Fehler im STM32F4?

[Uwe (Gast)]

Der Variablenwert ändert sich in der while Schleife normal, jedoch hört 
er dan mit f bei 256.0 auf. Der Code wird weiterhin abgeabeitet.
Meiner meinung nach müßte der Gülti wertebereich aber
von 1.5E-45 bis 3.4E38 gehen.

Habe folgenden Codeabschnitt der einfach in einer while-Schleife 
abgearbeitet wird :

  volatile float f=0,f2=0.00001;
  while(1) {
    f=f+f2;
  }

Wird vom Compiler so übersetzt :
136           volatile float f=0,f2=0.00001;
0x080004ac:   ldr r3, [pc, #24]       ; (0x80004c8 <main+140>)
0x080004ae:   str r3, [r7, #4]
0x080004b0:   ldr r3, [pc, #24]       ; (0x80004cc <main+144>)
0x080004b2:   str r3, [r7, #0]
138             f=f+f2;
0x080004b4:   vldr s14, [r7, #4]
0x080004b8:   vldr s15, [r7]
0x080004bc:   vadd.f32 s15, s14, s15
0x080004c0:   vstr s15, [r7, #4]
141           }
0x080004c4:   b.n 0x80004b4 <main+120>
0x080004c6:   nop

Wie man sieht ist der vector Floating Point aktiviert und funktioniert 
auch. Die wichtzigsten Compileroptionen sind:

 arm-none-eabi-gcc -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mthumb -Wall 
-ffunction-sections -O0 -mfloat-abi=hard -g -c -DHSE_VALUE=8000000 
-DSTM32F4XX -DUSE_STDPERIPH_DRIVER -DUSE_STM32F4_DISCOVERY -DSTM32F407VG

Was ist hier los ?
An Adresse 0x080004c4 wird wieder zu 0x080004b4 zurückgesprungen und das 
vadd.f32 wird auch als float ausgeführt. Anderer Code wird in dieser 
Zeit nicht ausgeführt.

[Uwe (Gast)]

Ja ne schon klar sind ja nur 8 Signifikante Dezimalstellen bei 0.00001 
kommt er nur bis 256.0 mit seinen 32 Bit. Bei 0.0001 kommt er bis 
2048.0. Alles klar oder hab ich nen Denkfehler ? Eine Multiplikation 
müßte aber gehen.

[Karl H. (kbuchegg)]

Uwe schrieb:

> Was ist hier los ?

die Anzahl der Mantissenbits reicht bei 256 nicht mehr aus, damit 
0.00001 nach der Normierung als von 0 verschieden dargestellt werden 
kann.

Ab da wird dann real 256.0 + 0 gerechnet und da kommt dann wieder 0 
raus.

Du hast soeben real erlebt, was die Aussage "Bei float ist mit 5 bis 6 
signifikanten Stellen zu rechnen" beispielsweise in der Praxis bedeuten 
kann.

Floating Point rechnen ist eben mehr und in den Details schwieriger als 
einfach nur einen Dezimalpunkt reinmachen.

[Uwe (Gast)]

Na ja bei Double hat man halt fast nie Probleme weil da genügend 
Signifikante Stellen drin sind. Das nimmt man halt irgendwann für 
gegeben.
Fällt halt so nur bei Additionen und Subtraktionen auf. Bei ner 
Multiplikation ist das schon ehr normal (auch bei Double), daß mal 
schnell nen Ergebnis 0 oder unendlich bzw. NAN wird.

[Alex E. (tecnologic)]

Moin Uwe,

du hast das erkannt. Der kann nur 256.0000 darstellen. die + 0.00001 
kann er nicht mehr darstellen. Deswegen sagt man ja auch das man für 
nummerische Stabilität bei Rechnungen mit Fließkommazahlen nie eine ganz 
kleine Zahl von/zu einer großen subtrahieren/addieren darf.

MfG

Tec