Skip to content

Technik Blog

Programmieren | Arduino | ESP32 | MicroPython | Python | Raspberry Pi | Raspberry Pi Pico

Menu
  • Smarthome
  • Arduino
  • ESP32 & Co.
  • Raspberry Pi & Pico
  • Solo Mining
  • Über mich
  • Deutsch
  • English
Menu

Zeitgesteuerte Schaltung mit Arduino: Programmieren von RTC, LCD und Relaismodul

Posted on 22. September 20246. November 2024 by Stefan Draeger

Über eine zeitgesteuerte Schaltung kannst du Verbraucher zu einem bestimmten Zeitpunkt aktivieren/deaktivieren. Dieses kleine Projekt wird mit dem Arduino UNO R3, einem 2×20 Zeichen LCD-Display und Relais Shield umgesetzt. Der Arduino nutzt eine Echtzeituhr (RTC), um das Datum und die Uhrzeit genau zu erfassen, sodass Schaltvorgänge pünktlich ausgeführt werden können. Die aktuelle Uhrzeit wird auf dem LCD-Display dargestellt, während das Relaismodul externe Geräte wie Lampen oder Motoren steuert. Diese zeitgesteuerte Schaltung eignet sich ideal für Automatisierungsprojekte, bei denen Aktionen zu festgelegten Zeiten ablaufen sollen. Im Folgenden erkläre ich dir Schritt für Schritt, wie du die Komponenten anschließt und programmierst.

Zeitgesteuerte Schaltung mit Arduino: Programmieren von RTC, LCD und Relaismodul
Dieses Video auf YouTube ansehen.

Ein Follower auf TikTok hat mich auf die Idee für diesen Beitrag gebracht, daher möchte ich mich an dieser Stelle ganz besonders bei Armin F. für den inspirierenden Vorschlag bedanken.

LCD-Display mit Datum & Uhrzeit von einer RTC am Arduino UNO R3
LCD-Display mit Datum & Uhrzeit von einer RTC am Arduino UNO R3

Auf meinem TikTok Kanal habe ich dir bereits zu diesem Beitrag, mehrere Videos veröffentlicht, in welchen ich den Aufbau der Schaltung, das Programmieren in der Arduino IDE sowie das Einstellen von Zeitpunkten für das Schalten von Verbraucher erläutert habe.

  • Teil 1 – Aufbauen der Schaltung
  • Teil 2 – Programmieren eines LCD-Displays über die Arduino IDE am Arduino UNO R3

Inhaltsverzeichnis

  • Wie soll das kleine Projekt funktionieren?
  • Benötigte Ressourcen für dieses Projekt
  • Aufbau der Schaltung
  • Zeitgesteuerte Schaltung in der Arduino IDE programmieren
    • Schritt 1 – programmieren des LCD-Displays
    • Schritt 2 – programmieren der RealtimeClock
      • Schritt 2.1 – setzen eines Zeitstempels
      • Schritt 2.2 – auslesen eines Zeitstempels
    • Schritt 3 – aktivieren der Relais via Zeitstempel
  • Fazit und Ausblick

Wie soll das kleine Projekt funktionieren?

Der Arduino UNO R3 erhält die aktuelle Uhrzeit und das Datum von der RTC. Zu einem festgelegten Zeitpunkt schaltet er dann das Relais. So weit, so unkompliziert. Über die serielle Schnittstelle lässt sich einerseits der Zeitpunkt für eine Aktion einstellen und andererseits die RTC mit dem richtigen Datum und der Uhrzeit konfigurieren.

In meinem Projekt verwende ich ein zweifaches Relaismodul, wodurch ich zwei verschiedene Schaltzeitpunkte festlegen kann.

Benötigte Ressourcen für dieses Projekt

Für den Aufbau des Projektes verwende ich nachfolgende Bauteile:

  • einen Arduino UNO R3*
  • ein USB-Datenkabel*
  • eine RTC DS3231*
  • ein I2C LCD-Display*
  • ein Relais Shield*
  • diverse Breadboardkabel*, 10 cm, männlich – weiblich
Module - zeitgesteuerte Schaltung am Arduino
Module – zeitgesteuerte Schaltung am Arduino

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Aufbau der Schaltung

Der Aufbau am Arduino UNO R3 ist recht einfach, du schließt die RTC & das LCD-Display via I2C an und das 2fach Relaismodul über zwei digitale Pins.

zeitgesteuerte Schaltung mit dem Arduino UNO R3, RTC und LCD-Display
zeitgesteuerte Schaltung mit dem Arduino UNO R3, RTC und LCD-Display

Nachfolgend die Tabelle mit den Daten, wie die Bauteile an den Arduino angeschlossen wurden.

BauteilArduino UNO R3Kabelfarbe
2fach Relais Modul
VCC5 Vrot
GNDGNDschwarz
IN1D9braun
IN2D8blau
RealtimeClock (RTC DS3132)
VCC5 Vrot
GNDGNDschwarz
SDAA4gelb
SCLA5grün
LCD-Display
VCC5 Vrot
GNDGNDschwarz
SDAA4gelb
SCLA5grün

Statt dem betagten Arduino UNO R3 könntest du auch den neuen UNO R4 Minima oder UNO R4 WiFi nutzen, alle drei Mikrocontroller sind untereinander kompatibel. Oder wenn du noch platzsparender sein möchtest, dann den Arduino Nano V3.

Zeitgesteuerte Schaltung in der Arduino IDE programmieren

Beginnen wir nun und programmieren die Schaltung in der Arduino IDE. In meinem Fall nutze ich die Arduino IDE 2.

Schritt 1 – programmieren des LCD-Displays

Fangen wir zunächst im ersten Schritt mit dem LCD-Display an, dieses haben wir via I2C angeschlossen und daher benötigen zunächst auch eine spezielle Bibliothek. Diese Bibliothek können wir vom GitHub Repository johnrickman / LiquidCrystal_I2C als ZIP-Datei herunterladen.

//Bibliothek zum ansteuern des LCD-Display via I2C
#include <LiquidCrystal_I2C.h>

//Das Display wird über
//die I2C Adresse 0x27 angesteuert
//es hat 20 Zeichen pro Zeile
//es hat 2 Zeilen
LiquidCrystal_I2C lcd(0x27, 20, 2);

void setup() {
  //initialisieren des Displays
  lcd.init();
  //aktivieren der Hintergrundbeleuchtung
  lcd.backlight();
  //setzen des Cursors auf die erste Zelle im Display
  lcd.setCursor(0, 0);
  //schreiben eines Textes
  lcd.print("Fr. 20.10.2024");
  //setzen des Cursors auf die zweite Zeile im Display
  lcd.setCursor(0, 1);
  //schreiben eines Textes
  lcd.print("18:35:23 Uhr");
}


void loop() {
  //bleibt leer
}

Der Code bewirkt, dass auf dem LCD-Display in der ersten Zeile das Datum und in der zweiten Zeile die Uhrzeit angezeigt wird.

Solltest du keinen Text sehen, so empfehle ich dir zunächst den Drehpoti für die Helligkeit auf der Rückseite zu drehen.

Schritt 2 – programmieren der RealtimeClock

Die Realtimeclock wird via I2C angesteuert und liefert uns einen Zeitstempel aus Datum & Uhrzeit. Jedoch müssen wir dieser initial einen solchen Zeitstempel setzen.

Programm – setzen und auslesen eines Zeitstempels an einer RTCHerunterladen

Schritt 2.1 – setzen eines Zeitstempels

Den Zeitstempel im Format TT.MM.YYY SS:MM:SS also zum Beispiel „20.09.2024 18:35:34“ (ohne Anführungszeichen) senden wir via seriellen Monitor an den Mikrocontroller. Über die Funktion readDataFromSerial() werden diese Daten empfangen und ausgewertet. Die Bestandteile des Zeitstempels werden anschließend an die Funktion rtcWriteTimestamp übergeben.

// I2C Adresse des RTC  DS3231
#define RTC_I2C_ADDRESS 0x68

struct Zeitstempel {
  String datum;
  String zeit;
};

char linebuf[30] = {};
bool readData = false;

void setup() {
  Serial.begin(9600);
  ...
}

void loop() {
  readDataFromSerial();
  if (readData) {
    String timestamp = linebuf;
     //Das Datum muss inkl. den Punkten 10 Zeichen lang sein
    String datum = timestamp.substring(0,10);
    String tag = datum.substring(0,2);
    String monat = datum.substring(3,5);
    String jahr = datum.substring(6,10);

    //Die Uhrzeit beginnt ab dem 11 Zeichen aus dem Zeitstempel
    String uhrzeit = timestamp.substring(11);
    String stunde = uhrzeit.substring(0,2);
    String minute = uhrzeit.substring(3,5);
    String sekunde = uhrzeit.substring(6);

    rtcWriteTimestamp(stunde.toInt(), minute.toInt(), stunde.toInt(), tag.toInt(), monat.toInt(), jahr.toInt());
  }
  ...
}

void readDataFromSerial() {
  //Zähler für die Zeichen
  byte counter = 0;
  readData = false;

  //Wenn Daten verfügbar sind dann...
  if (Serial.available() > 0) {
    delay(250);
    readData = true;
    //solange Daten von der seriellen Schnittstelle
    //empfangen werden...
    while (Serial.available()) {
      //speichern der Zeichen in dem Char Array
      char c = Serial.read();
      if (c != '\n') {
        linebuf[counter] = c;
        if (counter < sizeof(linebuf) - 1) {
          counter++;
        }
      }
    }
    Serial.println(linebuf);
  } else {
    readData = false;
  }
}

void rtcWriteTimestamp(int stunde, int minute, int sekunde, int tag, int monat, int jahr){
  Wire.beginTransmission(RTC_I2C_ADDRESS);
  Wire.write(0); // Der Wert 0 aktiviert das RTC Modul.
  Wire.write(decToBcd(sekunde));    
  Wire.write(decToBcd(minute));
  Wire.write(decToBcd(stunde));                                  
  
  Wire.write(decToBcd(0)); // Wochentag unberücksichtigt
  Wire.write(decToBcd(tag));
  Wire.write(decToBcd(monat));
  Wire.write(decToBcd(jahr-2000));  
  
  Wire.endTransmission();  
}

Schritt 2.2 – auslesen eines Zeitstempels

Wenn wir den Zeitstempel gesetzt haben, dann können wir diesen wieder auslesen.

void loop() {
  ...
  //bleibt leer
  Zeitstempel zeitstempel = readRtc();

  lcd.setCursor(0, 0);
  lcd.print(zeitstempel.datum);
  lcd.setCursor(0, 1);
  lcd.print(zeitstempel.zeit);

  delay(500);
}

//auslesen der Daten von der RealtimeClock
Zeitstempel readRtc() {
  //Aufbau der Verbindung zur Adresse 0x68
  Wire.beginTransmission(RTC_I2C_ADDRESS);
  Wire.write(0);
  Wire.endTransmission();
  Wire.requestFrom(RTC_I2C_ADDRESS, 7);

  int sekunde = bcdToDec(Wire.read() & 0x7f);
  int minute = bcdToDec(Wire.read());
  int stunde = bcdToDec(Wire.read() & 0x3f);

  int wochentag  = bcdToDec(Wire.read());
  int tag = bcdToDec(Wire.read());
  int monat = bcdToDec(Wire.read());
  int jahr = bcdToDec(Wire.read()) + 2000;

  char datum[30];
  sprintf(datum, "%02d.%02d.%4d", tag, monat, jahr);

  char zeit[30];
  sprintf(zeit, "%02d:%02d:%02d Uhr", stunde, minute, sekunde);

  return { datum, zeit };
}

Schritt 3 – aktivieren der Relais via Zeitstempel

In meinem Fall habe ich ein 2fach Relais Shield in die Schaltung integriert, du kannst auch Shields mit deutlich mehr Relais erwerben und integrieren, die nachfolgend gezeigt Funktion bleibt dieselbe.

Programm: steuern eines Relais via RTC am Arduino UNOHerunterladen
struct Relais {
  int digitalPin;
  String desc;
  Zeitstempel actionON;
  Zeitstempel actionOFF;
};

Relais relais1 = {
  9,
  "Relais #1",
  { "20.09.2024", "22:21:00" },
  { "20.09.2024", "22:21:10" }
};

Relais relais2 = {
  8,
  "Relais #2",
  { "20.09.2024", "22:21:10" },
  { "20.09.2024", "22:21:15" }
};

void setup() {
  ...
  pinMode(relais1.digitalPin, OUTPUT);
  pinMode(relais2.digitalPin, OUTPUT);

  digitalWrite(relais1.digitalPin, HIGH);
  digitalWrite(relais2.digitalPin, HIGH);
}


void loop() {
  ...
  checkCurrentTimestamp(relais1, zeitstempel);
  checkCurrentTimestamp(relais2, zeitstempel);
}

void checkCurrentTimestamp(Relais relais, Zeitstempel zeitstempel) {
  if (zeitstempel.datum == relais.actionON.datum && zeitstempel.zeit == relais.actionON.zeit) {    
    Serial.println("aktivieren");
   digitalWrite(relais.digitalPin, LOW);
  } else if (zeitstempel.datum == relais.actionOFF.datum && zeitstempel.zeit == relais.actionOFF.zeit) {
    Serial.println("deaktivieren");
   digitalWrite(relais.digitalPin, HIGH);
  }
}

Fazit und Ausblick

Mit diesem Beitrag habe ich dir nun gezeigt wie eine zeitgesteuerte Schaltung am Arduino UNO R3 mit einer RTC und einem Relaisshield aufgebaut und programmiert wird.

Diese Schaltung kannst du selbstverständlich auch mit dem neuen UNO R4 WiFi aufbauen und so die Zeit von einem NTP-Server abrufen und auch andere smarter Schalter wie den Shelly 1PM Mini steuern.

4 thoughts on “Zeitgesteuerte Schaltung mit Arduino: Programmieren von RTC, LCD und Relaismodul”

  1. Merz Günther sagt:
    5. November 2024 um 18:31 Uhr

    Hallo
    Vielen Dank für die tolle Erklärung, ich habe dazu noch eine Frage, Schaltet das Relais nur zu dem angegebenen Datum oder kann es so programmiert werden, das es jeden Tag zur gleichen Zeit schaltet?
    Könntest Du mir da weiter helfen?
    Vielen Dank schon mal im Voraus

    Antworten
  2. Pingback: Arduino und DS3231: Relais jeden Tag automatisch zur gleichen Uhrzeit schalten - Technik Blog
  3. Frankie sagt:
    3. März 2025 um 11:56 Uhr

    Alles gut erklärt leider generiert der Sketch tausend und eine Fehlermeldung, die ich nicht auflösen kann. Es scheint unmöglich zu sein mit der RTC DS3231 ein Relais zu steuern, das einmal oder mehermals am Tag irgendwas ein oder ausschalten kann.
    Mich würde auch interessieren wie der ganze Code aussieht. Nicht um abzukopieren sondern um auszuschließen das ich Teile davon übersehe.
    Ich benutze immer einen Arduino Nano weil ich schon 6 Stück davon habe!
    Mein Projekt ist eine kleine Uhr mit Thermometer und die Möglichkeit mit einem Relais etwas ein oder auszuschalten. Die Uhrzeit und Temperatur wird angezeigt auf einem 1602A Display.

    Antworten
    1. Stefan Draeger sagt:
      3. März 2025 um 12:19 Uhr

      Hi,

      das klingt interessant, magst du mir das mal bitte an info@draeger-it.blog senden?

      Gruß, Stefan Draeger

      Antworten

Schreibe einen Kommentar Antworten abbrechen

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

Fragen oder Feedback?

Du hast eine Idee, brauchst Hilfe oder möchtest Feedback loswerden?
Support-Ticket erstellen

Newsletter abonnieren

Bleib auf dem Laufenden: Erhalte regelmäßig Updates zu neuen Projekten, Tutorials und Tipps rund um Arduino, ESP32 und mehr – direkt in dein Postfach.

Jetzt Newsletter abonnieren

Unterstütze meinen Blog

Wenn dir meine Inhalte gefallen, freue ich mich über deine Unterstützung auf Tipeee.
So hilfst du mit, den Blog am Leben zu halten und neue Beiträge zu ermöglichen.

draeger-it.blog auf Tipeee unterstützen

Vielen Dank für deinen Support!
– Stefan Draeger

Kategorien

Tools

  • Unix-Zeitstempel-Rechner
  • ASCII Tabelle
  • Spannung, Strom, Widerstand und Leistung berechnen
  • Widerstandsrechner
  • 8×8 LED Matrix Tool
  • 8×16 LED Matrix Modul von Keyestudio
  • 16×16 LED Matrix – Generator

Links

Blogverzeichnis Bloggerei.de TopBlogs.de das Original - Blogverzeichnis | Blog Top Liste Blogverzeichnis trusted-blogs.com

Stefan Draeger
Königsberger Str. 13
38364 Schöningen

Tel.: 01778501273
E-Mail: info@draeger-it.blog

Folge mir auf

  • Impressum
  • Datenschutzerklärung
  • Disclaimer
  • Cookie-Richtlinie (EU)
©2025 Technik Blog | Built using WordPress and Responsive Blogily theme by Superb
Cookie-Zustimmung verwalten
Wir verwenden Technologien wie Cookies, um Geräteinformationen zu speichern und/oder darauf zuzugreifen. Wir tun dies, um das Surferlebnis zu verbessern und um personalisierte Werbung anzuzeigen. Wenn Sie diesen Technologien zustimmen, können wir Daten wie das Surfverhalten oder eindeutige IDs auf dieser Website verarbeiten. Wenn Sie Ihre Zustimmung nicht erteilen oder zurückziehen, können bestimmte Funktionen beeinträchtigt werden.
Funktional Immer aktiv
Die technische Speicherung oder der Zugang ist unbedingt erforderlich für den rechtmäßigen Zweck, die Nutzung eines bestimmten Dienstes zu ermöglichen, der vom Teilnehmer oder Nutzer ausdrücklich gewünscht wird, oder für den alleinigen Zweck, die Übertragung einer Nachricht über ein elektronisches Kommunikationsnetz durchzuführen.
Vorlieben
Die technische Speicherung oder der Zugriff ist für den rechtmäßigen Zweck der Speicherung von Präferenzen erforderlich, die nicht vom Abonnenten oder Benutzer angefordert wurden.
Statistiken
Die technische Speicherung oder der Zugriff, der ausschließlich zu statistischen Zwecken erfolgt. Die technische Speicherung oder der Zugriff, der ausschließlich zu anonymen statistischen Zwecken verwendet wird. Ohne eine Vorladung, die freiwillige Zustimmung deines Internetdienstanbieters oder zusätzliche Aufzeichnungen von Dritten können die zu diesem Zweck gespeicherten oder abgerufenen Informationen allein in der Regel nicht dazu verwendet werden, dich zu identifizieren.
Marketing
Die technische Speicherung oder der Zugriff ist erforderlich, um Nutzerprofile zu erstellen, um Werbung zu versenden oder um den Nutzer auf einer Website oder über mehrere Websites hinweg zu ähnlichen Marketingzwecken zu verfolgen.
Optionen verwalten Dienste verwalten Verwalten von {vendor_count}-Lieferanten Lese mehr über diese Zwecke
Einstellungen anzeigen
{title} {title} {title}