Raspberry Pi RTC Real Time Clock

GPIO, Webserver

Raspberry Pi RTC Modul steuern – I2C Real Time Clock

Der Raspberry Pi speichert das Datum nicht dauerhaft. Mithilfe des Raspberry Pi RTC (Real Time Clock) Moduls DS1307 hat man eine Echtzeituhr – unabhängig von einer bestehenden Internetverbindung. Dies ist in vielen Anwendungen, welche einen Zeitstempel benötigen, aber nicht mit dem Internet verbunden sein können, von Vorteil. Vor allem für Outdoor Pi’s und Logging Systemen ist es wichtig das genaue Datum und Uhrzeit zu kennen.

In diesem Tutorial geht es um die Inbetriebnahme einer Echtzeituhr (RTC) und Synchronisierung der Systemzeit von Linux / Raspbian.



 

Verwendetes Zubehör

Folgendes Zubehör wirst du benötigen:

Alternativ sollte das RTC DS3231 Modul auch funktionieren, allerdings habe ich es damit (noch) nicht getestet.

 

Vorbereitung

Die Tiny RTC Module sind eigentlich für den Arduino hergestellt, dessen IO Pins auf 5V agieren. Da die GPIOs des Raspberry Pi’s nur auf 3.3V arbeiten und eine höhere Spannung sie beschädigen kann, müssen wir zwei Widerstände des Boards entfernen.

Raspberry Pi RTC Modul back before Raspberry Pi RTC Modul top
Auf der Rückseite sind die zwei Widerstände (R2 und R3), welche entfernt werden. Dazu erhitzen wir mit der Lötspitze jeweils die Befestigungen. Außerdem können noch Pin-Leisten angelötet werden, die meistens mit dabei sind. Wir brauchen nur die Seite mit 7 Pins (rechts):

Raspberry Pi Tiny RTC I2C Modules

Die Widerstände R2 und R3 müssen entfernt werden, um dem Raspberry Pi nicht durch zu hohe Spannung zu schaden.

Alternativ könnte auch ein Logic Level Converter (wie hier) zwischengeschaltet werden.

 

 

Anschluss des Raspberry Pi RTC I2C Moduls

Angeschlossen wird das Modul per I²C Schnittstelle. Dazu verwenden wir die rechte Pin Seite (welche 7 Pins hat), da im Offline Modus des Raspberrys der Strom von der Batterie gezogen werden soll, sodass die Uhr nicht stehen bleibt. Andere Module haben ggf. nur eine Pinleiste. Die Belegung ist wie folgt:

RTC ModulRaspberry Pi
SCLGPIO 3 / SCL (Pin 5)
SDAGPIO 2 / SDA (Pin 3)
VCC / 5V5V (Pin 2)
GNDGND (Pin 6)

 

Die RTC Module unterscheiden sich ein wenig vom Aufbau, daher sollte das folgende Bild nur als Anhaltspunkt genommen werden. Wichtig ist, dass die angeschlossenen Pins stimmen:

Raspberry Pi RTC Real Time Clock Aufbau

 

 

Raspberry Pi RTC Software

Bevor wir richtig loslegen können, muss sichergestellt sein, dass alle Pakete und Paketquellen auf dem neusten Stand sind, daher aktualisieren wir diese zuerst und installieren dann die I2C Software:

sudo apt-get update && sudo apt-get upgrade --yes
sudo apt-get install i2c-tools

Anschließend muss der I2C Bus noch aktiviert werden, falls noch nicht geschehen:

sudo raspi-config

Unter „Advanced Options“ > „I2C“ alles aktivieren (einfach mit Yes bestätigen). Ein Neustart ist ggf. nötig.

Nun bearbeiten wir noch die modules Datei

sudo nano /etc/modules

und fügen die nicht vorhandenen Einträge am Ende hinzu:

i2c-bcm2708
i2c-dev
rtc-ds1307

Gespeichert und beendet wird mit STRG+O, STRG+X.

Um die Module zu aktivieren, müssen sie geladen werden:

sudo modprobe i2c_bcm2708
sudo modprobe i2c_dev
sudo modprobe rtc-ds1307

Wir können nun schauen, ob das RTC Module per I2C erkannt wurde (der Parameter -y 1 gibt an, dass es sich um Rev.2 handelt. Nur das aller erste Raspberry Pi entspricht Revision 1):

i2cdetect -y 1

Es sollte ein folgender Output zu sehen sein:

pi@raspberrypi:~ $ i2cdetect -y 1
 0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: 50 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- 68 -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

Das Modul wird also erkannt und kann mittels i2cget -y 1 0x68 abgefragt werden. Da ein Hex Code nur schlecht leserlich ist, tragen wir das Modul als neues I2C Gerät ein:

sudo bash
echo ds1307 0x68 > /sys/class/i2c-adapter/i2c-1/new_device
exit

Anschließend können wir einfach mittels sudo hwclock -r die Uhrzeit auslesen. Die lokale Uhrzeit des Systems bekommst du mit date heraus.

Bei mir war die Echtzeituhr noch nicht richtig eingestellt (1. Januar 2000), weshalb ich sie erst einstellen musste. Da die lokale Systemzeit stimmt (automatisch abgegriffen über einen NTP Server), habe ich sie folgendermaßen synchronisiert (alle Befehle können übrigens in der hwclock Doku nachgelesen werden):

sudo hwclock --set --date="$(date "+%m/%d/%y %H:%M:%S")"

Falls du die System-Uhrzeit (und Zeitzone!) ändern möchtest, solltest du dies per sudo raspi-config tun,  bevor du die Uhrzeiten synchronisierst.

 

Um nun die Systemzeit automatisch bei jedem Neustart zu setzen, müssen wir einen Set-Befehl in den Autostart schreiben. Dazu bearbeiten wir die Datei:

sudo nano /etc/rc.local

Vor dem exit 0 kommen folgende zwei Zeile hinzu:

echo ds1307 0x68 > /sys/class/i2c-adapter/i2c-1/new_device
hwclock --hctosys

 

Nach einem Neustart sollte nun die richtige Uhrzeit aus dem Raspberry Pi RTC Modul gelesen und eingestellt werden – ganz ohne Internetverbindung.



, , , , ,


7 Kommentare

  1. Christoph sagt:

    Hallo,

    wie wird der „GY-521 MPU-6050 3 Achsen Accelerometer“ in Verbindung mit dem „RealTime Clock RTC DS3231 AT24C32 Precision Echtzeit Uhrenmodul“
    zusammen geschaltet und betrieben?

    Ist das überhaupt möglich?

    Vielen Dank

  2. Christoph sagt:

    Wie sieht das mit VCC aus?

    – RTC-Chip: Betriebsspannung: 3,3V – 5,5V
    -GY-521 MPU-6050: Betriebsspannung: 3 – 5V

    Parallel an den RPI oder
    kann ich für den GY-521 an die 2. Pinreihe des RTC DS3231 anschließen?

    Wie funktioniert das mit der Hex-Adressierung?
    Müssen doch wahrscheinlich umgeschrieben werden?

    • Felix sagt:

      VCC und GND müssen sowieso angeschlossen. Mehr als 3.3V vertragen die GPIOs aber nicht, daher wäre z.B. ein TTL (wie hier verwendet) sinnvoll, wenn das I2C Modul 5V Signale sendet.
      Was meinst du denn mit 1. und 2. Pinreihe? Du hast GND sowie SDA und SCL die parallel an beide Module kommen. Bei VCC nimmst du 3.3V (an beide), aber falls mal ein Modul wirklich nur mit 5V Signalen arbeiten kann, schaltest du zwischen die SDA/SCL Verbindung den Level Converter.
      Die I2C Adressen kannst du einfach mit i2cdetect auslesen (sind meistens hardcoded). Erst das eine Modul anschließen – auslesen – dann das nächste Modul anschließen – auslesen – usw.

    • Christoph sagt:

      Danke erstmal. Werde die Lieferung der Teile abwarten.

      Im Tutorial hier sind für beide Module die Hex-Adressen 68 beim Auslesen angegeben, daher meine Frage.
      Beide Module sind mit 3,3V VCC betriebsfähig angegeben, daher sollten unwahrscheinlich 5V an die GPI gehen… werde also die 3,3V des RPI nutzen.

      Dennoch rührt die Frage ob die 2. Stiftleise des RTC DS3231 die Signale/Spannungen der 1. Stiftreihe durchreicht? Somit würde ich mir Y-Jumper sparen. Aber auch das werde ich wohl persönlich prüfen müssen/können wenn das Modul geliefert ist.

    • Felix sagt:

      Du müsstest mal schauen, ob du mit Jumpern die Adresse verändern kannst. Normalerweise haben I2C Chips drei Adressspins (A0, A1, A2), die an High/Low angeschlossen werden können und womit bis zu 8 verschiedene Adressen möglich sind. Wenn es keinen Pin auf dem PCB gibt, so kannst du dir dennoch das Datenblatt des Chips ansehen und ggf. die Pins verlöten.

    • Christoph sagt:

      Fein! Habe heute die besagten Module erhalten.

      Die Kontakte auf dem RTC erscheinen für mich wertlos… unabhängig von der Beschaltung High oder LOW erschließen sich mir KEINE Änderung in der Adressierung, immer verbleibt 0x68.

      Der Gyroskop hat eine PIN-ausführung A0, diese auf High (3.3V/VCC) geschaltet funktioniert der Sensor statt auf 0x68 auf 0x69. Sieht wie folgt aus, RTC bereits auf 0x68 festgelegt, daher UU:

      $ i2cdetect -y 1
           0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
      00:          -- -- -- -- -- -- -- -- -- -- -- -- --
      10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
      20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
      30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
      40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
      50: -- -- -- -- -- -- -- 57 -- -- -- -- -- -- -- --
      60: -- -- -- -- -- -- -- -- UU 69 -- -- -- -- -- --
      70: -- -- -- -- -- -- -- --

      Uhr läuft, Gyro-Script liefert plausible Ergebnisse.

      Für heute genug!

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Blog abonnieren

Abonniere Tutorials-RaspberryPi, um kein Tutorial mehr zu verpassen!