Zeitschaltuhr mit ESP32, DS3231 & Relais bauen: Geräte zeitgesteuert schalten

Warum selbst bauen statt Steckdosen-Timer kaufen?

Fertige Zeitschaltuhren sind billig – aber starr. Willst du eine Aquarium-Beleuchtung morgens und abends für je zwei Stunden, dazwischen aus, plus eine CO₂-Pumpe mit eigenem Rhythmus, stößt die Baumarktlösung schnell an ihre Grenzen. Eine selbst gebaute Schaltuhr auf ESP32-Basis kennt diese Grenzen nicht: Du definierst so viele Schaltzeiten, wie du willst, kombinierst Bedingungen und kannst das Ganze später sogar per WLAN steuern.

Das Herzstück der Genauigkeit ist die DS3231-Echtzeituhr. Sie hat einen eigenen, temperaturkompensierten Quarz und eine Knopfzelle – dadurch tickt sie autark weiter, selbst wenn der ESP32 stromlos ist. Nach einem Stromausfall kennt deine Schaltuhr also sofort wieder die exakte Zeit, ohne dass du irgendetwas neu stellen musst. Ihre Abweichung liegt bei nur rund zwei Minuten pro Jahr.

Das brauchst du

1Verkabelung

Zuerst die DS3231 und das OLED an den I2C-Bus des ESP32, dann das Relais an einen freien GPIO:

2Die Uhr einmalig stellen

Damit die Schaltuhr weiß, wie spät es ist, setzen wir die DS3231 einmalig auf die aktuelle Zeit. Wir nutzen die RTClib von Adafruit (über den Bibliotheksverwalter installieren). Der folgende Sketch stellt die Uhr auf die Compile-Zeit deines PCs.

#include <Wire.h>
#include "RTClib.h"

RTC_DS3231 rtc;

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);          // SDA=21, SCL=22 beim ESP32
  if (!rtc.begin()) {
    Serial.println("DS3231 nicht gefunden!");
    while (1) delay(100);
  }

  // Setzt die Uhr auf die Compile-Zeit.
  // NUR EINMAL aktiv lassen, danach auskommentieren!
  rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}

void loop() {
  DateTime t = rtc.now();
  Serial.printf("%02d:%02d:%02d\n", t.hour(), t.minute(), t.second());
  delay(1000);
}

3Das Relais testen

Bevor wir Zeiten programmieren, prüfen wir, ob das Relais sauber schaltet. Dieser Sketch klickt es im Sekundentakt an und aus – du hörst das charakteristische Klicken und siehst die LED auf dem Modul.

const int RELAIS = 26;

void setup() {
  pinMode(RELAIS, OUTPUT);
}

void loop() {
  digitalWrite(RELAIS, HIGH);   // Relais an (High-Level-Trigger)
  delay(1000);
  digitalWrite(RELAIS, LOW);    // Relais aus
  delay(1000);
}

4Schaltzeiten definieren

Jetzt kommt das Herz der Schaltuhr. Wir speichern die Schaltzeiten in einer kleinen Tabelle (einem Array von Strukturen). Jeder Eintrag hat eine Stunde, eine Minute und eine Aktion (an oder aus). So legst du beliebig viele Schaltpunkte fest – hier ein Beispiel für eine Aquarium-Beleuchtung, die zweimal am Tag läuft:

struct Schaltpunkt {
  int stunde;
  int minute;
  bool einschalten;   // true = an, false = aus
};

// Beliebig erweiterbar – hier vier Schaltpunkte:
Schaltpunkt plan[] = {
  {  8,  0, true  },   // 08:00 Uhr AN
  { 10,  0, false },   // 10:00 Uhr AUS
  { 18, 30, true  },   // 18:30 Uhr AN
  { 21, 30, false }    // 21:30 Uhr AUS
};
const int ANZAHL = sizeof(plan) / sizeof(plan[0]);

5Die komplette Schaltuhr

Jetzt verbinden wir Uhr, Schaltplan und Relais. Der Kniff: Wir prüfen einmal pro Minute, ob die aktuelle Uhrzeit einem Schaltpunkt entspricht – und schalten dann. Damit ein Schaltpunkt nicht 60-mal pro Minute auslöst, merken wir uns die zuletzt geprüfte Minute.

#include <Wire.h>
#include "RTClib.h"

RTC_DS3231 rtc;
const int RELAIS = 26;

struct Schaltpunkt { int stunde; int minute; bool einschalten; };
Schaltpunkt plan[] = {
  {  8,  0, true  },
  { 10,  0, false },
  { 18, 30, true  },
  { 21, 30, false }
};
const int ANZAHL = sizeof(plan) / sizeof(plan[0]);

int letzteMinute = -1;
bool relaisAn = false;

void schalte(bool an) {
  digitalWrite(RELAIS, an ? HIGH : LOW);
  relaisAn = an;
  Serial.println(an ? "-> EINGESCHALTET" : "-> AUSGESCHALTET");
}

void setup() {
  Serial.begin(115200);
  pinMode(RELAIS, OUTPUT);
  digitalWrite(RELAIS, LOW);
  Wire.begin(21, 22);
  rtc.begin();
}

void loop() {
  DateTime t = rtc.now();

  // nur einmal pro Minute pruefen
  if (t.minute() != letzteMinute) {
    letzteMinute = t.minute();

    for (int i = 0; i < ANZAHL; i++) {
      if (plan[i].stunde == t.hour() && plan[i].minute == t.minute()) {
        schalte(plan[i].einschalten);
      }
    }
  }
  delay(1000);
}

Das war's im Kern: Der ESP32 fragt jede Sekunde die Zeit ab, prüft aber nur beim Minutenwechsel den Schaltplan. Trifft eine Uhrzeit auf einen Schaltpunkt, schaltet das Relais – zuverlässig und sekundengenau dank DS3231.

6Robust: den Soll-Zustand berechnen

Statt nur auf Schaltpunkte zu reagieren, ermitteln wir bei jedem Durchlauf, welchen Zustand das Relais gerade jetzt haben sollte – nämlich den des letzten vergangenen Schaltpunkts. So ist die Schaltuhr auch nach einem Stromausfall sofort wieder im richtigen Zustand.

// gibt zurueck, ob das Relais zur aktuellen Zeit AN sein soll
bool sollZustand(DateTime t) {
  int jetzt = t.hour() * 60 + t.minute();   // Minuten seit Mitternacht
  bool zustand = false;
  int letzterPunkt = -1;

  // suche den juengsten Schaltpunkt, der schon vorbei ist
  for (int i = 0; i < ANZAHL; i++) {
    int pkt = plan[i].stunde * 60 + plan[i].minute;
    if (pkt <= jetzt && pkt > letzterPunkt) {
      letzterPunkt = pkt;
      zustand = plan[i].einschalten;
    }
  }
  return zustand;
}

void loop() {
  DateTime t = rtc.now();
  bool soll = sollZustand(t);

  if (soll != relaisAn) {   // nur schalten, wenn noetig
    schalte(soll);
  }
  delay(1000);
}

7Optional: Status auf dem OLED anzeigen

Ein kleines OLED-Display macht aus der Schaltuhr ein fertiges Gerät: Es zeigt die aktuelle Uhrzeit und ob der Ausgang gerade an ist. Installiere die Bibliotheken "Adafruit SSD1306" und "Adafruit GFX", dann ergänzt du:

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Adafruit_SSD1306 oled(128, 64, &Wire, -1);

void oledSetup() {
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);
}

void oledUpdate(DateTime t, bool an) {
  oled.clearDisplay();
  oled.setTextSize(2);
  oled.setCursor(0, 0);
  char buf[9];
  sprintf(buf, "%02d:%02d:%02d", t.hour(), t.minute(), t.second());
  oled.println(buf);

  oled.setTextSize(2);
  oled.setCursor(0, 34);
  oled.println(an ? "AUSGANG: AN" : "AUSGANG: AUS");
  oled.display();
}

Rufst du oledSetup() im setup() und oledUpdate(t, relaisAn) im loop() auf, hast du eine gut ablesbare Anzeige. Wie du das SSD1306 im Detail bedienst – Text, Grafik, Animationen – zeigt der Artikel OLED Display SSD1306 mit Arduino.

Troubleshooting