Sommerzeit / Winterzeit - Sonnenaufgang / Sonnenuntergang

Hallo Leute!

Ich habe diese Sonnenaufgangs Funktion mySunrise.Actual(); //Actual, Civil, Nautical, Astronomical

Ich bekomme z.b. für meine Koordinaten die Zeiten 06:02 Uhr Aufgang und 19:09 Uhr Untergang.

laut internet sind diese Zeiten aktuell:

Sonnenaufgang: 06:59 Uhr
Sonnenuntergang: 20:09 Uhr

Die Sommerzeitumstellung ist nicht berücksichtigt. +1 Stunde

Hat jemand eine Idee wie ich die MESZ Zeitumstellung berücksichtige im Arduino Programm?

Sunrise mySunrise(50.8791, 6.6939, +1);

Eben diese +1 in dieser Funktion ist sehr wahrscheinlich der Fehler.
Sommerzeit = +2
Winterzeit = +1

Grüße, Stefan

Was genau suchst Du? Die Zeitpunkte für die Sommer/Winter Umstellung werden politisch festgelegt, dafür ist mir kein entsprechender Algorithmus bekannt, den man ins Programm einbauen könnte.

stevie72:
Sunrise mySunrise(50.8791, 6.6939, +1);

Eben diese +1 in dieser Funktion ist sehr wahrscheinlich der Fehler.
Sommerzeit = +2
Winterzeit = +1

So unbesehen, ohne dass Du vorzeigst, wo Du Deine Funktion geguttenbergt hast und wie diese genau aussieht, mal in meine Glaskugel geschaut:

Sieht ganz so aus.
So what?

Entweder rufst Du die Funktion während der Sommerzeit dann mit +2 auf und läßt die Funktion rechnen, oder Du rufst die Funktion mit +1 auf und rechnest während der Sommerzeit auf die errechneten Zeiten jeweils eine Stunde drauf. Da in ganz Deutschland die Sonne selbst bei Sommerzeit überall deutlich vor Mitternacht untergeht, sollte letzteres wie auch ersteres funktionieren.

Die Daten der Zeitumstellung stehen kalendermäßig fest (letzter Sonntag im März bzw. Oktober), also weißt Du genau, für welche Tage Du eine Stunde draufschlagen mußt und für welche nicht.

Folgendes Problem:

Ich kann diese Funktion nicht so einfach verwenden Sunrise mySunrise(50.8791, 6.6939, +1);
Gewiss ich habe noch eine DCF 77 Uhr diese könnte ich zusätzlich heranziehen und damit das bit auswerten welches Sommerzeit und Winterzeit anzeigt... aber ich dachte mir es muss doch eine praktikablere art geben als so einen umstand. Ich habe in der Tat auch schon daran gedacht den letzten Sonntag im März bzw. im Oktober auszuwerten. Das scheint mir in der Tat die einfachere Weise zu sein.
Hat denn niemand eine Idee für dieses Problem? Ich kann mir nicht vorstellen das ich als erster dieses Problem habe ...

Einen schönen Abend noch..

Stefan

kleiner Nachtrag: die Lib gibt´s hier ...

http://www.andregoncalves.info/ag_blog/?p=47

Stefan

Hallo,

also zuerst einmal, das Tehma interessiert mich auch...

Ich habe das vor einier Zeit mal komplett mit Tabellen realisiert. Also für ein Jahr für alle 365 Tage in eine Tabelle (wenn man will gleich mit dem Sprung für die Sommerzeit) und dann in einer weiteren Tabelle Korrekturwerte für die nächsten x Jahre in Abhängigkeit von der Jahreszahl.

Der Vorteil war daß so etwas ohne viel Mathematik auch auf sehr einfachen CPUs läuft solange man ein paar kB für die Tabellen hat...

Zu berücksichtigen ist aber auch: was passiert wenn an der Sommerzeit was geändert wird (Zeitpunkt) oder diese vielleicht ganz abgeschaff wird?

Edit: Eentuell kann man das Ganze intern einfach auf Normalzeit laufen lassen (Sommerzeit ignorieren) weil ja die Dämmerung auch nicht um eine Stunde "springt". Nur für eine eventuelle Anzeige auf einem Display kann man dann, wenn man möchte, die Sommerzeit umschalten. Hängt aber natürlich davon ab wo die Zeit herkommt (nur Quarz-RTC oder DCF77 oder GPS oder...) das macht durchaus einen Unterschied.

Christian

stevie72:
Hat denn niemand eine Idee für dieses Problem?

Welches Problem denn genau? Beschreibe doch mal!

Hast Du ein Problem, das Beispielprogramm zur Library zu verstehen?

Hast Du ein Problem, das Beispielprogramm zur Library fehlerfrei zu kompilieren, weil es ein altes .PDE Programm ist?

Hast Du ein Problem, Tag und Monat irgendwoher (RTC?) zu bekommen, um die Berechnung durchzuführen?

Oder hast Du ein Problem, nachdem Du für die Berechnung für Monat, Tag, UTC+1, Längengrad und Breitengrad durchgeführt und Auf-/Untergangszeiten bekommen hast, jeweils eine Stunde draufzuschlagen, falls es sich um einen Tag mit Sommerzeit handelt?

Ich habe aus Deinen bisherigen Erklärungen Dein Problem noch nicht so ganz verstanden.

Hallo Christian,

Bei mir soll die Sonnenuntergangs / Sonnenaufgangsfunktion in kombination mit einem BH1750 zu einer
Steuerrung für Rollladen werden. Ich habe diesen Weg gewählt um eine Variation zu ermölichen. Nur wenn
zwei Parameter erfült sind soll die Rolllade hoch oder runter fahren. Dadurch hat man eine "Art Anwesenheits Simulation... " weil die Rollladen nie zur selben Zeit hoch oder runter fahren.
Besonders interessant wird das im Herbst, wenn es früher dunkel wird.

Eine RTC habe ich auch die via DCF77 synchronisiert wird. Hat den Vorteil ich muss nichts mehr einstellen
bei Stromausfall oder bei der Zeitumstellung. Hier habe ich schon drüber nachdedacht das Bit für die Sommerzeitumstellung auszuwerten ... eine möglichkeit.
Ich denke ich werde mir eine weitere möglichkeit überlegen das ganze über eine funktion lösen bei der ich den letzten Sonntag im März bzw. im Oktober abfrage. Die möglichkeit diese Funktion über Software zu deaktivieren besteht
ja auch .. wenn man sich mal einig wird ob weiter Sommerzeit besteht oder nicht.. mal sehen was zum Einsatz kommt.

Deine variante klingt auch sehr gut. Aber man muss schon bei der Planung genug Speicher reservieren.
Den habe ich leider nicht.. .

Grüße,
Stefan

Hallo Jurs,

"Oder hast Du ein Problem, nachdem Du für die Berechnung für Monat, Tag, UTC+1, Längengrad und Breitengrad durchgeführt und Auf-/Untergangszeiten bekommen hast, jeweils eine Stunde draufzuschlagen, falls es sich um einen Tag mit Sommerzeit handelt? "

genau das ist die Nuss die ich knacken muss ..

Hier ist ein auszug aus meinem Code:

aus dem Header

#include <Sunrise.h> // Sonnenauf und Untergang berechnen

Sunrise mySunrise(50.9122, 6.8159, +1);

aus der setup:

mySunrise.Actual(); //Actual, Civil, Nautical, Astronomical
delay(10);

//***********************************************************************************************
// Display Funktion

void digitalClockDisplay() { // Ausgabe Datum und Zeit

tmElements_t tm; // tmElements Funktion wird gebraucht

display.clearDisplay(); // Display refresh
byte h, m;
int t;

//***********************************************************************************************
// Astro Sonnenaufgang und Sonnenuntergang

// ************ Aufgang

t = mySunrise.Rise(now.month(), now.day()); // (month,day) - january=1
h = mySunrise.Hour(); // h = stunden
m = mySunrise.Minute(); // m = minuten

display.setCursor(0, 0); // Position (x,y)
display.setTextSize(1); // Textgröße 1
display.setTextColor(BLACK); // Display Farbe schwarz
display.print("A"); // ein A für Aufgang ausgeben
display.setCursor(9, 0); // Position (x,y)

if (h < 10) // Wenn h (Stunden) kleiner als 10
{
display.print(0, DEC); // eine 0 Dezimal vorranstellen
}
display.print(h, DEC); // Dann die Stunden Dezimal ausgeben
display.print(":"); // Einen Doppelpunkt aufs Display
if (m < 10) // Wenn die Minuten kleiner 10 sind
{
display.print(0); // eine 0 Dezimal vorranstellen
}
display.print(m, DEC); // Dann die Minuten Dezimal ausgeben

//Serial.print(h, m);
//Serial.print(" ");

// ************ Untergang

t = mySunrise.Set(now.month(), now.day()); // (month,day) - january=1
h = mySunrise.Hour(); // h = stunden
m = mySunrise.Minute(); // m = minuten

display.setCursor(45, 0); // Position (x,y)
display.setTextSize(1); // Textgröße 1
display.setTextColor(BLACK); // Display Farbe schwarz
display.print("U"); // ein U für Untergang ausgeben
display.setCursor(54, 0); // Position (x,y)

if (h < 10) // Wenn h (Stunden) kleiner als 10
{
display.print(0, DEC); // eine 0 Dezimal vorranstellen
}
display.print(h, DEC); // Dann die Stunden Dezimal ausgeben
display.print(":"); // Einen Doppelpunkt aufs Display
if (m < 10) // Wenn die Minuten kleiner 10 sind
{
display.print(0); // eine 0 Dezimal vorranstellen
}
display.print(m, DEC); // Dann die Minuten Dezimal ausgeben

}

Ein Nokia 5110 Display habe ich verwendet.

ich hoffe das hilft weiter ...

Stefan

stevie72:
Eine RTC habe ich auch

Aha, jetzt wird es klarer: Also liefert eine RTC Datum und Tag, für den die Auf-/Untergangszeiten berechnet werden sollen.

In dem Fall schau Dir doch mal die einfache RTC-Library für DS1307 und DS3231 an, die ich heute hier ins deutschsprachige Forum gepostet habe. Die arbeitet so, dass die RTC generell auf UTC+1 läuft, und es gibt für die RTC zwei Auslesefunktionen:

  • RTCreadZoneTime(time) ==> liest Zonenzeit aus und setzt die Zeitzone auf 1
  • RTCreadLocalTime(time) ==> liest lokale Zeit aus und setzt Zeitzone auf 1 oder 2 (abhängig davon, ob gerade Sommerzeit herrscht)

Wenn Du diese Library mit Deiner Sonnenberechnungsfunktion für UTC+1 kombinierst, brauchst Du nur folgendes machen:

  • mit RTCreadZoneTime(time) die Zonenzeit UTC+1 auslesen
  • für dieses Datum Sonnenauf- und Untergang mit Deinem Objekt für UTC+1 berechnen
  • und dann die erhaltene Zeit mit der Zonenzeit vergleichen
    Dann siehst Du doch, ob Du mit der aktuellen UTC+1 Zeit vor Sonnenaufgang bist, zwischen Sonnenauf- und Sonnenuntergang, oder nach Sonnenuntergang.

Und ob es am selben Tag noch einen Sonnenaufgang und/oder Sonnenuntergang gibt oder nicht, und wie lange es bis dahin noch dauert, kannst Du durch Zeitvergleich leicht feststellen:
Wenn Du sowohl die Zonenzeit aus der RTC in UTC+1 ausgelesen hast als auch die Sonnenauf-/ -untergangszeit in UTC+1 berechnet hast, ist die Berechnung des Zeitunterschieds ja einfach.

Hallo Jurs,

vielen Dank ich habe mir gerade Deine Lib heruntergeladen und werde mal sehen wie ich damit zurande
komme. Was Du geschrieben hast das währe wohl die lösung!
Ich werde berichten.

Vielen Dank

Stefan

stevie72:
vielen Dank ich habe mir gerade Deine Lib heruntergeladen und werde mal sehen wie ich damit zurande
komme. Was Du geschrieben hast das währe wohl die lösung!
Ich werde berichten.

Ich habe da mal etwas vorbereitet...

Dazu habe ich mir zunächst mal eine Library für die Berechnung verschiedener Zeiten heruntergeladen und für den Arduino angepaßt, zur Berechnung von:

  • Morgendämmerung
  • Sonnenaufgang
  • Sonnenuntergang
  • Abenddämmerung
    Mit dem von Dir angegebenen Link und was man da downloaden kann, bin ich nicht zurechtgekommen.

Dann habe ich zusammen mit der von mir gerade erstellten RTC-Library mit automatischer Berücksichtigung von Sommer-/Winterzeit ein Demoprojekt mit zwei laufenden Tasks gemacht:

  • ein ständig laufender Task wartet auf serielle Befehle zur Zeiteinstellung
  • ein alle fünf Sekunden laufender Task liest die aktuelle Zeit aus und gibt auf Serial aus
  • aktuelle Zonenzeit
  • aktuelle lokale Zeit (mit ggf. Berücksichtigung von Sommerzeit)
  • Zeiten für Morgendämmerung, Sonnenaufgang, Sonnenuntergang, Abenddämmerung in lokaler Zeit
  • Zeit bis zum nächsten Sonnenaufgang (falls dieser am selben Tag erfolgt)
  • Zeit bis zum nächsten Sonnenuntergang (falls dieser am selben Tag erfolgt)
  • Tageslichtstatus: DAY, NIGHT oder TWILIGHT

Die verwendeten Libraries brauchen nicht extra installiert werden, sondern sind als "Tab" in das Projekt eingebettet. Einfach den im ZIP-Archiv enthaltenen Ordner im Arduino-Sketchordner entpacken.

Viel Spaß damit!

dateTimeLibEasyDemoSunrise.zip (7.27 KB)

Suuuper! Danke jurs!
Genau so etwas brauche ich demnächst.

Eine Frage noch zur "Dämmerung", es gibt ja verschiedene (bürgerliche, nautische, astronomische). Wenn ich "sunrise.h" richtig verstanden habe, dann wird da die "bürgerlichen Dämmerung" berechnet also Sonnenmittelpunkt 6 Grad unter Horizont. Oder?

Gruß
Udo

uxomm:
Eine Frage noch zur "Dämmerung", es gibt ja verschiedene (bürgerliche, nautische, astronomische). Wenn ich "sunrise.h" richtig verstanden habe, dann wird da die "bürgerlichen Dämmerung" berechnet also Sonnenmittelpunkt 6 Grad unter Horizont. Oder?

Ja, es wird die "bürgerliche" Dämmerung berechnet.

Also der Zeitpunkt, ab dem bzw. bis zu dem unter normalen Witterungsbedingungen ein Zeitungslesen im Freien noch ohne Zusatzbeleuchtung möglich ist.

Wenn Du andere Dämmerungszeiten berechnen möchtest, müßtest Du für die Berechnung der Twilightstunden eine andere Konstante als 12.0 verwenden, soweit ich das überblicke. Der originale Code für die Sonnenberechnungen ist nicht von mir, sondern nur von mir für Arduino angepaßt worden:

 twx = 12.0*twx/PI;    // length of twilight in hours

Das entspricht zweimal Twilight von 6° unter dem Horizont.

Also dort müßtest Du im Code ansetzen, wenn Du z.B. die "astronomische Dämmerung" berechnen möchtest, um den Zeitpunkt zu finden, an dem sich lohnt, ein Spiegelteleskop zur Beobachtung sehr schwach leuchtender Sterne herauszuholen oder zur Sternwarte zu fahren.

Allerdings möchte ich Dich vorwarnen: Die astronomische Dämmerung wird ganz im Norden Deutschlands in der Zeit um den 21.06. eines Jahres herum gar nicht mehr erreicht, und ich habe die Library nicht daraufhin getestet, was an Werten ausgegeben wird, wenn Du versuchst Werte zu berechnen, die es in Abhängigkeit von geographischer Position, Datum und Sonnentand überhaupt nicht gibt, z.B. astronomische Dämmerung am 21.06. in Kiel oder Flensburg. Das Ende der bürgerlichen Dämmerung wird dagegen überall in Deutschland zu jeder Jahreszeit erreicht, so dass das Beispielprogramm so wie es ist für jede geographische Position innerhalb Deutschlands (und wohl auch des größten Teils der Welt mit Ausnahme der Polarregionen) plausible Werte errechnen sollte.

Besten Dank für diese ausführliche Erklärung!!

Hallo Jurs !

Du, ich kann Dir gar nicht genug Danke sagen !
Danke für Deine Geduld und Hilfe für mich Anfänger in C++ . :wink:

Da hast Du ein Meisterwerk geschaffen mit Deiner dateTimeLibEasyDemoSunrise.h Library.

So viele Funktionen die so einfach und flexibel verwendbar sind. Wow.
Mir fallen immer wieder neue Einsatzgebiete ein. So werde ich die dusk / dawn funktion als Ref. zur Ansterrung
der Rollladenmotoren nutzen. In verbindung mit einem BH1750FVI. Klasse - einfach klasse!

Vielen vielen Dank !

Stefan

Hallo Jurs,

ich hole den alten Beitrag nochmal hoch, weil er für mich 200% paßt und das echt eine geniale Arbeit ist!!! TOPP!!!

Ich will das ganze nun in meinen bestehenden Sketch einbauen, wo das holen der Zeit letztendlich auf dem Beispiel aus der DS3232RTC.h - lib stammt... nun hader ich etwas damit die Befehle so anzupassen, dass sie mit deiner Lib arbeiten...

Kannst du mir den entscheidenden Tipp geben, mit dem der Knoten in meinem Hirn hoffentlich platzt...?

MaHa76:
Kannst du mir den entscheidenden Tipp geben, mit dem der Knoten in meinem Hirn hoffentlich platzt...?

Nein, tut mir leid, ich kann nicht raten, was Du möchtest.

Wenn es irgendwie mit dem Thema dieses Threads und/oder dem von mir geposteten Beispielprogramm zu tun hat, kannst Du ja gerne hier fragen.
Aber dann möglichst konkret und nicht nur mit einem Hinweis auf die Knoten in Deinem Hirn.

OK... du hast Recht

/*
 * TimeRTC.pde
 * Example code illustrating Time library with Real Time Clock.
 * This example is identical to the example provided with the Time Library,
 * only the #include statement has been changed to include the DS3232RTC library.
 */

#include <DS3232RTC.h>    //http://github.com/JChristensen/DS3232RTC
#include <Time.h>         //http://www.arduino.cc/playground/Code/Time  
#include <Wire.h>         //http://arduino.cc/en/Reference/Wire (included with Arduino IDE)

void setup(void)
{
    Serial.begin(9600);
    setSyncProvider(RTC.get);   // the function to get the time from the RTC
    if(timeStatus() != timeSet) 
        Serial.println("Unable to sync with the RTC");
    else
        Serial.println("RTC has set the system time");      
}

void loop(void)
{
    digitalClockDisplay();  
    delay(1000);
}

void digitalClockDisplay(void)
{
    // digital clock display of the time
    Serial.print(hour());
    printDigits(minute());
    printDigits(second());
    Serial.print(' ');
    Serial.print(day());
    Serial.print(' ');
    Serial.print(month());
    Serial.print(' ');
    Serial.print(year()); 
    Serial.println(); 
}

void printDigits(int digits)
{
    // utility function for digital clock display: prints preceding colon and leading 0
    Serial.print(':');
    if(digits < 10)
        Serial.print('0');
    Serial.print(digits);
}

mit diesem Beispiel arbeite ich derzeit. Mit setSyncProvider(RTC.get);  hole ich mir die Uhrzeit von der RTC.... ich möchte aber gern mit deiner lib die lokale Zeit erholen.

Wenn ich setSyncProvider(RTC.get);  mit RTCreadLocalTime(time); ersetze bekomme ich allerdings eine Fehlermeldung. Das was in void digitalClockDisplay(void) steht ist in meinem eigentlich Sketch etwa umfangreicher... Ich kann aktuell nicht ganz identifizieren wo ich meine Zeit und mein Datum her bekomme... sorry...

MaHa76:
mit diesem Beispiel arbeite ich derzeit.
Ich kann aktuell nicht ganz identifizieren wo ich meine Zeit und mein Datum her bekomme... sorry...

Meine Library ist nicht dafür ausgelegt, mit den beiden von Dir verwendeten include-Libraries "DS3232RTC.h" und "Time.h" zusammenzuarbeiten.
Da mußt Du wohl irgendwas umschreiben. Entweder am Sketch-Programm oder an den Libraries.

Was soll Dein Programm denn können?

Mein in #11 als Anhang gepostetes Beispielprogramm kann Zonenzeit und Ortszeit (ausgeben, die Uhrzeit von Beginn der Morgendämmerung, Sonnenaufgang, Sonnenuntergang und Ende der Abenddämmerung.
Soll Dein Programm mehr können? Wenn ja: WAS soll es mehr können?
Oder soll es weniger können?

Was mein Beispielprogramm nicht kann: Die Schaltsekunde am 31.12.2016 anzeigen. Der Code läuft am Jahresende einfach in das neue Jahr, ohne für die amtlich festgelegte Schaltsekunde lang anzuhalten und dieses eher seltene Ereignis irgendwie speziell darzustellen.

Wenn Du die Schaltsekunde beim Jahreswechsel feiern möchtest, empfehle ich Dir ein GPS-Modul.

Manche GPS-Module liefern beim Auftreten einer Schaltsekunde eine sechzigste Sekundein der Minute.

So ein Modul würde an Silvester laufen:
23:59:58
23:59:59
23:59:60 // kommt auf das GPS-Modul an, ob die Schaltsekunde an Silvester 2016 als Sekunde 60 erscheint