Die Uhrzeit mit einer RTC (Real Time Clock) ermitteln und anzeigen

Brauchst du für dein Arduino-Projekt die aktuelle Uhrzeit – vielleicht, weil du dir mit einem LC-Display (auch LCD-Display genannt) eine Uhr bauen möchtest, oder einen Zeitstempel für deine Daten benötigst? Dann eignet sich hierfür perfekt die RTC, oder Real Time Clock.

In diesem Tutorial erfährst du, wie du ein RTC-Modul (DS1307 oder DS3231) am Arduino anschließt und damit die aktuelle Uhrzeit samt Datum auf einem Display anzeigst.

Was ist eine Real Time Clock?

In den meisten Fällen erhältst du beim Kauf einer Real Time Clock ein Modul, auf dem oft ein DS1307 samt einer kleinen Batterie verbaut ist. Diese sorgt dafür, dass dein Arduino die aktuelle Zeit ermitteln kann, auch wenn es zwischenzeitlich zu einem Stromausfall gekommen ist – denn die RTC wird weiterhin mit Strom versorgt.

Diese Bauteile sind in der Regel recht preisgünstig und werden per I²C am Microcontroller angeschlossen. Die Genauigkeit ist für die allermeisten Projekte ausreichend und die Knopfbatterie hält bis zu fünf Jahre durch.

Warum nicht einfach millis()? Die Funktion millis() zählt nur die Millisekunden seit dem letzten Start deines Arduino – sie kennt weder das aktuelle Datum noch die Uhrzeit und beginnt nach jedem Reset oder Stromausfall wieder bei null. Eine RTC dagegen behält die echte Uhrzeit dauerhaft im Blick, auch wenn dein Projekt zwischendurch komplett ausgeschaltet ist. Genau dafür ist sie gemacht.

DS1307 oder DS3231 – welches Modul solltest du nehmen?

Beim Kauf begegnen dir vor allem zwei Chips: der DS1307 und der DS3231. Beide werden per I²C angeschlossen und funktionieren nach demselben Prinzip – der DS3231 ist heute aber die bessere Wahl:

• Genauigkeit: Der DS3231 besitzt einen temperaturkompensierten Schwingquarz und weicht nur um wenige Sekunden pro Monat ab. Der DS1307 kann dagegen schon mal einige Sekunden pro Tag verlieren.
• Betriebsspannung: Der DS3231 läuft problemlos an 3,3 V und 5 V – also auch direkt an einem ESP8266 oder ESP32. Der DS1307 braucht für den I²C-Bus eigentlich 5 V.
• Preis: Beide Module kosten kaum unterschiedlich viel.

Kurz gesagt: Für ein neues Projekt greifst du am besten zum DS3231. Weiter unten im Artikel findest du einen zweiten Sketch mit der modernen Bibliothek RTClib, die mit beiden Chips funktioniert. Falls du bereits ein DS1307-Modul besitzt, kannst du natürlich problemlos weiter der folgenden Anleitung folgen.

⚠️ Wichtig: die richtige Batterie

Ein Punkt, der oft übersehen wird: Viele günstige DS3231-Module (z.B. das verbreitete ZS-042) besitzen eine Ladeschaltung, die für wiederaufladbare Knopfzellen vom Typ LIR2032 ausgelegt ist. Legst du dort eine ganz normale, nicht aufladbare CR2032 ein, versucht das Modul trotzdem, sie zu laden – im schlimmsten Fall läuft die Zelle aus oder bläht sich auf.

Du hast zwei sichere Optionen: Entweder du verwendest eine passende LIR2032, oder du entfernst bei Verwendung einer CR2032 den zuständigen Lade-Widerstand (meist mit „201″ beschriftet) vom Modul. DS1307-Module besitzen diese Ladeschaltung in der Regel nicht und sind für die CR2032 ausgelegt.

Die RTC am Arduino anschließen

Dank der Verbindung per I²C benötigst du nur vier Kabel, um die Real Time Clock an deinem Arduino anzuschließen. Wenn du einen Arduino UNO verwendest, benötigst du (neben GND und 5V) hierfür die Pins A4 und A5. Orientiere dich an folgender Skizze:

Wenn du ein anderes Arduino-Modell verwendest, findest du die benötigten Pins in der Arduino-Referenz. Am ESP8266 kommunizierst du mit den Pins D1 (SCL) und D2 (SDA) per I²C. Da der ESP8266 über WLAN verfügt, kannst du hier natürlich aber auch die aktuelle Zeit von einem NTP-Server abfragen.

Hier die Verkabelung noch einmal als Übersicht:

Pin am RTC-Modul	Arduino UNO	ESP8266
GND	GND	GND
VCC	5V	3V3 (DS3231) bzw. 5V (DS1307)
SDA	A4	D2
SCL	A5	D1

Auf vielen Modulen findest du neben diesen vier Anschlüssen noch weitere Pins. Für die reine Zeitausgabe brauchst du sie nicht – gut zu wissen ist aber, wofür sie da sind:

Pin	Bedeutung
VCC	Stromversorgung (3,3–5 V)
GND	Masse
SDA	I²C-Datenleitung
SCL	I²C-Taktleitung
SQW / INT	Rechtecksignal-Ausgang bzw. Alarm-Interrupt (nur DS3231)
32K	Ausgang eines stabilen 32,768-kHz-Taktsignals (nur DS3231)
BAT	Anschluss der Pufferbatterie (meist bereits mit der Knopfzelle belegt)

Die benötigten Bibliotheken

Um eine RTC mit dem Chip DS1307 verwenden zu können, benötigst du zwei Bibliotheken. Öffne hierfür den Bibliotheksverwalter und suche dort nach DS1307rtc. Du findest neben der gleichnamigen Bibliothek auch die Bibliothek Time. Installiere jeweils die aktuelle Version.

Sollte deine Real Time Clock einen anderen Chip haben, suche stattdessen nach dessen Namen. Im Folgenden arbeiten wir jedoch mit dem DS1307 weiter.

Wenn beide Bibliotheken in deiner Arduino IDE installiert sind, kann es auch schon mit dem Einstellen der Uhr weitergehen.

Die aktuelle Uhrzeit in der RTC einstellen

Bevor in deinem RTC-Modul die Uhr ticken kann, muss es natürlich erst einmal wissen, wie viel Uhr es ist. Hierfür benötigst du einen Sketch, der bereits in den mitgelieferten Beispielen der Bibliothek DS1307RTC vorhanden ist.

Den Sketch findest du in der Arduino IDE unter Datei > Beispiele > DS1307RTC > SetTime

Öffne ihn und lade ihn auf deinen Arduino. Mit diesem Sketch „lädt“ dein Arduino die aktuelle Uhrzeit samt Datum von deinem Computer und speichert beides in der RTC.

Das war es auch schon mit der Konfiguration. Den Sketch SetTime musst du erst wieder nach dem nächsten Batteriewechsel ausführen.

Uhrzeit und Datum im Seriellen Monitor ausgeben

Für einen ersten Test reicht ebenfalls ein Beispiel-Sketch der Bibliothek. Öffne im gleichen Verzeichnis den Sketch ReadTest und lade ihn auf deinen Arduino.

In deinem Seriellen Monitor sollte nun im Sekundentakt die aktuelle Uhrzeit und das Datum erscheinen.

Uhrzeit und Datum auf einem LC-Display anzeigen

Der Serielle Monitor ist das Eine – aber eine Digitaluhr ist etwas ganz Anderes. Schließe hierfür zunächst dein LC-Display am Arduino zusätzlich zur RTC an.

Danach kommt der Sketch an die Reihe. Um es einfach zu halten, haben wir einfach den Sketch ReadTest modifiziert und um das Setup des LC-Displays und der Ausgabe darauf erweitert.

Im Loop gibt der Sketch nun jede Angabe – Stunden, Minuten etc. – parallel im Seriellen Monitor und per lcd.print() auf dem Display aus.

Ein besonderer Clou ist hierbei die Funktion void print2digits(), die auch schon im Sketch vorhanden ist. Diese Funktion sorgt dafür, dass jede Zahl zweistellig angezeigt wird. Ohne diese Funktion würde die Uhrzeit 16:08 als 16:8 auf dem Display dargestellt.

Hier nun der gesamte Sketch:

#include <Wire.h>
#include <TimeLib.h>
#include <DS1307RTC.h>

#include <LiquidCrystal.h>
const int rs = 11, en = 12, d4 = 2, d5 = 3, d6 = 4, d7 = 5; //Anschlüsse LCD -> Arduino
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {
  Serial.begin(9600);
  while (!Serial) ; // wait for serial
  delay(200);
  Serial.println("DS1307RTC Read Test");
  Serial.println("-------------------");

  // Festlegen, wie viele Zeichen und Reihen das Display hat:
  lcd.begin(16, 2);
}

void loop() {

  tmElements_t tm;

  if (RTC.read(tm)) {
    lcd.clear();

    Serial.print("Ok, Time = ");
    lcd.setCursor(0, 0);
    print2digits(tm.Hour);

    Serial.write(':');
    lcd.print(':');

    print2digits(tm.Minute);

    Serial.write(':');
    lcd.print(':');

    print2digits(tm.Second);

    Serial.print(", Date (D/M/Y) = ");
    lcd.setCursor(0, 1);
    Serial.print(tm.Day);
    lcd.print(tm.Day);

    Serial.write('/');
    lcd.print('/');

    Serial.print(tm.Month);
    lcd.print(tm.Month);

    Serial.write('/');
    lcd.print('/');

    Serial.print(tmYearToCalendar(tm.Year));
    lcd.print(tmYearToCalendar(tm.Year));

    Serial.println();
  } else {
    if (RTC.chipPresent()) {
      Serial.println("The DS1307 is stopped.  Please run the SetTime");
      Serial.println("example to initialize the time and begin running.");
      Serial.println();
    } else {
      Serial.println("DS1307 read error!  Please check the circuitry.");
      Serial.println();
    }
    delay(9000);
  }
  delay(1000);
}

void print2digits(int number) {
  if (number >= 0 && number < 10) {
    Serial.write('0');
    lcd.print('0');
  }
  Serial.print(number);
  lcd.print(number);
}

Alternative: DS3231 (und DS1307) mit der Bibliothek RTClib

Statt der Kombination aus DS1307RTC und Time kannst du auch die weit verbreitete Bibliothek RTClib von Adafruit verwenden. Sie ist aktueller, komfortabler und funktioniert mit dem DS1307 und dem DS3231 – du änderst dafür nur eine einzige Zeile. Suche im Bibliotheksverwalter nach RTClib und installiere sie.

Der folgende Sketch zeigt Uhrzeit und Datum auf dem LC-Display an. Die Uhr stellst du hierbei nicht über einen separaten Sketch, sondern direkt im setup() – und zwar automatisch auf den Zeitpunkt, an dem du den Sketch kompilierst:

#include <Wire.h>
#include <RTClib.h>
#include <LiquidCrystal.h>

RTC_DS3231 rtc;   // Für ein DS1307-Modul stattdessen: RTC_DS1307 rtc;

const int rs = 11, en = 12, d4 = 2, d5 = 3, d6 = 4, d7 = 5; //Anschlüsse LCD -> Arduino
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);

  if (!rtc.begin()) {
    Serial.println("RTC nicht gefunden - bitte Verkabelung pruefen!");
    while (1);
  }

  // Uhr nur stellen, wenn sie die Zeit verloren hat (z.B. nach Batteriewechsel).
  // Sie wird dann auf den Kompilier-Zeitpunkt dieses Sketches gesetzt:
  if (rtc.lostPower()) {
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
}

void loop() {
  DateTime now = rtc.now();

  lcd.clear();

  lcd.setCursor(0, 0);
  print2digits(now.hour());
  lcd.print(':');
  print2digits(now.minute());
  lcd.print(':');
  print2digits(now.second());

  lcd.setCursor(0, 1);
  print2digits(now.day());
  lcd.print('/');
  print2digits(now.month());
  lcd.print('/');
  lcd.print(now.year());

  delay(1000);
}

void print2digits(int number) {
  if (number < 10) {
    lcd.print('0');
  }
  lcd.print(number);
}

Ein Hinweis zur Zeile mit rtc.adjust(): Der DS3231 erkennt über rtc.lostPower() selbst, ob er neu gestellt werden muss – etwa nach einem Batteriewechsel. Beim DS1307 verwendest du stattdessen if (!rtc.isrunning()). So läuft deine Uhr nach dem ersten Hochladen zuverlässig weiter.

Bonus: die Temperatur des DS3231 auslesen

Ein netter Nebeneffekt beim DS3231: Der Chip besitzt einen eingebauten Temperatursensor – schließlich braucht er die Temperatur ohnehin, um seinen Schwingquarz zu kompensieren. Diesen Wert kannst du direkt mitauslesen. Der Sensor ist mit rund ±3 °C nicht besonders präzise und misst eher die Temperatur des Chips als die der Umgebung, für einen groben Anhaltspunkt reicht es aber. Mit der RTClib genügt eine Zeile:

float temperatur = rtc.getTemperature();
Serial.print("Temperatur: ");
Serial.print(temperatur);
Serial.println(" Grad C");

Der DS1307 besitzt diesen Sensor übrigens nicht – das Auslesen der Temperatur funktioniert nur mit dem DS3231.

Häufige Probleme und ihre Lösung

Sollte deine RTC nicht wie erwartet funktionieren, helfen dir diese Punkte meist schnell weiter:

Die RTC zeigt eine falsche Zeit oder das Jahr 2000

Dann wurde die Uhr noch nie gestellt oder der Chip ist gestoppt. Führe den Sketch SetTime (bzw. bei RTClib die Zeile mit rtc.adjust()) einmalig aus. Bleibt das Problem bestehen, ist meist die Knopfbatterie leer – tausche sie gegen eine frische CR2032.

Im Seriellen Monitor erscheint „read error“ oder „RTC nicht gefunden“

Das deutet fast immer auf ein Verkabelungsproblem am I²C-Bus hin. Prüfe, ob SDA und SCL richtig sitzen (am UNO A4 und A5) und nicht vertauscht sind, und ob das Modul Strom bekommt. Mit einem I²C-Scanner-Sketch kannst du testen, ob das Modul überhaupt erkannt wird – die RTC meldet sich üblicherweise unter der Adresse 0x68.

Die Zeit springt nach jedem Neustart auf denselben Wert zurück

Dann wird rtc.adjust() bei jedem Start ausgeführt und setzt die Uhr immer wieder auf den Kompilier-Zeitpunkt. Stelle die Uhr nur, wenn es nötig ist – also innerhalb von if (rtc.lostPower()) (DS3231) bzw. if (!rtc.isrunning()) (DS1307), wie im Sketch oben gezeigt.

Die Uhr geht nach einiger Zeit merklich vor oder nach

Der DS1307 ist relativ ungenau und kann pro Tag einige Sekunden abweichen. Wenn dir das zu viel ist, wechsle auf ein DS3231-Modul – es ist temperaturkompensiert und deutlich präziser.

Häufige Fragen zur RTC am Arduino

Wie lange hält die Batterie einer RTC?

Die verbaute CR2032-Knopfzelle hält je nach Modul und Nutzung mehrere Jahre – oft bis zu fünf. Sie versorgt nur den RTC-Chip, damit die Uhr auch bei getrenntem Arduino weiterläuft.

Was ist der Unterschied zwischen DS1307 und DS3231?

Beide sind RTC-Chips mit I²C-Schnittstelle. Der DS3231 ist temperaturkompensiert und dadurch deutlich genauer, läuft auch an 3,3 V und ist damit die bessere Wahl für neue Projekte. Der DS1307 ist etwas älter und ungenauer, für einfache Anwendungen aber weiterhin ausreichend.

Welche I²C-Adresse hat das RTC-Modul?

Sowohl der DS1307 als auch der DS3231 verwenden die feste I²C-Adresse 0x68. Ein I²C-Scanner-Sketch hilft dir, das Modul im Zweifel aufzuspüren.

Kann ich die RTC auch an einem ESP8266 oder ESP32 verwenden?

Ja. Am ESP8266 nutzt du die Pins D2 (SDA) und D1 (SCL), am ESP32 die Standard-I²C-Pins. Da diese Boards mit 3,3 V arbeiten, empfiehlt sich hier ein DS3231-Modul. Alternativ kannst du bei ESP-Boards mit WLAN die Zeit auch von einem NTP-Server holen.

Brauche ich eine Internetverbindung für die RTC?

Nein – und genau das ist der Vorteil einer RTC. Sie hält die Uhrzeit völlig eigenständig, auch ganz ohne WLAN oder Internet.

Wie geht es weiter?

Du hast nun die Möglichkeit, in deinem Projekt immer die aktuelle Uhrzeit zu verwenden. Welche Ideen kommen dir nun in den Sinn? Wie wäre es z.B. mit einem Wecker, der dich mit einem Piezo weckt?

Statt eines LC-Displays kannst du die Uhrzeit natürlich auch auf anderen Displays ausgeben – zum Beispiel auf einem OLED-Display oder einem TFT-Display.