Manchmal entstehen die besten Projekte durch Fragen aus der Community – so auch dieses hier. Ein Leser hat mir über das Support-Formular geschrieben und wollte wissen, wie man ein Relais über Funk mit einem Arduino steuern kann, um damit kurzzeitig einen Elektromagneten zu aktivieren.
In diesem Beitrag zeige ich dir Schritt für Schritt, wie du genau das umsetzen kannst:
👉 Wir bauen eine kabellose Schaltung mit einem 433 MHz Sender-Empfänger-Paar,
👉 steuern damit ein Relaismodul,
👉 und schalten einen Elektromagneten für wenige Millisekunden ein.
Das Projekt eignet sich perfekt, um das Zusammenspiel von Funkkommunikation, Relais und Arduino-Programmierung zu verstehen – ideal für alle, die ihre ersten Funkprojekte starten oder bestehende Ideen erweitern möchten.
Inhaltsverzeichnis
- Was wird für die Schaltung benötig?
- Aufbau der Schaltung – 433 MHz Sender & Empfänger am Arduino
- Quellcode
Was wird für die Schaltung benötig?
Für unser Funkprojekt mit dem Arduino brauchst du nur wenige, aber entscheidende Komponenten. Ich verwende in meinem Aufbau folgende Bauteile:
- Zwei Arduino Mikrocontroller – in meinem Fall zwei Arduino Nano v3*
- 433 MHz Funk Sender & Empfänger Set*
- Ein Relaismodul*
- Einen Elektromagneten*
- Einen Taster*
- Eine externe Stromversorgung, passend zum Elektromagneten
- diverse Breadboardkabel*
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!
Mein verwendeter Elektromagnet arbeitet mit einer Versorgungsspannung von 4,6 bis 6 Volt.
Theoretisch könnte er direkt über einen freien digitalen Ausgangspin des Arduinos geschaltet werden – doch die Verwendung eines Relais ist deutlich sicherer, da so keine hohen Ströme durch den Mikrocontroller fließen und mögliche Schäden vermieden werden.
Als Spannungsquelle nutze ich ein Power Supply Modul für Breadboards*, das über USB mit einem einfachen Handy-Ladegerät betrieben wird. So lässt sich die gesamte Schaltung bequem mit Energie versorgen.
💡 Hinweis:
Es gibt auch 433 MHz Funksets mit 315 MHz-Frequenz, die vor allem auf Plattformen wie AliExpress.com sehr günstig angeboten werden.
Diese 315 MHz-Versionen dürfen in Deutschland von Privatpersonen nicht verwendet werden!
Achte daher unbedingt auf ein 433 MHz-Modul, um die gesetzlichen Bestimmungen einzuhalten.
💡 Tipp für den Alltag:
Am Ende dieses Beitrags zeige ich dir noch eine alternative Lösung mit einer einfachen Funkfernbedienung*.
Damit sparst du dir den zweiten Arduino und kannst das Relais mobil und direkt per Tastendruck schalten – ideal, wenn du deinen Elektromagneten oder andere Verbraucher schnell und unkompliziert steuern möchtest!
Aufbau der Schaltung – 433 MHz Sender & Empfänger am Arduino
Den grundlegenden Anschluss von 433 MHz Funkmodulen an den Arduino habe ich bereits in meinem früheren Beitrag Arduino Tutorial: 433 MHz Sender & Empfänger im Detail erklärt. Da dieser Artikel inzwischen etwas in die Jahre gekommen ist, möchte ich hier ein Update vorstellen – mit einer leicht angepassten Verdrahtung und einem praktischen Anwendungsbeispiel.
In diesem Projekt nutzen wir das 433 MHz Funkset nicht nur zur Datenübertragung, sondern um ein Relaismodul kabellos zu schalten, das wiederum einen Elektromagneten aktiviert.
Damit kombinieren wir Funkkommunikation und Laststeuerung in einem kompakten Aufbau – perfekt geeignet, um Funkmodule im Alltag praktisch einzusetzen.
Im nächsten Abschnitt zeige ich dir den vollständigen Schaltplan und erläutere, welche Pins beim Sender- und Empfänger-Arduino miteinander verbunden werden.
433 MHz Funksender am Arduino Nano v3
Der 433 MHz Funksender wird direkt mit dem Arduino Nano v3 verbunden und übernimmt die Aufgabe, ein Steuersignal über Funk zu senden.
Die Module arbeiten typischerweise mit 5 V, was perfekt zum Nano v3 passt.
Für eine stabile Übertragung sollte die Antenne (meist ein einfaches Stück Draht von ca. 17 cm Länge) nicht fehlen.
Anschlussbelegung:
| Funksender | Arduino Nano v3 | Beschreibung |
|---|---|---|
| VCC | 5 V | Betriebsspannung des Senders |
| GND | GND | Masseverbindung |
| DATA | D9 | Datenpin für das Senden des Signals |
| ANT | – (optional Drahtantenne) | Erhöht die Reichweite |
| Taster | Arduino Nano v3 | Beschreibung |
|---|---|---|
| Pin 1 | D4 | digitaler Pin welcher auf HIGH gezogen wird |
| Pin 2 | GND | Masseverbindung |
Im Sketch senden wir später über Pin D9 ein digitales Signal, das vom Empfänger-Arduino empfangen wird.
Die Reichweite liegt – je nach Umgebung und Antenne – zwischen 5 und 20 Metern in Innenräumen, im Freien auch deutlich mehr.
433 MHz Funkempfänger am Arduino Nano v3
Der 433 MHz Funkempfänger empfängt das Signal des Senders und gibt es an den Mikrocontroller weiter.
Auch er wird mit 5 V betrieben und benötigt eine saubere Spannungsversorgung, um Störungen zu vermeiden.
Anschlussbelegung:
| Funkempfänger | Arduino Nano v3 | Beschreibung |
|---|---|---|
| VCC | 5 V | Versorgungsspannung |
| GND | GND | Masseverbindung |
| DATA | D2 | Eingangssignal vom Sender |
| ANT | – (optional Drahtantenne) | Erhöht die Empfangsstabilität |
| Relaismodul | Arduino Nanov3 | Beschreibung |
|---|---|---|
| VCC | 5V | Versorgungsspannung |
| GND | GND | Masseverbindung |
| IN1 | D10 | digitales Signal zum aktivieren/deaktivieren des Relais |
| LED | Arduino Nanov3 | Beschreibung |
|---|---|---|
| Anode (kurzes Bein) | D7 | digitales Signal |
| Kathode (langes Bein) | 220 Ohm Vorwiderstand > GND | Masseverbindung |
Sobald der Empfänger ein Signal erkennt, liest der Arduino den Zustand des DATA-Pins (D2) aus und kann darauf reagieren – in unserem Fall wird damit das Relaismodul angesteuert, das wiederum den Elektromagneten aktiviert.
Quellcode
Zum programmieren nutze ich neben der Arduino IDE noch zusätzlich die Bibliothek RC Switch welche vom GitHub Repository sui77/rc-switch als ZIP-Datei heruntergeladen werden kann.
Sender mit Taster
/*
============================================================
Projekt: Arduino Funkprojekt – 433 MHz Sender (RCSwitch)
Beschreibung:
Sendet bei Tastendruck einen 24-Bit-Code per 433 MHz (OOK/ASK).
Entprellung erfolgt mit Bounce2. Sende-Wiederholungen sind
explizit auf 1 gesetzt, um Doppel-Empfänge zu vermeiden.
Pulsdauer ist auf ~350 µs eingestellt (RCSwitch Protokoll 1).
Blogbeitrag & Details:
https://draeger-it.blog/arduino-funkprojekt-relais-mit-433-mhz-sender-empfaenger/
============================================================
*/
#include <Bounce2.h>
#include <RCSwitch.h>
// ---------- Objekte ----------
Bounce bounce;
RCSwitch rcSwitch;
// ---------- Pins ----------
const uint8_t SEND_PIN = 9; // 433 MHz Sender-Datenpin
const uint8_t BTN_PIN = 4; // Taster gegen GND, interner Pullup aktiv
// ---------- Sende-Logik ----------
const uint32_t CODE = 9876UL; // Dein 24-Bit Code (Beispiel)
const uint8_t BITS = 24; // Bitlänge (muss zum Empfänger passen)
const unsigned long PAUSE = 500UL; // Sperrzeit zwischen Sendungen (ms)
unsigned long lastAction = 0; // Zeitpunkt der letzten Sendung
void setup() {
Serial.begin(115200);
// --- Button einrichten (internes Pullup + Entprellung) ---
bounce.attach(BTN_PIN, INPUT_PULLUP);
bounce.interval(5); // 5–10 ms sind praxisnah
// --- 433 MHz Sender konfigurieren ---
rcSwitch.enableTransmit(SEND_PIN);
rcSwitch.setRepeatTransmit(1); // Nur 1x senden -> weniger Doppel-Empfänge
rcSwitch.setPulseLength(350); // ~Protokoll 1 Standard (ca. 350 µs)
// Optional: rcSwitch.setProtocol(1); // explizit Protokoll 1
// Sofort startklar: Sperrzeit direkt "abgelaufen" setzen
lastAction = millis() - PAUSE;
// (Optional) Sendeleistung/Versorgung beachten:
// - 17,3 cm Draht als Antenne am Sender
// - Stabile 5V Versorgung laut Modulspezifikation
}
void loop() {
bounce.update();
// Nur auf "echten" Tastendruck reagieren (Flanke von HIGH -> LOW)
if (bounce.fell()) {
unsigned long now = millis();
// Sperrzeit beachten, um versehentliches Multisenden zu vermeiden
if ((now - lastAction) >= PAUSE) {
Serial.println(F("Button press -> sende Code"));
// 24-Bit Code senden
rcSwitch.send(CODE, BITS);
lastAction = now;
}
}
}
Empfänger mit LED & Relais
/*
============================================================
Projekt: Arduino Funkprojekt – 433 MHz Empfänger (RCSwitch)
Beschreibung:
Empfängt 24-Bit-Codes per 433 MHz (OOK/ASK) und schaltet:
- LED an Pin 7 (visuelles Feedback)
- Relais an Pin 10 (Impuls, standardmäßig Active-LOW)
Features zur Robustheit:
- Whitelist (nur erlaubte Codes)
- Duplikat-Filter (unterdrückt Doppel-Empfang kurz nacheinander)
- Engere Decoder-Toleranz
Blogbeitrag & Details:
https://draeger-it.blog/arduino-funkprojekt-relais-mit-433-mhz-sender-empfaenger/
============================================================
*/
#include <RCSwitch.h>
// --------- Objekte ----------
RCSwitch rcSwitch;
// --------- Pins ----------
const uint8_t LED_PIN = 7;
const uint8_t RELAIS_PIN = 10; // viele 5V-Module sind "active LOW"
// --------- Zeiten / Fenster ----------
const unsigned long ACTION_PAUSE = 2000UL; // Sperrzeit zwischen Aktionen (ms)
const unsigned long RELAIS_PULSE = 200UL; // Relais-Ansteuerung (ms)
const unsigned long DUP_WINDOW_MS = 180UL; // identische Werte in diesem Fenster ignorieren
// --------- Zustände ----------
bool ledOn = false;
unsigned long lastAction = 0;
unsigned long lastVal = 0;
unsigned long lastRxTime = 0;
// --------- Erlaubte Codes (Whitelist) ----------
const unsigned long TASTER_SENDER = 9876UL;
const unsigned long TASTE_A = 753832UL;
const unsigned long TASTE_B = 753828UL;
const unsigned long TASTE_C = 753826UL;
const unsigned long TASTE_D = 753825UL;
const unsigned long ALLOWED_SIGNALS[] = {
TASTER_SENDER, TASTE_A, TASTE_B, TASTE_C, TASTE_D
};
const uint8_t ALLOWED_LEN = sizeof(ALLOWED_SIGNALS) / sizeof(ALLOWED_SIGNALS[0]);
// --------- (Optional) Enge Decoder-Parameter ----------
// Wenn du die Werte deines Senders gemessen hast, kannst du zusätzlich
// auf Protokoll/Bitlänge/Pulsdauer filtern. Beispielwerte einkommentieren:
// const unsigned int EXPECT_PROTO = 1;
// const unsigned int EXPECT_BITS = 24;
// const unsigned int PULSE_MIN_US = 280;
// const unsigned int PULSE_MAX_US = 380;
static inline bool isAllowed(unsigned long v) {
for (uint8_t i = 0; i < ALLOWED_LEN; i++) {
if (ALLOWED_SIGNALS[i] == v) return true;
}
return false;
}
static inline void toggleLED() {
ledOn = !ledOn;
digitalWrite(LED_PIN, ledOn);
}
void setup() {
Serial.begin(115200);
// Empfänger an Interrupt 0 (D2 beim Nano)
rcSwitch.enableReceive(0);
rcSwitch.setReceiveTolerance(60); // enger als Standard → weniger Fehl-/Rausch-Decodes
pinMode(LED_PIN, OUTPUT);
pinMode(RELAIS_PIN, OUTPUT);
digitalWrite(RELAIS_PIN, HIGH); // viele Module sind Active-LOW: HIGH = aus, LOW = an
// Direkt startklar:
lastAction = millis() - ACTION_PAUSE;
// Debug: einmalig melden
Serial.println(F("433 MHz RX bereit (Whitelist, Duplikat-Filter aktiv)"));
}
void loop() {
if (!rcSwitch.available()) return;
const unsigned long now = millis();
const unsigned long value = rcSwitch.getReceivedValue();
// Meta-Infos (für evtl. spätere Filter)
const unsigned int bits = rcSwitch.getReceivedBitlength();
const unsigned int proto = rcSwitch.getReceivedProtocol();
const unsigned int pulse = rcSwitch.getReceivedDelay(); // µs
// 1) Duplikate innerhalb kurzer Zeit ausblenden
if (value == lastVal && (now - lastRxTime) < DUP_WINDOW_MS) {
rcSwitch.resetAvailable();
return;
}
// 2) Whitelist prüfen (nur bekannte Codes akzeptieren)
bool ok = isAllowed(value);
// 3) (Optional) Harte Timing-/Protokoll-Filter aktivieren
// ok = ok && (proto == EXPECT_PROTO) &&
// (bits == EXPECT_BITS) &&
// (pulse >= PULSE_MIN_US && pulse <= PULSE_MAX_US);
// 4) Aktion nur innerhalb der Sperrzeit zulassen
if (ok && (now - lastAction) >= ACTION_PAUSE) {
// Visuelles Feedback
toggleLED();
// Relais kurz anziehen (Active-LOW -> LOW aktivieren)
digitalWrite(RELAIS_PIN, LOW);
delay(RELAIS_PULSE);
digitalWrite(RELAIS_PIN, HIGH);
toggleLED();
lastAction = now;
Serial.print('['); Serial.print(now); Serial.print("] OK val=");
Serial.print(value);
Serial.print(" proto="); Serial.print(proto);
Serial.print(" bits="); Serial.print(bits);
Serial.print(" pulse="); Serial.println(pulse);
} else {
// Debug-Ausgabe für verworfene Frames (bei Bedarf einkommentieren)
// Serial.print('['); Serial.print(now); Serial.print("] DROP val=");
// Serial.print(value);
// Serial.print(" proto="); Serial.print(proto);
// Serial.print(" bits="); Serial.print(bits);
// Serial.print(" pulse="); Serial.println(pulse);
}
// 5) Empfangs-Kontext aktualisieren
lastVal = value;
lastRxTime = now;
rcSwitch.resetAvailable();
}
Letzte Aktualisierung am: 14. Oktober 2025
