Ich möchte dir eine drahtlose Steuerung mit ESP32 und einem Shelly i4 DC vorstellen, mit der du Smart-Home-Geräte komfortabel bedienen kannst. Viele setzen dabei auf Sprachassistenten wie Alexa oder Google Assistant – doch nicht jeder möchte sich einen „Spion“ ins Haus holen, der dauerhaft zuhört. Eine Funksteuerung mit ESP32 und Shelly i4 DC ist eine sichere, lokale und flexible Alternative, die ohne Cloud oder Internet funktioniert.
Den Shelly i4 DC habe ich bereits ausführlich in meinem Beitrag „Smarter Schalter für Gleichspannung: Der Shelly i4 DC im Detail“ vorgestellt. Zudem findest du auf meinem Blog bereits zahlreiche Beiträge zum ESP32, da dieser Mikrocontroller eine perfekte Grundlage für smarte DIY-Projekte bietet.
Mit einer 4-Tasten-Funkfernbedienung und dem Shelly i4 DC lassen sich bis zu vier verschiedene Aktionen ausführen – von der Lichtsteuerung bis zum Öffnen des Garagentors. In diesem Beitrag zeige ich dir, wie du diese praktische und datenschutzfreundliche Smart-Home-Lösung umsetzt.
Inhaltsverzeichnis
- Warum diese Schaltung, wenn Shelly auch per WebHook steuerbar ist?
- Die richtige Funkfernbedienung wählen
- Benötigte Hardware für das Projekt
- Aufbau der Schaltung – Shelly i4 DC via Funkfernbedienung über ESP32 steuern
- Programmieren – drahtlose Steuerung eines Shelly i4 DC am ESP32
- Schritt-für-Schritt-Anleitung
- Erweiterte Möglichkeit: Bis zu 8 Geräte mit einem 4-fach Relais steuern
Warum diese Schaltung, wenn Shelly auch per WebHook steuerbar ist?
Theoretisch kann man jeden Shelly direkt über WebHooks steuern, indem man HTTP-Requests an das Gerät sendet. Damit ließen sich Shelly-Produkte ganz ohne zusätzliche Hardware per WLAN in ein Smart-Home-System einbinden.
Aber: Was, wenn du eine unabhängige, einfache Lösung suchst?
Ich möchte dir hier eine alternative Schaltung zeigen, mit der du Geräte in deinem Smart Home über eine klassische Funkfernbedienung (433 MHz) bedienen kannst – ohne WLAN, Cloud oder App. Diese Lösung ist besonders dann interessant, wenn du:
✔ Geräte lokal und offline steuern möchtest, ohne auf eine Internetverbindung angewiesen zu sein.
✔ Eine einfache Fernsteuerung bevorzugst, die keine App oder komplizierte Einrichtung erfordert.
✔ Ein bestehendes Funk-Setup mit 433 MHz Fernbedienungen nutzt und dieses mit Shelly kombinieren möchtest.
Dazu setze ich einen ESP32 mit einem 433 MHz Funkempfänger und einem 4-fach Relais-Modul ein. Die Relais steuern die Eingänge des Shelly i4 DC, sodass du mit einer drahtlosen 4-Tasten-Fernbedienung bis zu vier verschiedene Smart-Home-Aktionen auslösen kannst.
Die richtige Funkfernbedienung wählen
Wer eine passende 4-Tasten-Funkfernbedienung sucht, findet auf AliExpress und eBay eine große Auswahl an Modellen. Wichtig ist, auf die Frequenz zu achten: In Deutschland sind 433 MHz-Modelle erlaubt und weit verbreitet, während 333 MHz-Fernbedienungen hier nicht genutzt werden dürfen. Dies ergibt sich aus dem Frequenzplan der Bundesnetzagentur, der die zulässigen Funkfrequenzen regelt. Achte daher beim Kauf darauf, dass das gewählte Modell den gesetzlichen Vorgaben entspricht.
Das 433 MHz Funksender Kit für den Arduino habe ich dir bereits im Beitrag Arduino Tutorial 37: 433 MHz Sender & Empfänger
Benötigte Hardware für das Projekt
Für dieses Projekt kommen folgende Hardware-Komponenten zum Einsatz:
- ESP32-S3 Super Mini von Waveshare* – ein leistungsstarker Mikrocontroller mit WLAN- und Bluetooth-Funktionalität
- Shelly i4 DC* – ein smarter Schalter mit vier digitalen Eingängen für Gleichspannung
- 433 MHz Funkempfänger* – zur drahtlosen Signalübertragung von der Fernbedienung an den ESP32
- 433 MHz Funksender* – ermöglicht das Senden von Signalen an andere Geräte (günstig im 2er-Set erhältlich)
- vierfach-Relais-Modul* – dient zur galvanischen Trennung und ermöglicht das Schalten der Eingänge am Shelly i4 DC
- diverse Breadboardkabel & 400-Pin Breadboard* – für eine einfache Verdrahtung ohne Löten
- ein USB-Netzteil* – wird für die Stromversorgung des Mikrocontrollers und des Shellys benötigt
- ein Power-Supply-Modul für Breadboard* – über dieses Modul kann man 5V & 3.3V abgreifen um unter anderem den Shelly zu betreiben
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!
Stromversorgung
Sowohl der ESP32-S3 Super Mini als auch der Shelly i4 DC benötigen eine Stromquelle. Hier eignet sich theoretisch ein einfaches USB-Netzteil*, das sich leicht zweckentfremden lässt. Da der Shelly i4 DC bereits ab 5V betrieben werden kann und weniger als 1W Leistungsaufnahme hat, reicht ein handelsübliches Netzteil vollkommen aus.
Aufbau der Schaltung – Shelly i4 DC via Funkfernbedienung über ESP32 steuern
Nachfolgend die kleine Schaltung im Schaubild wie die Komponenten zusammenarbeiten.
| Komponente | ESP32-S3 Mini |
|---|---|
| 4fach Relais Modul | |
| VCC | 5V |
| GND | GND |
| IN1 | GP2 |
| IN2 | GP3 |
| IN3 | GP4 |
| IN4 | GP5 |
| 433 MHz Funkempfänger | |
| VCC | 5V |
| GND | GND |
| DATA | GP1 |
Anschlussklemme des Relais
Ein 4-fach Relaismodul bietet für jeden Kanal eine dreipolige Anschlussklemme, bestehend aus:
- Links (NC – Normally Closed) → Ausgang aktiv, wenn die Relais-LED AUS ist
- Mitte (COM – Common) → Gemeinsamer Anschluss für den Schaltkreis
- Rechts (NO – Normally Open) → Ausgang aktiv, wenn die Relais-LED AN ist
Verdrahtung mit dem Shelly i4 DC
- Der GND-Anschluss des Shelly i4 DC wird mit dem rechten (GND) Anschluss der Relaisklemme verbunden.
- Die Eingänge des Shelly i4 DC können entweder über den mittleren (NO) oder linken (NC) Kontakt mit dem Relais verbunden werden, je nach gewünschtem Schaltverhalten:
- NO (Normally Open): Eingang wird aktiv, wenn das Relais anzieht (LED leuchtet).
- NC (Normally Closed): Eingang wird aktiv, wenn das Relais nicht angezogen ist (LED aus).
Pinout des ESP32-S3 Mini
Nachfolgend das Pinout des ESP32-S3-Zero von Waveshare.
Programmieren – drahtlose Steuerung eines Shelly i4 DC am ESP32
fertiges Programm
Quellcode
/*
Projekt: Smarthome ohne Spionage – Funksteuerung für den Shelly i4 DC mit ESP32
Autor: Stefan Draeger
Blog: https://draeger-it.blog
Beitrag: https://draeger-it.blog/smarthome-ohne-spionage-esp32-und-shelly-i4-dc-als-drahtlose-steuerung-fuer-dein-zuhause/
Beschreibung:
Dieser Code ermöglicht es, einen Shelly i4 DC über ein 4-fach Relais-Modul zu steuern.
Die Relais werden mit einem 433 MHz Funkempfänger in Kombination mit einem Handsender geschaltet.
Der ESP32 empfängt die Funksignale und schaltet entsprechend die Relais,
welche die Eingänge des Shelly i4 DC bedienen.
Benötigte Hardware:
- ESP32 (z. B. ESP32-S3 Super Mini)
- 433 MHz Funkempfänger
- 433 MHz Funksender
- 4-fach Relais-Modul
- Shelly i4 DC
- Passende Netzteile für ESP32 und Shelly
Hinweis:
Der Code nutzt die RCSwitch-Bibliothek, um die 433 MHz Funksignale zu dekodieren.
*/
#include <RCSwitch.h>
// Initialisierung des RCSwitch-Objekts zur Kommunikation mit dem 433 MHz Empfänger
RCSwitch rcSwitch = RCSwitch();
// Definition der GPIO-Pins
#define remotePin 1 // Empfangs-Pin für den 433 MHz Empfänger
#define relais1 2 // Steuerpin für Relais 1
#define relais2 3 // Steuerpin für Relais 2
#define relais3 4 // Steuerpin für Relais 3
#define relais4 5 // Steuerpin für Relais 4
// Definition von Zuständen für die Relaissteuerung
#define AN true // Relais einschalten
#define AUS false // Relais ausschalten
// Codes für die 433 MHz Funkfernbedienung (Ein- und Ausschalten der Relais)
const long TASTE_1_ON = 83029;
const long TASTE_1_OFF = 83028;
const long TASTE_2_ON = 86101;
const long TASTE_2_OFF = 86100;
const long TASTE_3_ON = 70741;
const long TASTE_3_OFF = 70740;
const long TASTE_4_ON = 21589;
const long TASTE_4_OFF = 21588;
void setup() {
Serial.begin(9600); // Serielle Kommunikation starten
rcSwitch.enableReceive(remotePin); // Aktivierung des 433 MHz Empfängers auf remotePin
// Setzen der Relais-Pins als Ausgang
pinMode(relais1, OUTPUT);
pinMode(relais2, OUTPUT);
pinMode(relais3, OUTPUT);
pinMode(relais4, OUTPUT);
// Alle Relais beim Start ausschalten
digitalWrite(relais1, AUS);
digitalWrite(relais2, AUS);
digitalWrite(relais3, AUS);
digitalWrite(relais4, AUS);
}
void loop() {
// Prüfen, ob ein Signal vom 433 MHz Handsender empfangen wurde
if (rcSwitch.available()) {
long remoteValue = rcSwitch.getReceivedValue(); // Empfangenen Code auslesen
rcSwitch.resetAvailable(); // Empfangsstatus zurücksetzen
Serial.println(remoteValue); // Empfangenen Code zur Diagnose ausgeben
// Überprüfung, ob der empfangene Code einem gespeicherten Befehl entspricht
switch (remoteValue) {
case TASTE_1_ON: toggleRelais(relais1, AN); break;
case TASTE_1_OFF: toggleRelais(relais1, AUS); break;
case TASTE_2_ON: toggleRelais(relais2, AN); break;
case TASTE_2_OFF: toggleRelais(relais2, AUS); break;
case TASTE_3_ON: toggleRelais(relais3, AN); break;
case TASTE_3_OFF: toggleRelais(relais3, AUS); break;
case TASTE_4_ON: toggleRelais(relais4, AN); break;
case TASTE_4_OFF: toggleRelais(relais4, AUS); break;
default:
Serial.println("Code : " + String(remoteValue) + " nicht behandelt!"); // Fehlermeldung, falls Code unbekannt
}
}
}
// Funktion zur Steuerung eines Relais
void toggleRelais(int pin, bool newStatus) {
digitalWrite(pin, newStatus); // Setzt das Relais auf AN oder AUS
}
Auslesen einer Funkfernbedienung
Jede Taste an einer Funkfernbedienung hat eine eigene einzigartige ID welche wir zunächst ermitteln müssen. Dazu reicht das kleine Script aus dem bereits veröffentlichten Beitrag Arduino Tutorial 37: 433 MHz Sender & Empfänger.
/*
Projekt: 433 MHz Signalempfang mit RCSwitch
Autor: Stefan Draeger
Webseite: https://draeger-it.blog
Beschreibung:
Dieser Code dient dazu, Signale von einem 433 MHz Funksender zu empfangen und auf der seriellen Schnittstelle auszugeben.
Der ESP32 oder Arduino empfängt dabei Funksignale von einer 433 MHz Fernbedienung oder anderen kompatiblen Sendern.
Benötigte Hardware:
- 433 MHz Funkempfänger
- Mikrocontroller (z. B. ESP32 oder Arduino)
- Serielle Schnittstelle für die Diagnose
*/
#include <RCSwitch.h> // Einbinden der Bibliothek für die 433 MHz Funkkommunikation
// Erstellen eines Objekts für die RCSwitch-Klasse zur Steuerung des Funkempfängers
RCSwitch rcSwitch = RCSwitch();
void setup() {
Serial.begin(9600); // Start der seriellen Kommunikation mit 9600 Baud
// Aktivierung des 433 MHz Empfängers auf Interrupt-Pin 0 (digitaler Pin 2 auf Arduino)
rcSwitch.enableReceive(0);
}
void loop() {
// Überprüfung, ob neue Daten vom 433 MHz Sender empfangen wurden
if (rcSwitch.available()) {
// Ausgabe des aktuellen Zeitstempels (Millisekunden seit dem Start des Mikrocontrollers)
Serial.print("[");
Serial.print(millis());
Serial.print("] - ");
// Ausgabe des empfangenen Codes auf der seriellen Schnittstelle
Serial.println(rcSwitch.getReceivedValue());
// Zurücksetzen des Empfängers, damit neue Signale verarbeitet werden können
rcSwitch.resetAvailable();
}
}
Schritt-für-Schritt-Anleitung
Nachfolgend erläutere ich dir den Aufbau des Quellcodes für eine drahtlose Steuerung des Shelly i4 über einen ESP32.
Schritt 1 – einbinden der Bibliothek und definieren der Pins
Für den 433 MHz Funkempfänger benötigen wir zusätzlich eine Bibliothek. Hier verwende ich „rc-switch von sui77“ welche über den Bibliotheksverwalter installiert werden kann wenn du nach „rc-switch“ suchst.
#include <RCSwitch.h> // Bibliothek für die 433 MHz Funkkommunikation einbinden // Initialisierung des RCSwitch-Objekts zur Kommunikation mit dem 433 MHz Empfänger RCSwitch rcSwitch = RCSwitch(); // Definition der GPIO-Pins #define remotePin 1 // Empfangs-Pin für den 433 MHz Empfänger #define relais1 2 // Steuerpin für Relais 1 #define relais2 3 // Steuerpin für Relais 2 #define relais3 4 // Steuerpin für Relais 3 #define relais4 5 // Steuerpin für Relais 4 // Definition der Zustände für die Relaissteuerung #define AN true // Relais EIN #define AUS false // Relais AUS
Schritt 2 – Konstanten für die Tasten
Über das kleine Programm oben habe ich nachfolgende Codes der Tasten ermittelt. Da sich diese Werte nicht ändern habe ich diese in Konstanten abgelegt.
// Codes für die 433 MHz Funkfernbedienung (Ein- und Ausschalten der Relais) const long TASTE_1_ON = 83029; const long TASTE_1_OFF = 83028; const long TASTE_2_ON = 86101; const long TASTE_2_OFF = 86100; const long TASTE_3_ON = 70741; const long TASTE_3_OFF = 70740; const long TASTE_4_ON = 21589; const long TASTE_4_OFF = 21588;
Schritt 3 – Funktion setup
Die Funktion setup wird einmalig aufgerufen wenn der Mikrocontroller startet oder auch neugestartet wird. Hier definieren wir die Pins des Relais Moduls als Ausgang und deaktivieren initial die Relais.
void setup() {
Serial.begin(9600); // Serielle Kommunikation starten
rcSwitch.enableReceive(remotePin); // Aktivierung des 433 MHz Empfängers auf remotePin
// Setzen der Relais-Pins als Ausgang
pinMode(relais1, OUTPUT);
pinMode(relais2, OUTPUT);
pinMode(relais3, OUTPUT);
pinMode(relais4, OUTPUT);
// Alle Relais beim Start ausschalten
digitalWrite(relais1, AUS);
digitalWrite(relais2, AUS);
digitalWrite(relais3, AUS);
digitalWrite(relais4, AUS);
}
Schritt 4 – Funktion loop
Die Funktion loop wird dauerhaft ausgeführt bis der Strom abfällt oder ein Fehler auftritt.
void loop() {
// Prüfen, ob ein Signal vom 433 MHz Handsender empfangen wurde
if (rcSwitch.available()) {
long remoteValue = rcSwitch.getReceivedValue(); // Empfangenen Code auslesen
rcSwitch.resetAvailable(); // Empfangsstatus zurücksetzen
Serial.println(remoteValue); // Empfangenen Code zur Diagnose ausgeben
//Switch/Case Abfrage
}
}
Schritt 4.1 – Switch / Case für die Tasten
Über eine switch Anweisung kann man einfach den empfangenen Wert mit den der Tasten vergleichen.
// Überprüfung, ob der empfangene Code einem gespeicherten Befehl entspricht
switch (remoteValue) {
case TASTE_1_ON: toggleRelais(relais1, AN); break;
case TASTE_1_OFF: toggleRelais(relais1, AUS); break;
case TASTE_2_ON: toggleRelais(relais2, AN); break;
case TASTE_2_OFF: toggleRelais(relais2, AUS); break;
case TASTE_3_ON: toggleRelais(relais3, AN); break;
case TASTE_3_OFF: toggleRelais(relais3, AUS); break;
case TASTE_4_ON: toggleRelais(relais4, AN); break;
case TASTE_4_OFF: toggleRelais(relais4, AUS); break;
default:
Serial.println("Code : " + String(remoteValue) + " nicht behandelt!"); // Fehlermeldung, falls Code unbekannt
}
Erweiterte Möglichkeit: Bis zu 8 Geräte mit einem 4-fach Relais steuern
Theoretisch lassen sich mit dieser Schaltung nicht nur vier, sondern bis zu neun verschiedene Geräte steuern – indem man die vier Eingänge des Shelly i4 DC als Bitmuster verwendet.
Wie funktioniert das?
- Die ersten drei Eingänge (SW1,SW2, SW3) des Shelly i4 DC werden als Binärcode für die Gerätewahl genutzt.
- Der vierte Eingang (SW4) wird als Bestätigungssignal (High-Pegel) verwendet, um die Auswahl auszuführen.
Bitmuster für die Geräteauswahl
| SW1 | SW2 | SW3 | Gerät |
|---|---|---|---|
| 0 | 0 | 0 | Gerät 1 |
| 0 | 0 | 1 | Gerät 2 |
| 0 | 1 | 0 | Gerät 3 |
| 0 | 1 | 1 | Gerät 4 |
| 1 | 0 | 0 | Gerät 5 |
| 1 | 0 | 1 | Gerät 6 |
| 1 | 1 | 0 | Gerät 7 |
| 1 | 1 | 1 | Gerät 8 |
| x | x | x | Keine Aktion (SW4 nicht aktiviert) |
Ablauf der Steuerung
- Mit der Funkfernbedienung wird ein 3-Bit-Muster auf die Eingänge SW1-SW3 gesetzt (z. B. „101“ für Gerät 6).
- Sobald SW4 auf High gesetzt wird, wertet der Shelly das Bitmuster aus und schaltet das zugewiesene Gerät.
- Danach werden alle Eingänge zurückgesetzt, um eine neue Auswahl zu ermöglichen.
Vorteile dieser Methode
✔ Erweitert die Steuerungsmöglichkeiten erheblich – statt nur 4 sind bis zu 8 Geräte steuerbar.
✔ Nutzt die vorhandenen Relais effizient – kein zusätzliches Hardware-Modul nötig.
✔ Schnelle und flexible Steuerung – einfach per Funkfernbedienung umsetzbar.
Diese Methode zeigt, wie viel Potenzial in der Kombination aus ESP32, Shelly i4 DC und einem 4-fach Relais-Modul steckt! 🚀