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

Ü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.

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:

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.

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

Bauteil	Arduino UNO R3	Kabelfarbe
2fach Relais Modul
VCC	5 V	rot
GND	GND	schwarz
IN1	D9	braun
IN2	D8	blau
RealtimeClock (RTC DS3132)
VCC	5 V	rot
GND	GND	schwarz
SDA	A4	gelb
SCL	A5	grün
LCD-Display
VCC	5 V	rot
GND	GND	schwarz
SDA	A4	gelb
SCL	A5	grü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
}

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.

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.

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.