So baust du dir deine eigene Internet-Uhr

So baust du dir mit Hilfe eines Raspberry Pis oder eines ESP32 eine Network Time Protocol basierte Internet-Uhr und gibst die Zeit auf einem Display aus.

Wir zeigen dir, wie du eine solche energiesparende Digitaluhr mithilfe deines ESP32 oder deines Raspberry Pi ganz einfach programmierst. Sowohl beim ESP32 als auch beim Pi greifen wir auf das Protokoll NTP (Network Time Protocol) zurück.

Das Protokoll ermöglicht die Synchronisierung von Computern und anderen IT-Componenten über ein IP-Netz wie das Internet. Das Network Time Protocol wurde bereits 1985 an der Universität von Dalaware entwickelt.

Dieses Material benötigst du für dein Projekt

• ESP32 oder Raspberry Pi (egal welches Modell) inkl. Netzteil: Ganz gleich, ob du dich für den Microcontroller aus dem Hause Espressif oder den Raspberry Pi entscheidest: Die Vorgehensweise ist in beiden Fällen vergleichsweise einfach und das Projekt schnell realisiert. Wir stellen dir für jede der Optionen ein detailliertes Tutorial zur Verfügung.
• Draht Jumper Kabel für Raspberry Pi und Arduino (Female to Female, 4 Stück): Die Kabel sind notwendig, um eine Verbindung zwischen den relevanten Pins herzustellen.
• LCD 16×2: Auf dem Display lässt du letztlich die Uhrzeit anzeigen.
• Arduino IDE: Wenn du den ESP32 für das Vorhaben nutzt, schreibst du mit diesem Tool den untenstehenden Code, bevor du ihn hochlädst.

Zusätzlich, falls du das Projekt mit dem Raspberry Pi durchführen möchtest:

• microSD Karte: Diese brauchst du, um Raspbian OS nach der Installation auf deinen Raspberry Pi übertragen zu können.
• IIC / I2C Interface für 1602 / 2004 Displays
• Lötstation: Falls du noch keine Lötstation besitzt, findest du hier eine große Auswahl.
• Raspbian OS: Das Raspberry Pi Betriebssystem ist nicht zuletzt deshalb ein wichtiger Faktor für das Projekt, weil es inklusive NTP daherkommt.

WARENKORB

Alle für dieses Projekt notwendigen Artikel landen mit einem Klick auf den Button direkt in deinem Warenkorb, sofern sie in unserem Shop verfügbar sind. Kontrolliere daher deinen Warenkorb genau!

Schritt für Schritt: So baust du dir deine Internet Clock – mit dem ESP32

• Im ersten Schritt gilt es, mithilfe deiner Lötstation die Schaltung zu bauen. Wir haben die Pins des ESP32 und des LCD, an denen du jeweils eine Verbindung herstellen musst, im Folgenden aufgeführt, um dir diesen Schritt zu erleichtern:

ESP32 Pins                                           LCD Pins

Vin (für bessere Helligkeit)        →         VCC

GND                                          →         GND

D21                                           →         SDA

D22                                         →        SCL

• Als nächstes installierst du in der Arduino IDE die ESP Boards & Packages. Dabei gehst du folgendermaßen vor: Installiere den Arduino Core für ESP32, um zu gewährleisten, dass dein ESP32 in der Arduino IDE auch gefunden werden kann. Zu diesem Zweck öffnest du die Voreinstellungen und tippst in das Feld „Zusätzliche Boardverwalter-URLs“ die URL https://dl.espressif.com/dl/package_esp32_index.json ein. Die URL für ESP8266-Boards lautet http://arduino.esp8266.com/stable/package_esp8266com_index.json. Damit die URLs akzeptiert werden, musst du diese durch ein Komma trennen.

• Nun ist das ESP32 Modul unter dem Menüpunkt „Board“ > „Boardverwalter“ auffindbar. Du findest es auch ganz einfach, indem du „ESP“ in das Suchfeld eingibst. Installiere nun das Modul.

• Öffne anschließend Arduino IDE, um die Bibliotheken NTPClient.h, TimeLib.h und LiquidCrystal_I2C.h zu installieren. NTPClient.h kannst du direkt via Arduino IDE installieren, die anderen beiden Bibliotheken nicht . Um NTPClient.h hinzuzufügen, klicke auf „Sketch“, dann auf „Bibliothek einbinden“ und schließlich auf „Bibliotheken verwalten“. Suche nun nach dem Begriff „ntpclient“.

Um TimeLib.h und LiquidCrystal_I2C.h zu installieren, musst du die Bibliotheken erst über die hinterlegten URLs downloaden. Wenn du das getan hast, navigierst du in Arduino IDE zu „Sketch“, klickst auf „Bibliothek einbinden“ und zuletzt auf „ZIP-Bibliothek hinzufügen“.

• Nun musst du noch den auf das Projekt zugeschnittene Code eingeben. Diesen stellen wir dir natürlich gerne zur Verfügung:

#include <WiFi.h>

#include <WiFiUdp.h>

#include <NTPClient.h>                    // Include NTPClient library
 
#include <TimeLib.h>                      // Include Arduino time library

#include <LiquidCrystal_I2C.h>            // Include LiquidCrystal_I2C library

 

LiquidCrystal_I2C lcd(0x27, 16, 2);       // 0x27 address, 16 columns and 2 rows

 

const char *ssid     = "******";          //Internet ssid

const char *password = "******";          //Internet password 

WiFiUDP ntpUDP;

// 'time.nist.gov' is used (default server) with +1 hour offset (3600 seconds) 60 seconds (60000 milliseconds) update interval

NTPClient timeClient(ntpUDP, "time.nist.gov", 3600, 60000);

char Time[ ] = "TIME:00:00:00";

char Date[ ] = "DATE:00/00/2000";

byte last_second, second_, minute_, hour_, day_, month_;

int year_;

 

void setup() {

  Serial.begin(115200);

  lcd.begin(21, 22);                 //SDA = GPIO21, SCL = GPIO22

  lcd.backlight();                   // Turn backlight ON

  lcd.setCursor(0, 0);

  lcd.print(Time);

  lcd.setCursor(0, 1);

  lcd.print(Date);

  WiFi.begin(ssid, password);

  Serial.print("Connecting.");

  while ( WiFi.status() != WL_CONNECTED ) {

    delay(500);

    Serial.print(".");

  }

  Serial.println("connected");

  timeClient.begin();

}

 

void loop() {

  timeClient.update();

  unsigned long unix_epoch = timeClient.getEpochTime();    // Get Unix epoch time from the NTP server

 

  second_ = second(unix_epoch);

  if (last_second != second_) {

 

    minute_ = minute(unix_epoch);

    hour_   = hour(unix_epoch);

    day_    = day(unix_epoch);

    month_  = month(unix_epoch);

    year_   = year(unix_epoch);

 

    Time[12] = second_ % 10 + 48;

    Time[11] = second_ / 10 + 48;

    Time[9]  = minute_ % 10 + 48;

    Time[8]  = minute_ / 10 + 48;

    Time[6]  = hour_   % 10 + 48;

    Time[5]  = hour_   / 10 + 48;

 

    Date[5]  = day_   / 10 + 48;

    Date[6]  = day_   % 10 + 48;

    Date[8]  = month_  / 10 + 48;

    Date[9]  = month_  % 10 + 48;

    Date[13] = (year_   / 10) % 10 + 48;

    Date[14] = year_   % 10 % 10 + 48;

 

    // Send time and date to serial monitor

    Serial.println(Time);

    Serial.println(Date);

 

    // Display time and date on the 16x2 LCD

    lcd.setCursor(0, 0);

    lcd.print(Time);

    lcd.setCursor(0, 1);

    lcd.print(Date);

    last_second = second_;

  }

  delay(200);

}

• Im nächsten Schritt musst du deine Internet SSID und dein Passwort in den Sektch eingeben.

• Als letztes musst du den Code nur noch hochladen. Klicke dazu auf den Button „Hochladen“. Diesen findest du oben rechts. Im Anschluss musst du den seriellen Monitor mit einer Baudrate von 115200 öffnen, damit du Zugriff auf den Webserver erhältst. Um den seriellen Monitor zu öffnen, klickst du in Arduino IDE auf den Button rechts oben. Ändere anschließend die Baudrate des Monitors über die Tastenkombination Strg + T und gib dann die Baudrate „115200“ ein. Bestätige die Eingabe mit der Taste „EN“ auf deinem ESP32. Dein Router hat nun eine dynamische IP-Adresse erhalten, die sogleich ausgegeben wird. Es erscheint die Meldung „Start“. Im letzten Schritt lädst du dir einen Browser herunter und gibst die IP-Adresse ein, die auf dem seriellen Monitor zu sehen ist. Die gemessenen Werte kannst du im Interface auslesen.

Schritt für Schritt: So baust du dir deine Internet-Uhr – mit dem Raspberry Pi

Natürlich kannst du nicht nur einen ESP32 Microcontroller nutzen um deine Internet-Uhr zu bauen, sondern auch einen Raspberry Pi. Wie du hierbei vorgehst zeigen wir dir in diesem Abschnitt.

• Wie beim ESP32 baust du zunächst mithilfe deiner Lötstation die Schaltung. Führe die Pins folgendermaßen zusammen:

Raspberry Pi Pins                     LCM 1602 IIC Pins

5v                                →        VCC

GND                             →        GND

SDA                              →        SDA

SCL                              →        SCL

• Im zweiten Schritt installierst du das Betriebssystem Raspbian OS auf deiner microSD Karte. Dabei gehst du folgendermaßen vor: Als erstes lädst du Raspbian OS herunter und entpackst das Image auf deiner Festplatte. Im Anschluss überträgst du das Betriebssystem mithilfe der Software Etcher auf deine micro SD Karte. Etcher ist ein Open Source Tool, das sich bei der Installation von Raspbian OS als sehr nützlich erweist. Daher ist es ratsam, die neueste Version im Vorfeld der Installation zu downloaden. Danach legst du die micro SD Karte in deinen Rechner ein und aktivierst Etcher. Klicke auf „Select Image“ und wähle anschließend den Ordner aus, in dem du das Image entpackt hast. Zum Schluss klickst du auf die micro SD Karte und auf „Flash“, um mit der Installation zu beginnen.
• Als nächstes richtest du den SSH-Zugriff für deinen Raspberry Pi ein. Dabei gibt es verschiedene Vorgehensweisen – je nachdem, ob du Windows oder Linux nutzt.

Vorgehensweise für WIndows:

Du nutzt als Betriebssystem Windows? In diesem Fall benötigst du das Tool PuTTY. Du musst dieses nicht einmal installieren, sondern lediglich downloaden. Wähle nach dem Herunterladen die exe-Datei aus und gib als Host „raspberrypi“ ein. Klicke anschließend auf „Open“. Du wirst nun dazu aufgefordert, einen Login-Namen und ein Passwort einzugeben. Als Standard sind der Benutzername „pi“ und das Passwort „raspberry“ voreingestellt. Am besten änderst du direkt das Passwort, um Gewissheit zu haben, dass keine unerwünschte Person auf den Desktop zugreifen kann. Um das Passwort zu ändern, lässt du einfach im Terminal den Befehl „sudo passwd“ ausführen. Bestätige das Passwort, nachdem du es geändert hast.

Vorgehensweise für Linux & Mac:

Sofern du Linux oder Mac als Betriebssystem nutzt, brauchst du keine weitere Software, um den SSH-Zugriff einzurichten. Wenn du eine Verbindung herstellen möchtest, musst du allerdings die Raspberry Pi IP und den Hostnamen kennen. Abgesehen davon genügt für das Prozedere dein Raspberry Pi Terminal. Hier erfährst du im Detail, wie du vorzugehen hast, um eine SSH-Verbindung herzustellen.

• Nachdem du Raspbian OS erfolgreich installiert und den SSH-Zugriff eingerichtet hast, öffnest du ein Terminal deines Raspberrys und lässt den Befehl „sudo apt-get update“ ausführen.

sudo apt-get update

• Nun gibst du den Befehl „sudo apt-get install -y i2c-tools && sudo apt-get install -y python-smbus“ in das Terminal ein.

sudo apt-get install -y i2c-tools && sudo apt-get install -y python-smbus

• Anschließend konfigurierst du das I2C Interface. Hier findest du ein anschauliches Tutorial, das dir die Vorgehensweise genau erläutert.
• Im System ist per Default die Weltzeit (UTC) voreingestellt. Um die Zeitzone dahingehend zu verändern, dass die in Deutschland geltende Uhrzeit angezeigt wird, müssen einige Anpassungen vorgenommen werden. Optional kannst du zunächst auch die für NTP genutzten Zeitserver anpassen, um den für Deutschland zuständigen Server zu verwenden. Gib im Anschluss den Befehl „sudo timedatectl set-timezone Europe/Berlin“ ins Terminal ein.

sudo timedatectl set-timezone Europe/Berlin

• Installiere nun den Open-Source-Texteditor Vim, indem du den Befehl „sudo apt-get install vim“ ausführen lässt.

sudo apt-get install vim

• Im nächsten Schritt erstellst du einen Ordner für das Projekt, den du z. B Projekt nennst. Dies machst du indem du den Befehl „mkdir Projekt“ ins Terminal eingibst.

mkdir Projekt

• Jetzt kannst du nach deiner IC2 LCD Adresse suchen. Zu diesem Zweck gibst du „sudo i2cdetect -y 1“ ins Terminal ein. Nachdem du den Befehl eingegeben hast, erscheint deine IC2 LCD Adresse im Terminal.

sudo i2cdetect -y 1

• Kopiere anschließend die Codes „code.py“ , „i2c_lib.py“ und „lcddriver.py“ von deinem Computer in den zuvor angelegten Ordner („mkdir Projekt“) auf deinem Raspberry Pi. Wenn du Windows nutzt, solltest du dir für diesen Schritt am besten den Open-Source-FTP-Client WinSCP herunterladen. Falls du Linux aufgespielt hast, empfiehlt es sich, FileZilla für das Kopieren der Codes zu verwenden.
• Als nächstes öffnest du die Datei „lcddriver.py“ und gibst deine I2C Adresse ein („vim lcddriver.py“). Speichere die Datei, indem du auf „Esc“ und anschließend auf „:q“ tippst.

vim lcddriver.py

• Es ist vollbracht – du kannst deine selbst programmierte Internet-Uhr direkt testen! Dazu gibst du im Terminal den Befehl „python code.py“ ein und lässt diesen sogleich ausführen. Tipp: Du kannst die Internet-Uhr auch beim Boot starten, dann musst du nicht jedes Mal das Skript über SSH ausführen lassen, um die Uhr anzeigen zu lassen. Genauere Infos, wie du hierbei vorgehst, findest du hier.

python code.py

Wir wünschen dir viel Spaß mit deiner Internet-Uhr

Wir hoffen du hattest Spaß beim Bau dieses IoT-Projekts. Wenn du das Tutorial befolgt hast, dann hast du jetzt eine coole Internet-Uhr zuhause. Alle notwendigen Teile zum Bau dieses Projekts findest du noch einmal hier!

Wir hoffen dich auch in Zukunft für viele tolle Projekte begeistern zu können. Wenn du Fragen zu diesem Projekt hast, so kannst du diese gerne in den Kommentaren stellen.

Euer BerryBase-Team