Rechnen mit Datum (localtime,ctime etc) bei Mikros

[Christian J. (Gast)]

Hallo,

einiges klappt schon aber anderes leider noch nicht.

Ich habe im 32 Bit Register eines STM32F103 die aktuelle Epoch Time und 
kann diese auch umrechnen in ein normales Zeitformat.

Zur Zeit rechne ich UTC in MEZ+1 derart um, dass ich 3600s drauf addiere 
und localtime die Arbeit machen lasse. Zieht gut 2kb extra an Code dazu 
aber 128kb habe ich ja sowieso.

Nun gibt es aber in der time.h Lib auch die Funktion tzset mit der man 
angeblich einstellen kann in welcher Zeitzone man sich befindet und wann 
die Sommerzeit beginnt. Schaut man im POSIX Stndard nach wird da vom 
Umgebungsvariablen gesprochen, die da gesetzt sind. Natürlich hat ein UC 
sowas nicht. tzset wird aber in time.h als LIB Funktion referenziert, 
leider ohne Parameter. Auch gmtime, ctime usw sind alle da, man kann 
sich aus der Epoch Time poroblemlos einen String bauen lassen.

Hat da jemand ne Idee, wie ich mir die Wurschtelei das manuell 
umzurechnen wann die Sommerzeit beginnt, samt Korrektur etc sparen kann?

 void RTC_IRQHandler(void)
{
   #define MEZ +1

   struct tm *ptr;      // Zeiger auf Zeit Strktur
   time_t value;        // 32 Bit Unixzeit

  if (RTC_GetITStatus(RTC_IT_SEC) != RESET)
  {
        /* Unixzeit aus RTC lesen */
        value = (time_t)RTC_GetCounter();

        /* UTC +1h dazu addieren */
        value = value + (MEZ*3600);

        /* In Normalzeit UTC hh:mm:ss umwandeln */
        ptr = localtime(&value);

        /* Zeit in eigenen Struct holen */
        memcpy((void*)&mytime,ptr,sizeof(struct tm));  // mytime <- localtime Buffer

        /* Prüfe auf Sommerzeit */
        if (IsSummertime())
        {
            /* Zeit nochmal umrechnen SZ = +1H */
            value = value + 3600;
            /* In Normalzeit UTC hh:mm:ss umwandeln */
            ptr = localtime(&value);
            memcpy((void*)&mytime,ptr,sizeof(struct tm));  // mytime <- localtime Buffer
            mytime.tm_isdst = true;
        }

        /* Jahr richtig schreiben */
        mytime.tm_year += 1900;

        /* Zeitflags setzen, Minute, Stunde */
        f_sekunde = true;
        if (mytime.tm_sec == 0)
            f_minute = true;
        if (mytime.tm_min == 0)
            f_stunde = true;

        /* Clear Interrupt pending bit */
        RTC_ClearITPendingBit(RTC_FLAG_SEC);
  }
}

/* Prueft, ob es gerade Sommerzeit ist

   SZ beginnt am letzten Sonntag im März um  2.00 Uhr -> 3.00 Uhr
   und endet am letzten Sonntag im Oktober 3.00 Uhr -> 2.00 Uhr

   Monate ohne Sommerzeit:  Jan, Feb, November, Dezember.
   Monate mit Sommerzeit :  April, Mai, Juni, Juli, August, September
   Monate zu prüfen: März und Oktober

 */
_Bool IsSummertime() {

    /* Monate in denen keine Sommerzeit ist */
    if ((mytime.tm_mon < Maerz) || (mytime.tm_mon > Oktober))
        return false;

    /* Monate in denen sicher Sommerzeit ist */
    if ((mytime.tm_mon > April) && (mytime.tm_mon < Oktober))
        return true;

    /* Nur Maerz und Oktober bleiben übrig, prüfen auf 3.ten Sonntag */
    if (mytime.tm_wday == 0) {
        /* Es ist Sonntag ... */
        if (31 - mytime.tm_mday < 8) {
             /* Sonntag liegt nahe dem Monatsende */
             if (mytime.tm_mon == Maerz)
                if (mytime.tm_hour >= 2);
                    return true;

             if (mytime.tm_mon == Oktober)
                if (mytime.tm_hour < 2);
                    return true;
        }

    }

    return false;

}

[Frank M. (ukw) (Moderator)]

Ich wüsste nicht, dass es einfacher geht. Ich benutze für die 
WordClock mit WS2812 eine ähnliche Routine, welche Du für Deine 
Berechnungen offenbar als Vorlage genommen hast, denn die Ähnlichkeiten 
sind unverkennbar ;-)

Jedoch ist in Deiner Funktion ein Fehler:

if (31 - mytime.tm_mday < 8) {

Der letzte Sonntag im März ist immer im Bereich vom 25. bis 31. März, 
das sind die letzten 7 Tage.

Wenn der Sonntag auf den 24.03. fällt, ist wegen 31 - 24 = 7

if (31 - mytime.tm_mday < 8) {

der obige Ausdruck wahr, obwohl in diesem Fall der 31. März und nicht 
der 24. März der letzte Sonntag ist.

Schreibe besser:

if (mytime.tm_mday >= 25) {

Da sieht man auf den ersten Blick, dass es nur Tage zwischen dem 25. und 
31. März sein können und muss nicht erst rechnen.

EDIT:

Du hast noch einen weiteren Fehler drin: Du prüfst nur auf Sonntage im 
März. Was ist mit einem Montag, wie z.B. der 27.03. in diesem Jahr? 
Komischerweise hast Du da die if-Bedingungen umsortiert - offenbar um 
den Source zu vereinfachen. Dabei hast Du aber einiges "wegoptimiert", 
was hätte stehen bleiben müssen.

Hier das Original:

    uint_fast8_t    summertime = 0;
    ...
    // calculate summer time:
    if (mytm->tm_mon >= 3 && mytm->tm_mon <= 8)                             // april to september
    {
        summertime = 1;
    }
    else if (mytm->tm_mon == 2)                                             // march
    {
        if (mytm->tm_mday - mytm->tm_wday >= 25)                            // after or equal last sunday in march
        {
            if (mytm->tm_wday == 0)                                         // today last sunday?
            {
                if (mytm->tm_hour >= 2)                                     // after 02:00 we have summer time
                {
                    summertime = 1;
                }
            }
            else
            {
                summertime = 1;
            }
        }
    }
    else if (mytm->tm_mon == 9)                                             // it's october
    {
        summertime = 1;

        if (mytm->tm_mday - mytm->tm_wday >= 25)                            // it's after or equal last sunday in october...
        {
            if (mytm->tm_wday == 0)                                         // today last sunday?
            {
                if (mytm->tm_hour >= 3)                                     // after 03:00 we have winter time
                {
                    summertime = 0;
                }
            }
            else
            {
                summertime = 0;
            }
        }
    }
    ...

[Christian J. (Gast)]

Hi Frank,

danke für die Tips. Nee, ich habe nix abgeschaut, das ist alles bisher 
mein Werk und ähnlich ist es sicherlich irgendwo. Bin alle Monate 
durchgegangen, das >=24 hatte ich schon eingefügt, da der letzte Sonntag 
maximal 7 Tage entfernt sein kann.

Mit den ersten beiden ifs hole ich alles raus bis auf März und Ooktober.
Ok, habe da was vertauscht, hast recht, die ifs müssen verdreht werden.

Ganze easy kann man sich das auch machen, wenn man sich bis Ende 2039 
alle Epoch Times heraussuchen lässt, wo die Umstellung passiert. Ich 
vermute zwar, dass wir 2039 andere Sorgen haben (oder gar keine mehr, 
weil wir tot sind) aber so geht es auch.

2017: 1490580000 und 1509242400
2018: usw...

März und Oktober kann man aber gleich behandeln, beide 31 Tage, beide 
bis auf die Stunde der gleiche Tag der Umstellung.

Ich melde mich später nochmal...

Gruss,
Christian

[Christian J. (Gast)]

PS: Ist doch etwas komplizierter, da man das nicht auf einen Zeitpunkt 
festmachen darf. Ich kann ja zwischendurch auch mal resetten auf dem 
Montag nach dem Umschalt Sonntag oder an dem Sonntag ist die Uhr aus und 
dann würde meine Rechnung keine Sommerzeit liefern in den Tagen danach. 
Muss noch etwas nachdenken. Ich möchte globale Entweder-Oder-Switch 
Flags vermeiden, eben wegen dem Reset.

Das ist bei Dir allerdings auch so!

Schaltest Du die Uhr erst im Oktober am Montag nach dem Wechsel ein 
bleibt Dein Flag auf Sommerzeit stehen.

Schätze mal einfacher ist es wirklich sich die Unix Zeiten aller Tage 
raus zu suchen und in eine Tabelle zu packen.

[Marc V. (Firma: Vescomp) (logarithmus)]

Christian J. schrieb:
> März und Oktober kann man aber gleich behandeln, beide 31 Tage, beide
> bis auf die Stunde der gleiche Tag der Umstellung.

 Wie das ?

 Hier, das ist besser und schneller:

;*** 2015 => 2050 - März
.db  29, 27, 26, 25, 31, 29, 28, 27, 26, 31,  30, 29, 28, 26, 25, 31, 30, 28, 27, 26,  25, 30, 29, 28, 27, 25, 31, 30, 29, 27,  26, 25, 31, 29, 28, 27

;*** 2015 => 2050 - Oktober
.db  25, 30, 29, 28, 27, 25, 31, 30, 29, 27,  26, 25, 31, 29, 28, 27, 26, 31, 30, 29,  28, 26, 25, 31, 30, 28, 27, 26, 25, 30,  29, 28, 27, 25, 31, 30

[Christian J. (Gast)]

Habe ich früher auch so gemacht, noch einfacher wie gesagt mit den Unix 
Zeiten, da reduziert es sich auf einen einzigen Vergleich :-)

[Frank M. (ukw) (Moderator)]

Christian J. schrieb:
> Das ist bei Dir allerdings auch so!

Nein, da hast Du meinen Code zu flüchtig gelesen.

> Schaltest Du die Uhr erst im Oktober am Montag nach dem Wechsel ein
> bleibt Dein Flag auf Sommerzeit stehen.

Hier nochmal der Block ab Oktober:

    else if (mytm->tm_mon == 9)                                             // it's october
    {
        summertime = 1;

        if (mytm->tm_mday - mytm->tm_wday >= 25)                            // it's after or equal last sunday in october...
        {
            if (mytm->tm_wday == 0)                                         // today last sunday?
            {
                if (mytm->tm_hour >= 3)                                     // after 03:00 we have winter time
                {
                    summertime = 0;
                }
            }
            else
            {
                summertime = 0;
            }
        }
    }

Am Montag nach der Zeitumstellung wird der letzte else-Block 
durchlaufen: summertime = 0;

Vergleiche mal den Block für März mit dem Block für Oktober: Während ich 
im März das Flag bedingt setze, setze ich es im Oktober bei gleichen 
(bzw. ähnlichen) Bedingungen zurück, mache also genau das Gegenteil.

Beachte auch, dass ich immer den Wochentag bei der Berechnung mit 
einbeziehe:

if (mytm->tm_mday - mytm->tm_wday >= 25)

Bei Dir steht da immer nur:

if (mytm->tm_mday >= 25)    // nach Umstellung der Terme

Das ist zu kurz gedacht. Bei Dir ist alles ab dem 25. schon vorbei, egal 
ob der letzte Sonntag noch kommt oder bereits vorüber ist.

[Christian J. (Gast)]

Ok ;-)

Habe schon nen Knoten im Hirn wegen der vielen returns. Soll ja nicht 
heissen, ich hatte abgeschrieben. Obwohl die Subtraktionen ist gut, wäre 
ich jetzt nicht drauf gekommen. Hoffe ich habe es jetzt. Testen bin ich 
zu faul, das wäre ne Arbeit für Doofe da im Debugger alles per hand 
einzutragen. Werde aber Sonntag nachts mal aufstehen und schauen, ob das 
klappt.

PS: Es gibt diese Funktionen fertig in den StdLibs, aber leider wohl nur 
für PC's. Mit tzset erschlägt man das alles. Und localtime 
berücksichtigt das auch.

enum monat {Januar, Februar, Maerz, April, Mai, Juni, Juli, August,
            September, Oktober, November, Dezember};

enum Wochentag {Montag,Dienstag,Mittwoch,Donnertag,Freitag,Samstag,Sonntag};

_Bool IsSummertime()
{

    /* Monate in denen keine Sommerzeit ist */
    if ((mytime.tm_mon > Oktober) || (mytime.tm_mon < Maerz))
        return false;

    /* Monate in denen sicher Sommerzeit ist */
    if ((mytime.tm_mon > Maerz) && (mytime.tm_mon < Oktober))
        return true;

    /* Nur Maerz und Oktober bleiben übrig, prüfen auf letzten Sonntag */
    if (mytime.tm_mon == Maerz)
    {
        /* Sonntag muss nach oder auf dem 25.ten liegen */
        if ((mytime.tm_mday - mytime.tm_wday) >= 25)
        {
            if (mytime.tm_wday == Sonntag)
            {
                if (mytime.tm_hour >= 2)
                    return true;

                /* Vor 2 Uhr keine Sommerzeit */
                return false;
            }
            /* Alle Tage > Sonntag sind Sommerzeit */
            return true;
        }
        return false;
    }

    if (mytime.tm_mon == Oktober)
    {
        /* Sonntag muss nach oder auf dem 25.ten liegen */
        if ((mytime.tm_mday - mytime.tm_wday) >= 25)
        {
            if (mytime.tm_wday == Sonntag)
            {
                if (mytime.tm_hour >= 3)
                    return false;

                /* Vor 3 Uhr keine Normalzeit */
                return true;
            }
            /* Alle Tage nach Sonntag sind Normalzeit */
            return false;
        }
        /* Oktober ist eingangs SZ */
        return true;
    }


    return false;

}

[Frank M. (ukw) (Moderator)]

Christian J. schrieb:
> enum Wochentag
> {Montag,Dienstag,Mittwoch,Donnertag,Freitag,Samstag,Sonntag};
> ...
>             if (mytime.tm_wday == Sonntag)

Das ist ebenso falsch. Laut Definition von tm_wday beginnt die Woche mit 
Sonntag, also Sonntag = 0, Montag = 1 usw.

Schreibe also:

enum Wochentag {Sonntag, Montag,Dienstag,Mittwoch,Donnertag,Freitag,Samstag};

Sonst kommt da absoluter Quark raus.

[Christian J. (Gast)]

Tschuldigung....... :-( duckundwech

[Marc V. (Firma: Vescomp) (logarithmus)]

Christian J. schrieb:
> Habe ich früher auch so gemacht, noch einfacher wie gesagt mit den Unix
> Zeiten, da reduziert es sich auf einen einzigen Vergleich :-)

 Schneler und einfacher als lesen aus der Tabelle ?

 SchaltTag = MonatsTabelle[year-2015]

 Ausserdem prüfst du das Ganze in _Bool IsSummertime(), da ist aber
 mehr als nur ein Vergleich drin.


 P.S.
 Und _Bool IsSummertime() wird bei dir immer aufgerufen, nicht nur in
 März und Oktober. Ich würde die Monatsabfrage vor dem Aufruf machen.

[Christian J. (Gast)]

Ich glaube, die paar Takte spielen bei einem 72 Mhz Cortex keine Rolle 
und der Aufruf passiert nur jede Sekunde einmal. Für eine derarrt lahme 
Anwendung wie ich sie habe, die maximal alle paar Stunden überhaupt 
Leben zeigt ist das egal. Die SleepTime beträgt unendlich, aufwachen tut 
er nur wenn ein INT kommt.

[Marc V. (Firma: Vescomp) (logarithmus)]

Christian J. schrieb:
> Ich glaube, die paar Takte spielen bei einem 72 Mhz Cortex keine Rolle
> und der Aufruf passiert nur jede Sekunde einmal. Für eine derarrt lahme
> Anwendung wie ich sie habe, die maximal alle paar Stunden überhaupt

 Du hast mit einfacher und schneller angefangen und gefragt:
Christian J. schrieb:
> Hat da jemand ne Idee, wie ich mir die Wurschtelei das manuell
> umzurechnen wann die Sommerzeit beginnt, samt Korrektur etc sparen kann?

 Und jetzt auf einmal ist die benötigte Zeit und Wurschtelei nicht mehr
 wichtig ?


 Und meine Frage steht immer noch:
Christian J. schrieb:
> März und Oktober kann man aber gleich behandeln, beide 31 Tage, beide
> bis auf die Stunde der gleiche Tag der Umstellung.

  Wie das ?

[Christian J. (Gast)]

@Frank:

Vielleicht kannste das ja noch gebauchen, Berechnung der Sonnenaufgangs 
und Untergangszeit auf 5 Minuten genau. Klappt prima.

typedef struct
{
    uint8_t SAG_Std,        // Sonnenaufgang h
            SAG_Min,        // Sonnenaufgang min
            SUG_Std,        // Sonnenuntergang h
            SUG_Min;        // Sonnenuntergang min

    float   f_SAG,          // Sonnenaufgang float Wert zB 7,32 Uhr
            f_SUG,
            f_Tagdauer;
} sonnenstand_t;

////////////////////////////////////////////////////////////////////////////////////
/*
    Funktion:   CalcSonnenAufgang()
    Modul   :   rtc_user.c
    --------------------------------------------------------------------------------
    Beschreibung           : Berechnet den Sonnenaufgang und Untergang (auf 5 Minuten genau)

    Zeitgleichung:          WOZ - MOZ = -0.171*sin(0.0337 * T + 0.465) - 0.1299*sin(0.01787 * T - 0.168)
                            Deklination = 0.4095*sin(0.016906*(T-80.086))
                            Zeitdifferenz = 12*arccos((sin(h) - sin(B)*sin(Deklination)) / (cos(B)*cos(Deklination)))/pi;
                            Sonnenaufgang h=-50 Bogenminuten = -0.0145

                            Aufgang Ortszeit = 12 - Zeitdifferenz - Zeitgleichung
                            Untergang Ortszeit = 12 + Zeitdifferenz - Zeitgleichung

                            Aufgang = Aufgang Ortszeit - geographische Länge /15 + Zeitzone
                            Untergang = Untergang Ortszeit - geographische Länge /15 + Zeitzone

    aufgerufene Funktionen  : CalcDayOfYear(ptr);
                              IsSommerzeit();
    Eingabeparameter        : ptr           (Zeiger auf aktuelle Zeit für Sommerzeit)
                              sonne         (Zeiger auf Ergebnisstruktur
                              T             (Tag des Jahres)
    Rückgabe                : -
    veränderte Globals      : SAG_Std,SAG_Min, SUG_Std,SUG_Min

*/
////////////////////////////////////////////////////////////////////////////////////


uint8_t CalcSonnenAufgang(TM_RTC_Time_t *ptr,sonnenstand_t *sonne)
{
    #define hoehe   -0.0145     // Sonnenhöhe in RAD
    #define PI      3.141592654

    double  B,
            Deklination,        // Deklination der Sonne
            Zeitdiff,           // Zeitdifferenz
            DIFF_WOZ_MOZ,
            Aufgang_MOZ,        // Aufgang mittlere Ortzeit
            Untergang_MOZ,      // Aufgang mittlere Ortszeit
            Aufgang_WOZ,        // Aufgang wahre Ortszeit
            Untergang_WOZ;      // Untergang wahre Ortszeit


    uint16_t T;
    static  uint16_t oldvalue = 0;

    // Berechne des Tag des Jahres
    T = CalcDayOfYear(ptr);

    // Prüfen, ob Berechnungen für aktuellen Tag bereits vorliegen
    if (oldvalue == T)
         return 0;
    oldvalue = T;

    // Berechnungen
    B = PI *N_BREITE / 180;
    Deklination = 0.4095 * sin(0.016906 * (T-80.086));
    Zeitdiff = 12 * acos((sin(hoehe) - sin(B) * sin(Deklination)) / (cos(B) * cos(Deklination))) / PI;
    DIFF_WOZ_MOZ = -0.171 * sin(0.0337 * T + 0.465) - 0.1299 * sin(0.01787 * T - 0.168);    // WOZ-MOZ

    Aufgang_MOZ   = 12 - Zeitdiff - DIFF_WOZ_MOZ;
    Untergang_MOZ = 12 + Zeitdiff - DIFF_WOZ_MOZ;

    Aufgang_WOZ   = Aufgang_MOZ + (15 - O_LAENGE) * (double)4/60;
    Untergang_WOZ = Untergang_MOZ + (15 - O_LAENGE) * (double)4/60;

    // Sommerzeit berücksichtigen
    if (IsSommerzeit(ptr)) {
        Aufgang_WOZ = Aufgang_WOZ + 1;
        Untergang_WOZ = Untergang_WOZ + 1;
    }

    // globale double Werte setzen
    sonne->f_SAG = Aufgang_WOZ;
    sonne->f_SUG = Untergang_WOZ;
    sonne->f_Tagdauer = sonne->f_SUG - sonne->f_SAG;

    // Umrechnung in Stunden/Minuten
    sonne->SAG_Std = floor(Aufgang_WOZ);                    // Sonnenaufgang
    sonne->SAG_Min = (Aufgang_WOZ - (float)sonne->SAG_Std) * 60;

    sonne->SUG_Std = ceil(Untergang_WOZ)-1;             // Sonnenuntergang
    sonne->SUG_Min = (Untergang_WOZ - (double)sonne->SUG_Std) * 60;

    return 1;
}

[Jacko (Gast)]

Selbst in der Zeitrechnung kommt Mist heraus, wenn man
amerikanische Maßeinheiten und Konventionen benutzt!

Mit feet/meter-Problemen wurden vielversprechende, teure
Sonden in den Marsboden gerammt.

Und mit tm_wday beginnt die Woche am Sonntag, womit du in
Europa keinen Blumentopf gewinnen kannst, weil da ISO-8601
den Montag als Wochenanfang vorgibt.

Ist doch auch logisch: Sag mal die Wochentage auf:
Selbst im hintersten Kentucky fängt dabei jeder mit
"Monday" an.

Make REASON great again!

[Marc V. (Firma: Vescomp) (logarithmus)]

Jacko schrieb:
> Und mit tm_wday beginnt die Woche am Sonntag, womit du in
> Europa keinen Blumentopf gewinnen kannst, weil da ISO-8601
> den Montag als Wochenanfang vorgibt.

> Ist doch auch logisch: Sag mal die Wochentage auf:
> Selbst im hintersten Kentucky fängt dabei jeder mit
> "Monday" an.

 Hat doch eher mit der Bibel zu tun:

Am siebten Tag vollendete Gott das Werk, das er geschaffen hatte, und an diesem Tag ruhte er