Praxisbericht RTC3231 Echtzeituhr für Arduino mit Praxisbeispiel

[BAXL]

Für einige Anwendungen mit dem Arduino benötigt man die aktuelle Uhrzeit. Sei es, um eine ganz einfache Uhr zusammen mit einem LCD-Display zu bauen, oder um Messwerte auf einer SD-Karte mit dem passenden Timestamp zu versehen.

Die Arduino besitzt zwar eine interne "Uhr", doch die ist für o.g. Anwendungen unbrauchbar. Um das Problem zu lösen, gibt es kleine Uhrenmodule, die man über den I2C -Bus des Arduinos anschließen und auslesen kann. Mir sind zwei Versionen bekannt, einmal eine Modul mit einem DS1307 RTC-Chip und eine Version mit einem DS3231 RTC-Chip. Der Unterschied ist einfach aber gravierend. Während der DS1307 durch Temperaturschwankungen eine relativ große Ungenauigkeit entwickeln kann, die in wenigen Tagen bereits einige Sekunden beträgt, ist der DS3231 temperaturkompensiert, was sich auch im Preis niederschlägt.

Man bekommt ein DS3231 RTC-Modul zu Preisen zwischen 1,60€ bis zu ca. 8,00€, je nach Anbieter und Bestellmenge. Man muß aber aufpassen, weil die sehr günstigen Angebote manchmal ohne Knopfzelle kommen, die muß man dann noch obenauf rechnen. Leider sind die mitgelieferten Knopfzellen auch nicht immer ganz voll und müssen relativ schnell gewechselt werden.

Beide Versionen besitzen zur Pufferung der Zeit eine 2032 Knopfzelle als Energiequelle. Die Module speichern das komplette Datum und die Uhrzeit. Schaltjahre werden bis ins Jahr 2100 berücksichtigt, das sollte reichen (in 2100 tut uns sicher kein Zahn mehr weh ). Man muss sich lediglich um die Umsetellung zwischen Sommerzeit und Normalzeit kümmern. Das könnte man sogar automatisch per Software erledigen.

Wer es noch genauer braucht, für den wäre eine Zeitquelle aus der DCF77 Funkuhr, oder aus einem GPS-Modul eine Option:

• Arduino mit DCF77-Modul und RTC Echtzeituhr DS3231
• Arduino - Zeitabgleich mit GPS-Modul

Das hier gezeigte Modul ist mit einem DS3231 RTC-Chip ausgestattet, die Kopfzelle befindet sich auf der Unterseite. Auf dem Bild oben Links auf der Platine, ist unter der Beschriftung POWER eine rote LED, die signalisiert, wenn die Uhr in Betrieb ist.

Angeschlossen wird das Modul an VCC und GND und die Anschlüsse SDA an A4 und SCL an A5 beim Arduino (UNO und Nano). Der Arduino Mega hat gesonderte Anschlüsse für die I2C Schnittstelle, die bereits mit SDA und SCL beschriftet sind.

 

[BAXL]

Bedienung des RTC-Moduls mit einem Arduinoprogramm

Das RTC3231 Modul kann direkt über die OneWire Bibliothek des Arduinos angesteuert werden, die bindet man mit #include <wire.h> ins Programm ein, noch vor der void setup().

Sämtliche Aktionen, wie das Einstellen und Auslesen, sind direkt damit möglich, allerdings muß man sich komplett um alle Programmierschritte, inkl. der Zahlenumwandlung, selbst kümmern. Nette Kollegen haben dafür aber bereits eigene kleine Libs geschrieben und stellen die frei herunterladbar zur Verfügung. Für meine Projekte verwende ich bisher immer die RTClib.h, die ich hier herutergeladen habe: https://github.com/adafruit/RTClib

Hier mal ein Beispiel, wie umfangreich die Programmierschritte zum Auslesen der Uhr aussehen:

Spoiler: RTC zu Fuss einstellen nur mit wire.h

void leseDS3231zeit(byte *sekunde, byte *minute,byte *stunde, byte *wochentag, byte *tag, byte *monat, byte *jahr) {

Wire.beginTransmission(DS3231_ADDRESSE);
Wire.write(0); // DS3231 Register zu 00h
Wire.endTransmission();
Wire.requestFrom(DS3231_ADDRESSE, 7); // 7 Byte Daten vom DS3231 holen
*sekunde = bcdToDec(Wire.read() & 0x7f);
*minute = bcdToDec(Wire.read());
*stunde = bcdToDec(Wire.read() & 0x3f);
*wochentag = bcdToDec(Wire.read());
*tag = bcdToDec(Wire.read());
*monat = bcdToDec(Wire.read());
*jahr = bcdToDec(Wire.read());
}


byte bcdToDec(byte val) {
// BCD (binary coded decimal) in Dezimal Zahl umwandeln
return((val/16*10) + (val%16));
}

Mit der Lib reduziert sich das auf diese Befehle:
rtc.adjust(DateTime(2019, 1, 21, 3, 0, 0)); // Datum und Uhrzeit manuell eingeben (Jahr, Monat, Tag, Stunde, Minute, Sekunde)
oder
rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // Datum und Uhrzeit der PC-Systemuhr verwenden

Hinweis bei der Verwendung der Systemzeit des PCs

Verwendet man die Zeile um die Zeit der Systemuhr zu verwenden, wird bei der Übertragung und Start des Arduinoprogramms die Systemzeit des PCs ausgelesen und automatisch in das Uhrenmodul übertragen.
Wichtig ist natürlich, dass die Systemzeit des PCs auch stimmt. Sofern man mit dem Internet verbunden ist, wird die Systemuhr des PCs automatisch korrigiert. Nur bei Stand allone Geräten (also ohne Internetverbindung, sollte man die Systemzeit vorher kontrollieren.

Diese Lib unterstützt Echtzeituhrenmodule mit dem DS1307, dem DS3231 und einem PCF8523. Wenn man die Lib installiert, bekommt man gleich mehrere Beispielprogramme mitgeliefert.

Eingebunden wird die genannte Library mit #include"RTClib.h". Warum da " " verwendet werden statt der < > habe ich noch nicht herausgefunden. Es funktioniert aber.

Die wesentlichen Befehle in der fertigen Lib sind: DateTime now, rtc.adjust und now.dayOfTheWeek(). Bei rtc.adjust ist das rtc in Hellblau, das habe ich deshalb gemacht, weil man für diesen Befehl am Anfang eines Programms zuerst ein neues Objekt definieren muß, dass aus der Klasse RTC_DS3231 abgeleitet wird.

Achtung, nicht alle Funktionen in den Beispielprogrammen funktionieren mit allen RTC Chips. So habe ich herausgefunden, dass es für den DS1307 den Befehl rtc.isrunning() gibt, der für die Klasse DS3231 nicht definiert wurde. D.h., dass bei der Verwendung des Beispielprogramms zum Setzen der Uhrzeit, der DS3231 nicht sofort gestellt werden kann, dafür ist eine kleine Modifikation des Beispielprogramms nötig. Doch dazu mehr im nächten Post.

Im Vereinbarungsteil müssen dann auf jeden Fall folgende Zeilen stehen:

#include <Wire.h> // Einbinden der OneWire Library
#include "RTClib.h" // Einbinden der RTClib Library

RTC_DS3231 rtc; // Erstellung eines Objektes/Instanz aus der Klasse "Class RTC_DS3231"

 

[BAXL]

Uhrzeit einstellen

Kommen wir zu ersten kleinen, aber relativ leicht zu lösenden Problem, die Uhrzeit einzustellen. Wenn man die Module geliefert bekommt, oder die Knopfzelle wechselt, stimmt die aktuelle Uhrzeit nicht. Bei der RTClib.h gibt es ein Beispielprogramm, dass ich für den DS3231 leicht anpassen musste, weil darin eine Programmzeile existiert, die in der Class RTC_DS3231 nicht enthalten ist. Darin fehlt die Funktion RCT_DS3231.isrunning(), die in dem Beispielprogramm aber aufgerufen wird, weil dort ursprünglich der DS1307 gesetzt werden soll. Warum es diese Funktion für den DS3231 nicht gibt, weiß ich nicht. Es funktioniert aber auch ohne diesen Befehl.

Das Beispielprogramm bietet zum Einstellen der Uhr zwei Möglichkeiten. Wenn man der Systemzeit seine PCs vertraut, an dem man den Arduino programmiert, ist man fein raus, weil man das entsprechend vorbereitete Programm einfach kompilieret und hochlädt. Beim Start des programms im Arduino wird dann automatisch die Systemzeit des PCs angenommen und gesetzt. Dazu muß im Beispielprogramm die Zeile:

rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

auskommentiert werden, d.h. man entfernt die beiden // Zeichen vor dem Befehl.

Die manuelle Variante ist etwas umständlicher. Hier muß man vorher auf eine Uhr sehen und die Daten händisch in den entsprechenden Funktionsaufruf eintragen. Weil wir gerade den 31.12.2019 und 11:06 Uhr haben, sähe das so aus:

rtc.adjust(DateTime(2019, 12, 31, 11, 6, 0));

Nun kommt die nächste Krux. Diese Uhrzeit wird genau in dem Augenblick gesetzt, indem das Programm auf dem Arduino startet. Wartet man 10 Minuten und startet den Arduino neu, wird diese zeit erneut gesetzt und es scheint, als würde die Uhr "stehen".

Weiterer Umstand ist die Zeit vom Eintragen der Zeit, bis dass das Programm kompiliert, hochgeladen und gestartet wurde. Man muß also sehen wie lange das Dauert und eine Zeit eintragen, die etwas weiter vorverlegt ist. Würde der Vorgang ca. 15 Sekunden dauern, dann müsste ich zu der Zeit, zu der ich den Hochladeprozess starte, noch 15 Sekunden dazuzählen.

Beispiel:
Ich will um 11:06:00 Uhr starten, müsste ich in die Programmzeile
rtc.adjust(DateTime(2019, 12, 31, 11, 6, 15));
eintragen.

Damit bei der Methode die richtige Zeit nicht wieder überschrieben wird, muß ich das RTC-Modul nach dem Programmstart vom Arduino abklemmen.

 

[BAXL]

Beispielprogramm zum Setzen der Uhrzeit

Das Beispielprogramm, dass bei der RTClib.h dabei ist, funktioniert quasi ohne Änderung für die DS1307 RTC-Module. Um den DS3231 einstellen zu können, bedarf es kleiner Anpassungen. Die Anpassungen habe ich bereits vorgenommen. Das folgende Programm ist deshalb ausschließlich für den DS3231!

// Datum und Uhrzeit einstellen für einen DS3231 RTC, der über die I2C am Arduino angeschlossen wird und zusäztlich die Wire lib verwendet
#include <Wire.h>
#include "RTClib.h"

RTC_DS3231 rtc; // Es wird eine Objekt rtc aus der Klasse RTC_3231 der RTClib.h erstellt

char daysOfTheWeek[7][12] = {"Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"};

void setup () {
  while (!Serial); // for Leonardo/Micro/Zero

  Serial.begin(9600);
  if (! rtc.begin()) {
  Serial.println("Keine Echtzeituhr gefunden!");
  while (1);
  }
// Das Uhrenmodul wird angeschlossen an A4 - SDA, A5 - SCL

  // !!!!!!!!!!!!!!!Bei folgender Zeile die Geteiltzeichen entfernen und einmal laufen lassen danach
  // wird die RTC Uhr mit dem PC-Datum eingestellt. Danach diese Zeile wieder auskommentieren
  // und erneut starten.!!!!!!!!!!!!!!!!!!!!!
  rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));


  // Mit folgendem Befehl kann man die Zeit selbst eintragen und setzen
  // 21. Januar, 2019 at 3 Uhr Morgens muss so eingetragen werden =>
  // man muss aber vorher die Geteiltzeichen entfernen.
  // rtc.adjust(DateTime(2019, 1, 21, 3, 0, 0));

}

void loop () {
  // mit dem Befehl wird die aktuelle Uhrzeit abgefragt und in now abgelegt
  DateTime now = rtc.now();

  Serial.print(now.year(), DEC);
  Serial.print('/');
  Serial.print(now.month(), DEC);
  Serial.print('/');
  Serial.print(now.day(), DEC);
  Serial.print(" (");
  Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
  Serial.print(") ");
  Serial.print(now.hour(), DEC);
  Serial.print(':');
  Serial.print(now.minute(), DEC);
  Serial.print(':');
  Serial.print(now.second(), DEC);
  Serial.println();

  Serial.println();
  delay(3000);
}

Das Programm startet und schiebt die Systemzeit des PCs in die RTC. Danach kann man im seriellen Monitor der Arduino IDE alle 3s die aktuelle Uhrzeit sehen. Bitte darauf achten dass die Baudrate des seriellen Monitors mit der Baudrate im Programm übereinstimmt.

Das Programm übermittelt mit 9600 Baud!

Kleiner Fun Fakt:

Verwendet man die quasi automatische Einstellung der RTC über die Funktion:
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

fallen die Beiden Terme F(__DATE__) und F(__TIME__) auf. Diese beiden Terme enthalten den Zeitstempel des Uploads, damit wird die Systemzeit des PCs quasi "um die Ecke" bereitgestellt.

 

[BAXL]

Praktische Anwendung

Weil es ziemlich sinnlos ist, die Echtzeituhr alleine am Arduino zu betreiben, habe ich eine Beispielanwendung aufgebaut. Diese Anwendung ist eine einfache Uhr mit einem 1602 Display. Der Sinn ist schlicht, immer die aktuelle Zeit anzuzeigen.

Benötigt wird ein Arduino (Uno oder Nano), ein 1602 Display und die RCT DS3231. Das Display und die Uhr werden parallel mit den SDA und SCL Anschlüssen an die A4 und A5 Ports des Arduinos angeschlossen und VCC und GND an +5V und GND des Arduinos. SDA kommt an A4 und SCL an A5.

Und so sieht das als Schaltung aus:

Dazu das funktionierende Programm:

#include <RTClib.h> // Library für Echtzeituhr
RTC_DS3231 rtc;

#include <Wire.h>
#include <LiquidCrystal_I2C.h> // LiquidCrystal_I2C Bibliothek einbinden
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init(); //Im Setup wird das LCD gestartet
  lcd.backlight(); //Hintergrundbeleuchtung einschalten (lcd.noBacklight(); schaltet die Beleuchtung aus).
  lcd.setCursor(0,0);
  lcd.print("Uhrentest");
  delay(1000);
  lcd.clear(); // Anzeige löschen
}

void loop() {
     lcd.setCursor(0,0); // Cursor auf Zeile 1, Spalte 1 setzen
     DateTime now = rtc.now(); // Uhrzeit und Datum abrufen
   
     if (now.day()<10){lcd.print("0");} // Falls das Datum einstellig ist, führende 0 ausgeben, das Gleiche dann auch bei Monat
     lcd.print(now.day(), DEC); lcd.print("."); // Das Datum in Zeile 1 Darstellen und jeweils einen Trennpunkt zwischen Tag, Monat und Jahr
 
    if (now.month()<10){lcd.print("0");}
    lcd.print(now.month(), DEC); lcd.print(".");
  
    lcd.print(now.year(), DEC);

    lcd.setCursor(0,1); // Cursor in Zeile 2, Spalte 1 setzen
    if (now.hour()<10){lcd.print("0");} // Falls die Stunde einstellig ist, führende 0 ausgeben, das Gleiche dann auch bei Minute und Sekunde
    lcd.print(now.hour(), DEC); lcd.print(":");
    
    if (now.minute()<10){lcd.print("0");}
    lcd.print(now.minute(), DEC); lcd.print(":");
    
    if (now.second()<10){lcd.print("0");}
    lcd.print(now.second(), DEC);

    delay(1000); // 1 Sekunden warten

}

 

[BAXL]

Kleiner Wermutstropfen!

Auf den ersten Blick sieht jetzt alles ganz toll aus, allerdings wird es irgendwann erforderlich sein, die Uhr neu zu stellen, das kann passieren wenn wir den Wechsel zwischen Normal- und Winterzeit haben, wenn die Uhr irgendwann eine Abweichung hat, oder wenn die Batterie gewechselt wird und die Uhr ihre Einstellung "vergisst".

Solange man gut an das Modul herankommt ist das kein problem, spätestens wenn die Uhr in einer Anwendung verbaut ist, wird es schwierig, besonders auch dann, wenn die ganze Schaltung auch noch in einem verschlossenen Gehäuse steckt.

Kann man das Modul eben abziehen und an einen anderen Arduino zum Stellen anschließen (Maker haben meist mehrere freie Arduinus im Fundus), stellt man die Uhr kurz und setzt sie dann wieder in die ursprüngliche Anwendung ein. Sobald das aber nicht mehr "mal eben" geht, muß eine praktikable Lösung her. Dazu könnte man das jeweilige Anwendungsprogramm um eine zusätzliche Funktion erweitern, in der man die Uhrzeit mithilfe von Tastern stellt, oder die Uhr bekommt automatisch und regelmäßig einen Abgleich von Außen.

Wie das im Einzelnen aussieht, dazu habe ich mir bereits Gedanken gemacht, aber noch keine fertige, getestete Lösung parat. Im Internet findet man verschiedentlich schon fertigen Code für die manuelle Umstellung, den man in die eigene Applikation adaptieren muß, probiert habe ich das aber noch nicht.

Mir persönlich schwebt eine Lösung vor, bei der ein Arduino quasi Funktion der Systemuhr übernimmt und die Uhrzeit in bestimmten Zeitabständen z.B. per 2,4GHz mit einem NRF24l01 Modul sendet. Dann muß die Systemuhr selbst aber immer die richtige Zeit haben, das könnte man z.B. per DCF77 Empfänger, oder mit einem GPS-Modul lösen Arduino - Zeitabgleich mit GPS-Modul .

Der DCF77 Empfänger benötigt aber einen gewissen Aufwand, weil man die Antenne nicht in unmittelbarer Nähe des Arduinos wegen Störungen anbringen kann, das GPS-Modul wird regelmäßig in geschlossenen Räumen Probleme mit dem Empfang haben.

Vielleicht macht sich ja einer aus der Community mal über dieses Problem her. Wie man die RTC einstellt und wie man Daten per 2,4GHz von einem Arduino zum anderen schickt, das habe ich hier im Forum ziemlich ausführlich beschrieben. Es fehlt dann noch der Anschluß und die Auswertung des DCF77 Empfängers, oder des GPS-Moduls.

 

[BAXL]

Reservepost für evtl. weitere Informationen

 

[rennradjoe]

Hallo,
ich habe gerade mit Arduino angefangen und wollte die Uhrschaltung nachbauen.
Bei mir blinkt leider nur die LCD mit Text "Uhrentest".
Was mache ich falsch?

 

[BAXL]

Hallo,

das sind leider nur sehr wenig Informationen um einen Rat geben zu können. Der Fehler kann überall liegen. Ist die Hardware richtig verdrahtet? Ist das Programm richtig, bzw. Hast Du im Code irgendwelche Änderungen gemacht?

Der Text „Uhrentest“ wird in der Setuproutine nur 1 s angezeigt und dann springt das Programm in die Loop. Da dürfte nichts blinken, es sei denn, der Prozessor bekommt immer wieder einen HardwareReset, oder im Programm wurde etwas geändert.

 

[rennradjoe]

Hardware sollte richtig verdrahtet ein. Display leuchtet ja auch, RTC lechtet rot.
Programm habe ich copy and paste...
Keine Änderungen :-(

AZ Delivery RTC DS3231, 2 reihiges LCD-Modul.
Mir ist nicht klar, ob und wie ich den Sketch zum Setzen der Uhrzeit integriere.
Sorry für die dummen Fragen, aber beginne erst mit Arduino...

 

[BAXL]

Mir ist nicht klar, ob und wie ich den Sketch zum Setzen der Uhrzeit integriere.

Der kann nicht integriert werden, der läuft einmal um die Uhr zu stellen. Das ist ganz oben im Thema beschrieben wie das geht.

 

[norju]

Moin BAXL,

nach längerer Pause bin ich auch einmal wieder am experimentieren und habe dafür eine RTC DS1307 ausgegraben, weil sie mit einem Pufferakku ausgestattet werden kann. Zum Pufferbetrieb habe ich auch meine Frage hinsichtlich der gespeicherten Werte für Datum und Uhrzeit.

Bei Ausfall der Spannungsversorgung werden nach meinem Verständnis Datum und Uhrzeit durch den Akku gepuffert. Damit die Pufferung für den zuletzt bekannten Stand beider Werte stattfindet habe ich im Loop eine Art Refresh (s. u.) vorgesehen.

- Beide wurden im Setup durch: rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
geladen.
- Zu Beginn des Loops werden die Werte mittels: DateTime aktuell = rtc.now();
aus der RTC geholt und verarbeitet.
- Im Loop erfolgt alle 60 Sekunden ein Refresh durch: rtc.adjust(aktuell);

So weit die Theorie, praktisch beginnt das System nach Wiederkehr der Spannungsversorgung mit den ursprünglich während des Hochladens übernommenen Werten der PC-Systemzeit. Anscheinend werden die Refresh-Werte in der RTC anders abgelegt, als zum Zeitpunkt des Hochladens. Bei beiden Vorgängen kommt der gleiche Befehl zum Einsatz, weil mir kein separater Befehl zum Überschreiben des Pufferspeichers bekannt ist.

Hast Du oder hat jemand aus der Community eine Idee, wo sich mein Fehler verbirgt?

Gruß
norju

 

[BAXL]

Du musst die Zeile
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

nach dem ersten Start am PC (mit angeklemmter RTC Uhr) auskommentieren, die RTC-Uhr vom Arduino trennen, das Programm erneut hochladen und dann erst die externe Uhr wieder anklemmen, sonst wird die RTC bei jedem Restart wieder auf die Zeit des PCs beim Hochladen des Programms eingestellt.

siehe Sketchbeispiel von mir im Post weiter oben

// !!!!!!!!!!!!!!!Bei folgender Zeile die Geteiltzeichen entfernen und einmal laufen lassen danach
// wird die RTC Uhr mit dem PC-Datum eingestellt. Danach diese Zeile wieder auskommentieren
// und erneut starten.!!!!!!!!!!!!!!!!!!!!!
rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); <=== also diese Zeile in
// rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); ändern und das Programm erneut per PC hochladen

Weil das eben immer ein Problem ist habe ich mir auch die Lösung mit DCF77, bzw. GPS-Modul überlegt.

Alternativ könnte man auch einen NRF24l01 verbauen sich und von einen zweiten Arduino mit DCF77 und NRF24l01 die Normzeit immer wieder holen, bzw. senden lassen.

 

[norju]

Moin BAXL,

vielen Dank für Deine schnelle Rückmeldung. Die zitierte Anweisung hatte ich in dem älteren Post übersehen. Jetzt jedoch flugs übernommen und erfolgreich umgesetzt.

Allerdings stören mich in dem Zusammenhang die Hardware-Aktivitäten und überlege, ob ggf. eine Softwarelösung möglich ist. Vorstellbar wäre, dass eine bestehende Verbindung zum PC erkannt und

rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

freigegeben wird. Mal sehen, ob ich etwas passendes finde und integrieren kann.

Gruß
norju

 

[BAXL]

Puh, das wäre interessant. Ich frage mich nur, wenn das ginge, warum ich damals keine Hinweise darauf gefunden habe. Vielleicht hat sich auch bis jetzt noch keiner Gedanken darüber gemacht. Ich bin gespannt. Lass es mich wissen wenn Du was findest, aber auch, wenn die Suche nichts erbracht hat.

 

[norju]

Tja, das ist denn wohl doch schwieriger als vermutet. Ich hatte erwartet, dass die Funktionen F(__DATE__) und F(__TIME__) den eintreffenden Datenstrom in Verbindung mit der Übertragung durch den Compiler gelten. Doch weit gefehlt, es handelt sich um Speicherplätze, die zusammen mit der Compiler-Übertragung angelegt werden und im Flash solange erhalten bleiben, bis sie von einer erneuten Übertragung überschrieben werden.

Der Befehl Serial.available() half mir auch nicht weiter, da er nicht die Datenverbindung an sich überwacht, sondern den eintreffenden Datenstrom. So kann man mit dessen Hilfe also nicht unterscheiden, ob über die bestehend Datenverbindung auch Daten zu erwarten sind oder nach einem Ausfall der Spannungsversorgung ohne Synchronisation zu booten ist.

Da muss es doch noch irgend einen Software-Kniff geben

 

[BAXL]

Ich hatte erwartet, dass die Funktionen F(__DATE__) und F(__TIME__) den eintreffenden Datenstrom in Verbindung mit der Übertragung durch den Compiler gelten.

Dann wird das im Grunde so funktionieren, als wenn man manuell eine Uhrzeit einträgt, nur dass das bei der Variante durch die in dem Moment gültige Systemzeit des Computers ersetzt wird.
Trägt man die Zeit manuell ein und lädt das Programm danach nicht nochmal ohne die Settingfunktion hoch, wird die RTC, beim einem Restet des Arduinos, immer wieder mit dem vorher eingegebenen Festwert eingestellt.
Darum auch mein Hinweis, das Hochladen zweimal durchzuführen, einmal mit der Settingfunktion und danach noch einmal mit auskommentierter Settingfunktion.

Zum Nachstellen der Zeit (bei einer Abweichung) dann eben die RTC vom Arduino abtrennen, an einen anderen separaten Arduino anschließen und über den PC die Systemzeit setzen lassen. Danach die RTC wieder an die Ursprungsschaltung anschließen. Aber wie gesagt, das ist immer mit einem Umstand verbunden und man muß gut an die RTC herankommen, um sie aus und wieder einbauen zu können. Ist das nicht möglich, bleiben eigentlich nur noch die Varianten, die Uhrzeit per DCF77, GPS-Modul oder über eine 2,4 GHz Verbindung (NRF24) von einem anderen Arduino zugefunkt zu bekommen.

 

[norju]

In den vergangenen Tagen ließ es mir keine Ruhe, eine Lösung ohne viel Hardware-Geraffel zu finden. Funk-Synchronisationen haben ihren eigenen Reiz und zum Thema DCF77 hatten wir ja schon mehrfach Kontakt. Der Weg war bekannt und bereits entsprechend für einen Eigenbau zum Einsatz gekommen.

In diesem Fall ging es um ein Gerät zur Messung und Speicherung von Temperatur- und Raumfeuchtigkeitswerten. Dafür sollte die Zeit- und Datumsinformation lediglich ein Archivierungskriterium darstellen. Nun zu meinem Lösungsansatz:

Die für den ersten Upload erforderliche Aktivierung der Zeile mit dem rtc.adjust und deren Auskommentierung für weitere Uploads bleibt unverändert. Damit das rtc-Modul für einen möglichen Stromausfall auf dem Laufenden bleibt, habe ich in dem Loop folgende Ergänzung eingefügt:



if (Sekunde == 30)
{
DateTime(F(__DATE__), F(__TIME__)) = DateTime(aktuell);
}



Damit erfährt das rtc-Modul einmal in der Minute (in diesem Fall, wenn die 30. Sekunde erreicht wird) eine Aktualisierung. Das müsste für kurze Stromausfälle oder den Standortwechsel des Messgerätes ausreichen, um einigermaßen zeitnah weiterarbeiten zu können. Somit kann man die rtc-Zeit mittels Upload und ohne Eingriff in die Hardware wenigstens mit der PC-Zeit synchronisieren.