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