ESP32 und C++, Nachkommastellen verschwinden

[Thilo G. (thilo_g)]

Hallo,
ich versuche gerade für den ESP32 aus der Arduino-IDE heraus eine 
Berechnung zu realisieren. Eigentlich ganz simpel, allerdings werden 
unerwünschterweise die Nachkommastellen gerundet ... kann mir jemand 
einen Tipp geben?

Die Eingangswerte stammen im Byte-Format von der RTC, irgendwo muss ich 
also casten. Unterhalb von "D= ..." sollte die berechnung in einer Zeile 
erfolgen, ich hab das jetzt nur zur Fehlereingrenzung auf Einzelschritte 
gesplittet:

float julianDate(byte gYear, byte gMonth, byte gDay, byte gHour, byte gMinute, byte gSecond)
{
    int Y, M, B;
    float D, ret;
    float T1, T2, T3, T4, T5;

    if (gMonth > 2)
    {
        Y = gYear + 2000;
        M = gMonth;
    }
    else
    {
        Y = gYear + 2000 - 1;
        M = gMonth + 12;
    }

    B = 2 - Y / 100 + Y / 400;        // Ganzzahl!

    D = gDay + (gHour * 3600 + gMinute * 60 + gSecond) / (float)86400;

    T1 = floor(365.25*(static_cast<float>(Y)+4716.0));
    Serial.printf("T1: %f\r\n", T1);
    T2 = floor(30.6001*(static_cast<float>(M)+1.0));
    Serial.printf("T2: %f\r\n", T2);
    T3 = D;
    Serial.printf("T3: %f\r\n", T3);
    T4 = static_cast<float>(B);
    Serial.printf("T4: %f\r\n", T4);
    T5 = 1524.5f;
    Serial.printf("T5: %f\r\n", T5);

    ret = T1;
    Serial.printf("ret1: %f\r\n", ret);
    ret = ret + T2;
    Serial.printf("ret2: %f\r\n", ret);
    ret = ret + T3;
    Serial.printf("ret3: %f\r\n", ret);
    ret = ret + T4;
    Serial.printf("ret4: %f\r\n", ret);
    ret = ret - T5;
    Serial.printf("ret5: %f\r\n", ret);

    return ret;
}

Ein Beispiel der mitgeloggten Zwischenergebnisse:

T1:   2460689.000000
T2:   183.000000
T3:   13.451875
T4:   -13.000000
T5:   1524.500000
ret1: 2460689.000000
ret2: 2460872.000000
ret3: 2460885.500000
ret4: 2460872.500000
ret5: 2459348.000000

T3 wird richtig mit reichlich Nachkommastellen berechnet, beim 
Aufsummieren wird plötzlich gerundet, was mache ich da falsch?

Grüße
Thilo

[N. M. (mani)]

Auch float hat nur einen begrenzten Dynamikbereich den du hier knackst.
Bei ret3 sieht man das gut. Du erwartest was mit vielen 
Nachkommastellen. Durch die große Zahl ist dies allerdings nicht mehr 
möglich, deshalb sind die Nachkommastellen "gerundet".

Gib Mal hier [1] eine Zahl wie 2460885.451875 ein und drück auf Enter. 
Dann siehst du das Problem.

[1]  https://www.h-schmidt.net/FloatConverter/IEEE754.html

[erklehr behr (Gast)]

Thilo G. schrieb:
> was mache ich da falsch?

Du denkst dass Float beliebig viele Stellen genau ist.

Jetzt erkläre mir bitte was Float Zahlen in Datums-Berechnungen
zu suchen haben.

[Thilo G. (thilo_g)]

N. M. schrieb:
> Gib Mal hier [1] eine Zahl wie 2460885.451875 ein und drück auf Enter.
> Dann siehst du das Problem.
>
> [1]  https://www.h-schmidt.net/FloatConverter/IEEE754.html

Danke dir, daran hab ich natürlich nicht gedacht ...

Grüße
Thilo

[Michael D. (nospam2000)]

Thilo G. schrieb:
> T3 wird richtig mit reichlich Nachkommastellen berechnet, beim
> Aufsummieren wird plötzlich gerundet, was mache ich da falsch?

Wie viele signifikante Stellen erwartest du von einer 32-Bit 
Flieskommazahl?

Du hast eine Mantisse von 23 Bit, damit wären Integerzahlen von grob +-4 
Millionen darstellbar.
Die Zahl 2460689 schöpft fast schon das Maximum aus, da bleibt für die 
Nachkommastellen nicht mehr viel übrig, genau gesagt ein Bit und das ist 
genau das was du siehst.

Wenn du genauere Ergebnisse benötigst, dann musst du double anstatt 
float verwenden, nur weiß ich nicht, ob der ESP32 dies überhaupt 
unterstützt.

Alternativ: verwende Festpunkt-Arithmetik.

  Michael

[Thilo G. (thilo_g)]

erklehr behr schrieb:
> Jetzt erkläre mir bitte was Float Zahlen in Datums-Berechnungen
> zu suchen haben.

Das will mal eine Teleskopnachführung werden, da brauche ich für die 
weiteren Berechnungen das Julianische Datum incl. Tagesbruchteilen. Da 
ich die begrenzte Genauigkeit von float nicht auf dem Schirm hatte, muss 
ich jetzt erstmal sehen, wie ich das sinnvoll löse.

Grüße
Thilo

[Michael D. (nospam2000)]

Michael D. schrieb:
> Wenn du genauere Ergebnisse benötigst, dann musst du double anstatt
> float verwenden

Du hast Glück, der ESP32 unterstützt wohl tatsächlich double Zahlen: 
https://blog.classycode.com/esp32-floating-point-performance-6e9f6f567a69

  Michael

[Thilo G. (thilo_g)]

Michael D. schrieb:
> Wenn du genauere Ergebnisse benötigst, dann musst du double anstatt
> float verwenden, nur weiß ich nicht, ob der ESP32 dies überhaupt
> unterstützt.

Ich hab's mal schnell probiert, es funktioniert mit double. Allerdings 
werde ich mir das Timing mal noch in Ruhe ansehen, der ESP32 bekommt ja 
noch deutlich mehr zu rechnen und soll sekündlich aktualisieren. Aber da 
ich jetzt weiß, wo es geklemmt hat, werde ich die nächsten Tage mal den 
kompletten Rechenumfang grob zusammenbauen, um zu sehen, ob er's schafft 
oder ich anders rangehen muss.

Grüße
Thilo

[Wolfgang (Gast)]

Thilo G. schrieb:
> Das will mal eine Teleskopnachführung werden, da brauche ich für die
> weiteren Berechnungen das Julianische Datum

Warum musst du dich unbedingt auf den 1. Januar −4713 v. Chr. beziehen.
Meist wird das Problem umgangen, indem man nicht das Julianische Datum, 
sondern das Modifizierte Julianische Datum verwendet. Um mehr 
Nachkommastellen zur Verfügung zu haben, gibt es auch noch den Typ 
double

$$\textit{MJD} = \textit{JD} - 2{.}400{.}000{,}5$$

[N. M. (mani)]

Mit JD*1000 hättest du in einem uint32 bereits 3 Nachkommastellen.
Wenn du mehr brauchst wäre es vllt sinnvoll Ganztage und Tagesbruchteile 
zu trennen und für die Tagesbruchteile eine geeignete Normierung zu 
verwenden.
z.B.

struct tJulianDate
{
uint32_t u32Days;
uint16_t u16DayFrac;
}

Gekapselt in einer Klasse könntest du auch die Operatoren überladen um 
damit leicht rechnen zu können.

[Michael D. (nospam2000)]

Thilo G. schrieb:
> werde ich mir das Timing mal noch in Ruhe ansehen, der ESP32 bekommt ja
> noch deutlich mehr zu rechnen und soll sekündlich aktualisieren

Dazu hier noch ein interessanter Artikel, vor allem zu Thema Division 
und den Libraries welche man verwenden sollte:
https://blog.llandsmeer.com/tech/2021/04/08/esp32-s2-fpu.html

Es kann sogar schneller sein, wenn du double anstatt float verwendest.

Ein mal pro Sekunde ist jetzt nicht wirklich eine Herausforderung :-)

 Michael

[Wolfgang (Gast)]

N. M. schrieb:
> Mit JD*1000 hättest du in einem uint32 bereits 3 Nachkommastellen.

Die Erde dreht sich in einem Tag um 360°. Wenn man da auf etwa eine 
Bogensekunde genau positionieren möchte, braucht man mindestens 6 
Nachkommastellen.

[N. M. (mani)]

Wolfgang schrieb:
> Die Erde dreht sich in einem Tag um 360°. Wenn man da auf etwa eine
> Bogensekunde genau positionieren möchte, braucht man mindestens 6
> Nachkommastellen.

OK danke für die Info. Die Bogensekunden ist rein Erfahrungswert was man 
für das Fotografieren benötigt? Oder woher kommen die? Rein Interesse 
halber.

[Thomas G. (Firma: Frickelhauptquartier) (taximan)]

Thilo G. schrieb:
..., da brauche ich für die
> weiteren Berechnungen das Julianische Datum incl. Tagesbruchteilen. Da
> ich die begrenzte Genauigkeit von float nicht auf dem Schirm hatte, muss
> ich jetzt erstmal sehen, wie ich das sinnvoll löse.
>
> Grüße
> Thilo

UNIX-Zeit verwenden?

[thilo_g (Gast)]

Danke nochmal an alle, ich kenne da nun meine Baustellen und werde mir 
die Lösungsvorschläge in Ruhe ansehen.
Ich will mir letzten Endes nur die Ist-Koordinaten anzeigen lassen - 
umschaltbar in drei unterschiedlichen Koordinatensystemen - um damit 
gezielt Objekte anfahren zu können.
Die erforderliche Auflösung fürs Fotografieren soll der Schrittantrieb 
unabhängig davon erreichen. Da muss dann nur die Interruptfrequenz zur 
Untersetzung incl. Mikroschritten passen.

Einen schönen Feiertag an alle!
Thilo