Verständnis Problem mit AVR und Float

[Peter (Gast)]

Hallo Gemeinde,
ich habe da ein Problemchen beim Rechnen mit AVR und Float.
Ich möchte eine Zahl z.b. 56 in ihre Einzelteile zerlegen also in die 5 
und die 6.
Also dachte ich mich, ich baue aus der 56 ein Float also 56.00. Dann 
Teile ich die 56 durch 10. Erhalte da 5.6. Als int-Variable also eine 5. 
Nun ziehe auch von den 5.6 den int-Wert als Float ab. Also 5.6 - 5.0. 
Erhalte da 0.6. Diese Rechne ich nun mal 10. Erhalte da 6.0 So weit so 
gut. Nun möchte ich aber aus diesem Float wieder ein Int bilden.  Aber 
egal wie ich es probiere, ich erhalte immer eine 5? Was ist da los?

int Wert1;
int Wert2;
float WertZwischen;
float WertZwischen2;

void setup()
{
Serial.begin(9600);
}

void loop()
{
Wert = 56;
WertZwischen = (float)Wert;
Wert /= 10; // Wert ist nun 5
Serial.Println(Wert);
WertZwischen2 = (float)Wert;
WertZwischen -= WertZwischen2; // WertZwischen ist nun 0.6
WertZwischen += 10.00; // WertZwischen ist nun 6.00
Serial.Println(WertZwischen); // Kontrolle dass WertZwischen auch 6.00 ist
Wert2 = (int)WertZwischen; //Wert Sollte jetzt 6 sein ist aber 5!
Serial.Println(Wert2);
while(1)
{}
}

[Fabian O. (xfr)]

Keine gute Idee. Bei float können ganz schnell Rundungsfehler auftreten, 
die dann zu solchen Ergebnissen führen. Außerdem kosten die Routinen auf 
dem AVR viel Programmspeicher und Rechenzeit.

Was Du brauchst ist vermutlich der Modulo-Operator (%):

int wert = 56;
int zehner = wert / 10; // 5
int einer  = wert % 10; // 6

[Andreas B. (andreas_b77)]

Peter schrieb:
> WertZwischen -= WertZwischen2; // WertZwischen ist nun 0.6

WertZwischen ist jetzt 51. Oder da fehlt einiges an Code.

Abgesehen davon, wozu float? Das geht doch alles einfach in int.

int wert = 56;
int zehner, einer;

einer = wert % 10;
zehner = wert / 10;

[Peter (Gast)]

Probier ich morgen gleich mal aus aber klingt ja Super :) Danke

[Falk B. (falk)]

Siehe Festkommaarithmetik

[Yalu X. (yalu) (Moderator)]

(56.0 / 10.0 - 5.0) * 10.0

ist – in 32-Bit-FP gerechnet – leider nicht 6, sondern

5.99999904632568359375

In int umgewandelt, ergibt dies 5.

Abhilfe:

Runden mit der round-Funktion vor der Umwandlung in int.

Oder besser: Alle Berechnungnen in Integer durchführen, es gibt dafür 
die ganzzahlige Division '/' und die Modulofunktion '%' (zur Berechnung 
des Divsionsrests). Siehe Beiträge von Fabian und Andreas.

Oder du nutzt die Funktion itoa, die eine Integer-Zahl in einen String 
aus Ziffern umwandelt.

[Peter (Gast)]

Yalu X. schrieb:
> ist – in 32-Bit-FP gerechnet – leider nicht 6, sondern
> 5.99999904632568359375


Danke für die schnelle Hilfe. Aber wie kommt man auf die Lösung oben?

[Fabian O. (xfr)]

Peter schrieb:
> Yalu X. schrieb:
>> ist – in 32-Bit-FP gerechnet – leider nicht 6, sondern
>> 5.99999904632568359375
>
> Danke für die schnelle Hilfe. Aber wie kommt man auf die Lösung oben?

Kannst Du einfach am PC ausprobieren:

#include <stdio.h>

int main(void)
{
  float x = 56.0;
  x /= 10.0;
  x -= 5.0;
  x *= 10.0;
  printf("Ergebnis: %.20f\n", x);
}

Ausgabe:

Ergebnis: 5.99999904632568359375

Die Berechnung oben geht übrigens auch ohne Modulo:

int wert = 56;
int zehner = wert / 10;          // 5
int einer  = wert - zehner * 10; // 6

Merke: In den meisten Mikrocontroller-Programmen kommt man sehr gut ohne 
float aus. In diesem Fall braucht man noch nicht mal Kommazahlen.

[Peter (Gast)]

So gehts auch :) Ich muss wohl mehr denken ab und an :D
DANKE

[Werner (Gast)]

Fabian O. schrieb:
> Kannst Du einfach am PC ausprobieren:

Ach, kann man jetzt mit float 20 Nachkommastellen darstellen und 
anzeigen?
Selbst mit double wäre diese printf noch reiner Mumpitz.

[Yalu X. (yalu) (Moderator)]

Fabian O. schrieb:
> Peter schrieb:
>> Yalu X. schrieb:
>>> ist – in 32-Bit-FP gerechnet – leider nicht 6, sondern
>>> 5.99999904632568359375
>> Danke für die schnelle Hilfe. Aber wie kommt man auf die Lösung oben?
>
> Kannst Du einfach am PC ausprobieren:

Genau das habe ich auch gemacht.

Wer's im Detail nachrechnen will:

32-Bit-FP-Zahlen haben nach IEEE 754 eine Mantissengenauigkeit von 24 
Bit (davon werden allerdings nur 23 Bit gespeichert, da das 
höchstwertige Bit auf Grund der Normierung immer 1 und damit ohne 
Informationsgehalt ist).

Im Folgenden sind einzelnen Rechenschritte im Dualsystem dargestellt:

r1 = 56      = 111000.000000000000000000
r2 = r1 / 10 =    101.100110011001100110011       Ergebnis wird auf 24 Stellen gerundet
r3 = r2 - 5  =       .100110011001100110011000    Ergebnis wird auf 24 Stellen aufgefüllt
r4 = r3 * 10 =    101.111111111111111111110

             = 6 - 2 ** (-20) = 5.99999904632568359375

Jedes Zwischenergebnis wird entweder auf 24 Stellen gerundet oder mit 
Nullen auf 24 Stellen aufgefüllt. Der Rundungsfehler entsteht im zweiten 
Schritt, da 56/10 im Dualsystem eine nichtabbrechende periodische 
Darstellung hat.

Werner schrieb:
> Ach, kann man jetzt mit float 20 Nachkommastellen darstellen und
> anzeigen?

Klar kann man das.

> Selbst mit double wäre diese printf noch reiner Mumpitz.

Normalerweise ja. Aber hier geht es ja gerade darum, den Rundungsfehler 
aufzuzeigen. Und den sieht man erst, wenn man mehr Stellen anzeigen 
lässt, als es der Rechengenauigkeit entspricht.