TMS320 Gleitkomma (Texas Instruments DSP von '98)

Hintergrund

Gibt es hier jemanden, der ein EE mit Programmiererfahrung ist und mit dem DSP der Texas Instruments TMS320 C3X-Serie gearbeitet hat? Ich arbeite gerade mit dem C3X für ein Projekt. Mein Ziel hier ist es, C3X-formatierte Gleitkomma- Hexadezimalwerte in das IEEE 754-Format zu konvertieren. Der Code, den ich habe, funktioniert ordnungsgemäß für:

Wobei x die eingegebene einzelne Gleitkomma-C3X-Hexadezimalzahl ist (dargestellt als UInt32).

Das Problem ist, wenn ich versuche, eine Zahl wie 0.123 zu verwenden . Es scheint, dass ich dadurch immer einen NaN- Wert bekomme . Ich verwende derzeit dieses Code-Snippet von der University of Florida , das ich auf C # portiert habe.

Verfahren

1. Tauschen Sie die Vorzeichen- und Exponentenfelder aus, um von C3X zu IEEE zu wechseln. Ich werde diesen Code nicht anzeigen (sofern nicht gefragt), da ich glaube, dass er für jeden, der mit diesem DSP gearbeitet hat, sehr einfach ist.
2. Führen Sie den Algorithmus der Universität von Florida (oben verlinkt) aus, den ich meines Erachtens nicht vollständig verstehe.
3. Kombinieren Sie das Vorzeichen, den Exponenten und die Mantisse zu einem IEEE 754-Gleitkomma mit einfacher Genauigkeit.

C # -Implementierung

Hier ist der Code, der zum Implementieren des Algorithmus verwendet wird, wenn die C3X-Gleitkommazahl zufällig zwischen 0 und 1 liegt (wo das Problem auftritt). Das c30Objekt repräsentiert die C3X-Gleitkommazahl. Das ieeeObjekt repräsentiert die IEEE 754-Gleitkommazahl.

BEARBEITEN: Auf vielfachen Wunsch finden Sie hier ein Codebeispiel, das nicht schrecklich ist. Dieses Beispiel ist die ordnungsgemäß funktionierende Version, in der wir 15.913,35 ... (als C3X hexadezimal) ausgeben.

C30Float c30 = null;
UInt32 bias = 127;
Int32 mantissa = 0;
Int32 digit = 0;
double fraction = 0;
double exponent = 0;
double fpValue = 0;
double sign = 0;

// 1. Declare the new C3X floating point value.
c30 = new C30Float(0x0D78A56B);

// 2. Get the sign bit value.
sign = c30.GetSign();

// 3. Decide whether or not to do the flip.
if (sign == 1)
{
    // flip
    mantissa = c30.GetMantissa();
    mantissa = mantissa + 1;
    mantissa = (~mantissa) & 0x007FFFFF; // the first 9 bits have nothing to do with the mantissa
}
else
{
    mantissa = c30.GetMantissa();
}

// 4. Obtain part of the fraction (do the swim!).
for (int i = -1; i > -24; i--)
{
    // mantissa index
    int currentDigit = i + 23; // n = -23 + 23 => n = 0

    // shift forward (get the digit)
    digit = mantissa;
    digit = digit & (1 << currentDigit);

    // shift back (get the digit into the lowest place)
    digit = digit >> currentDigit;

    // apply the digit to the fraction
    fraction += digit * Math.Pow(2, i);
}

// 5. Obtain the exponential part of the number.
exponent = c30.GetExponent() + 0x7F;

// 6. Get the floating point number.
fpValue = Math.Pow(-1, sign);
fpValue *= (1 + fraction) * Math.Pow(2, exponent - bias);

Ich weiß , dass ich nicht haben , um die Umsetzung zu den nachfolgend genannten Leitlinien:

GetMantissa()
GetExponent()
GetSign()

oder...

SetMantissa()
SetExponent()
SetSign()

Der Grund dafür ist, dass alles, was diese tun, darin besteht, die Nummern in die jeweiligen Felder einzugeben / daraus zu ziehen, wie im TMS320 C3X-Benutzerhandbuch angegeben . Wer weiß, vielleicht mache ich hier einen Fehler, aber jetzt möchte ich dort beginnen, wo ich denke, dass der Umfang des Problems beginnt. Wenn einer von Ihnen der Meinung ist, dass das Problem nicht vorliegt, können Sie sich gerne nach dieser Implementierung erkundigen, und ich werde Ihnen bei Bedarf weitere Einzelheiten mitteilen.

Frage

Mein Problem liegt anscheinend bei Zahlen zwischen 0 und 1. Wenn also jemand C3X-Hex-Werte und deren bekannte Gegenstück-Floats / Reals kennt, die ich einstecken und tuckern kann, wäre das großartig, damit ich diesen Algorithmus beheben kann.

Hinweis: Wir haben den DSP nicht vor uns für das, was wir tun, und können nicht einfach die Zahlen herausholen.

Das TMS320C3x-Benutzerhandbuch listet einige Testwerte auf:

• Hex-Wert des C3X-Gleitkommawerts interpretiert als uint32 ~~ Entsprechender Gleitkommawert
• 0x02400000 ~~ +6.0 (siehe S. 5-10)
• 0x01C00000 ~~ -3.0 (siehe S. 5-11)
• 0xFB400000 ~~ (+3/64) (siehe S. 5-11)

Ich vermute, Sie möchten Code eher wie:

/*
Convert from single-precision TMS C3x floating point
to single-precision IEEE floating point.
2016-07-11: minor tweaks by David Cary
2016-03-21: StevieV

(see
http://electronics.stackexchange.com/questions/223832/tms320-floating-point-texas-instruments-dsp-from-98
http://etd.fcla.edu/UF/UFE0005060/tmsieeeconv.c
http://etd.fcla.edu/UF/UFE0005060/tmsieeeconv.h
)
*/

C30Float c30 = null;
Int32 mantissa = 0;
double exponent = 0;
double sign = 0;
double fpValue = 0;

// 1. Declare the new single precision C3X floating point value.
c30 = new C30Float(0x0D78A56B);

/*
We could have followed page 5-21 in the TMS320C3x User's Guide
http://www.ti.com/lit/ug/spru031f/spru031f.pdf
for C3X-->IEEE conversion.

But it seemed simpler to follow page 5-9
in the TMS320C3x User's Guide
"5.3.5 Determining the Decimal Equivalent of a TMS320C3x Floating-Point Format"
http://www.ti.com/lit/ug/spru031f/spru031f.pdf
*/

// 2. Break up the C3X floating value into its components
// (Assume that these 3 functions deal with endianness).
sign = c30.GetSign(); // either 0 (positive) or 1 (negative)
exponent = c30.GetExponent(); // a signed 8-bit integer, -128 to +127.
mantissa = c30.GetMantissa(); // a 23-bit unsigned integer

// insert implied most significant bit to the left of MSB of the mantissa.
mantissa = ((1 + sign) << 23) + mantissa;

// 6. Get the floating point number.
// Move the binary point left 22 places,
// then adjust further based on exponent.
// (Possibly something like ldexp() or BitConverter.ToSingle()
// would be more efficient).
fpValue = (-sign) * mantissa * Math.Pow(2, exponent - 22);
return fpValue;