433 MHz Funkmodul Arduino: Sender, Empfänger, Antenne und Code

Ein 433 MHz Funkmodul ist der günstigste Weg, einem Arduino-Projekt eine Funkverbindung zu geben: Ein Set aus Sender (FS1000A) und Empfänger (XY-MK-5V) kostet sehr wenig, wird mit einer einzigen Datenleitung angeschlossen und überträgt mit einer 17 cm langen Drahtantenne ein Signal über Dutzende Meter. Funksteckdosen, Funkklingeln, Rollladen-Fernbedienungen, Tür- und Fensterkontakte sowie die Außensensoren von Wetterstationen nutzen meist dieselbe Frequenz. Mit diesen Modulen kannst du also Daten zwischen zwei Arduinos senden und außerdem die Codes der Fernbedienungen in deinem Zuhause auslesen und vom Arduino aus erneut senden.

In dieser Anleitung lernst du, wie die Module mit ASK-(OOK-)Modulation arbeiten, warum die Antenne 17,3 cm lang sein sollte und wie du sie an Arduino Uno, ESP32 und Raspberry Pi Pico anschließt. Danach sendest du mit der RadioHead-Bibliothek Text und Sensordaten zwischen zwei Arduinos, liest mit der RCSwitch-Bibliothek den Code einer Funksteckdose aus und klonst ihn, erfährst, wie du die Reichweite erhöhst, und vergleichst das Modul mit dem nRF24L01.

Was ist ein 433 MHz Funkmodul und wie funktioniert es?

Das Set besteht aus zwei getrennten Platinen. Der kleine, quadratische Sender FS1000A (auch als XY-FST verkauft) schaltet je nach Signal an seinem DATA-Pin eine Trägerwelle von 433,92 MHz ein und aus. Der längere Empfänger XY-MK-5V fängt dieses Signal aus der Luft auf und gibt es an seinem DATA-Pin wieder als 0 und 1 aus. Die Module selbst haben also weder Protokoll noch Adresse oder Fehlerprüfung; ihre einzige Aufgabe ist es, ein digitales Signal drahtlos zur Gegenseite zu bringen. Daten verpacken, prüfen und entschlüsseln ist die Aufgabe der Bibliothek auf dem Arduino. Die Kommunikation ist unidirektional: Der Sender sendet nur, der Empfänger hört nur zu.

Die beiden DATA-Pins des Empfängers sind auf der Platine miteinander verbunden; es ist egal, welchen du verwendest. Der XY-MK-5V ist ein günstiger, aber wenig trennscharfer Pendelempfänger (superregenerativ): Seine Frequenz wird von einer einstellbaren Spule auf der Platine bestimmt, und er reagiert empfindlich auf Störungen in der Nähe. Dreh nicht an der Schraube dieser Spule; geht die Werkseinstellung verloren, hört der Empfänger den Sender nicht mehr. Für stabilere Ergebnisse sind Superhet-Empfänger wie der RXB6 empfindlicher und laufen auch mit 3,3 V. Das Set gibt es auch als 315-MHz-Version; Sender und Empfänger müssen dieselbe Frequenz haben, und auf dem Metallresonator der Senderplatine steht meist die Frequenz.

ASK-(OOK-)Modulation: Warum brauchst du eine Bibliothek?

Bei OOK (On-Off Keying), der einfachsten Form von ASK (Amplitude Shift Keying, Amplitudenumtastung), wird der Träger für ein 1-Bit ein- und für ein 0-Bit ausgeschaltet. Das klingt einfach, aber der Empfänger hat eine Eigenheit: Seine automatische Verstärkungsregelung (AGC) dreht die Verstärkung ohne Signal ganz auf, hält das Rauschen in der Luft für Daten und gibt am DATA-Pin ständig zufällige Impulse aus. Deshalb endet der Versuch, den Sender direkt an den TX-Pin und den Empfänger an den RX-Pin des Arduino anzuschließen und mit Serial.print zu kommunizieren, meist in wirren Zeichen.

Der Treiber RH_ASK der RadioHead-Bibliothek löst dieses Problem so: Vor jedem Paket sendet er eine 36-Bit-Präambel und ein 12-Bit-Startsymbol, damit sich die Verstärkung des Empfängers einpendeln kann. Danach wandelt er jedes Byte in zwei gleichspannungsfreie 6-Bit-Symbole um (4-zu-6-Kodierung) und hängt am Ende des Pakets eine 16-Bit-CRC an. Pakete mit falscher CRC verwirft der Empfänger stillschweigend; so kommen nur unversehrte Daten bei dir an. RCSwitch dagegen entschlüsselt die Pulsweitenkodierung der Fernbedienungschips: Jedes Bit wird durch Impulse dargestellt, die bestimmte Zeiten HIGH und LOW bleiben.

433 MHz Antenne: Warum 17,3 cm?

Die Module haben keine Antenne, nur einen Lötpunkt mit der Aufschrift ANT. Ohne Antenne funktioniert ein Set nur über 1–3 Meter. Die effizienteste einfache Antenne ist ein gerader Draht mit einem Viertel der Wellenlänge: λ = c / f = 300.000.000 / 433.920.000 ≈ 0,69 m, ein Viertel davon sind etwa 17,3 cm. Bei 315-MHz-Modulen ergibt dieselbe Rechnung 23,8 cm. Löte ein Ende eines Volldrahts an den ANT-Punkt und halte den Draht gerade und senkrecht; löte auch an den Empfänger einen gleich langen Draht und richte beide Antennen gleich aus.

433 MHz Funkmodul anschließen: Arduino Uno, ESP32 und Pico

Der Sender funktioniert auch mit einem 3,3-V-Signal am DATA-Pin problemlos; an ESP32 und Pico kannst du ihn also mit 5 V versorgen und DATA direkt an einen GPIO legen. Die Reichweite hängt am stärksten von der Senderspannung ab: Bei 3,3 V sinkt sie deutlich, bei 9–12 V steigt sie um ein Mehrfaches. Ein 100-nF-Keramik- und ein 10-µF-Elektrolytkondensator direkt an VCC und GND des Empfängers verringern Störungen aus der Versorgung und verbessern den Empfang sichtbar.

Nachrichten zwischen zwei Arduinos mit RadioHead senden

1. Öffne in der Arduino IDE den Bibliotheksverwalter, suche nach RadioHead und installiere die Bibliothek von Mike McCauley. Details findest du im Artikel Bibliothek in Arduino hinzufügen.
2. Schließe den Sender an den ersten Arduino an: DATA → D12, VCC → 5V, GND → GND.
3. Schließe den Empfänger an den zweiten Arduino an: DATA → D11, VCC → 5V, GND → GND.
4. Löte an den ANT-Punkt beider Module je einen 17,3 cm langen Draht.
5. Lade den Sendercode auf das erste und den Empfängercode auf das zweite Board und öffne auf der Empfängerseite den seriellen Monitor mit 9600 Baud.

1#include <RH_ASK.h>
2#include <SPI.h>                  // RadioHead derlemesi için / needed for RadioHead to compile
3
4RH_ASK rf(2000, 11, 12);          // hız (bps), RX pini, TX pini / speed (bps), RX pin, TX pin
5unsigned int sayac = 0;
6
7void setup() {
8  Serial.begin(9600);
9  if (!rf.init()) Serial.println("RF init hatasi / failed");
10}
11
12void loop() {
13  char mesaj[24];
14  snprintf(mesaj, sizeof(mesaj), "Merhaba %u", sayac++);
15  rf.send((uint8_t *)mesaj, strlen(mesaj));
16  rf.waitPacketSent();            // paket bitene kadar bekle / wait until the packet is sent
17  Serial.print("Gonderildi / sent: ");
18  Serial.println(mesaj);
19  delay(1000);
20}

1#include <RH_ASK.h>
2#include <SPI.h>                  // RadioHead derlemesi için / needed for RadioHead to compile
3
4RH_ASK rf(2000, 11, 12);          // vericiyle aynı hız / same speed as the transmitter
5
6void setup() {
7  Serial.begin(9600);
8  if (!rf.init()) Serial.println("RF init hatasi / failed");
9}
10
11void loop() {
12  uint8_t buf[RH_ASK_MAX_MESSAGE_LEN + 1];   // +1: metin sonu için / +1 for the string terminator
13  uint8_t len = RH_ASK_MAX_MESSAGE_LEN;      // her turda yeniden ayarla / reset on every pass
14  if (rf.recv(buf, &len)) {                  // yalnız CRC doğruysa true / true only if the CRC is valid
15    buf[len] = '\0';
16    Serial.print("Alindi / received: ");
17    Serial.println((char *)buf);
18  }
19}

Im Empfängercode ist es wichtig, die Variable len bei jedem Durchlauf neu zu setzen: recv() schreibt die Größe des empfangenen Pakets hinein, und beim nächsten Aufruf wird dieser Wert als Puffergröße verstanden; ohne Zurücksetzen werden längere Nachrichten abgeschnitten. Wenn alles stimmt, siehst du im seriellen Monitor jede Sekunde die Zeilen "Merhaba 0", "Merhaba 1". Fehlen Zahlen, sind unterwegs Pakete verloren gegangen; prüfe dann Antenne und Stromversorgung.

Sensordaten senden: ein Paket mit struct

In echten Projekten ist es effizienter, Zahlen statt Text zu senden. Du kannst deine Messwerte in einem struct sammeln und dessen Bytes unverändert senden. Der Sender unten schickt fünfmal pro Sekunde den Wert eines LDR oder Potentiometers an A0 und den Zustand des Tasters an D2. Der Empfänger schaltet die LED an D13 ein, wenn der entfernte Taster gedrückt wird, und bemerkt verlorene Pakete.

1#include <RH_ASK.h>
2#include <SPI.h>
3
4struct __attribute__((packed)) Paket {   // iki tarafta birebir aynı olmalı / must be identical on both sides
5  uint16_t no;                           // paket numarası / packet number
6  int16_t deger;                         // analog değer / analog value
7  uint8_t buton;                         // 1 = basılı / 1 = pressed
8};
9
10RH_ASK rf;                               // varsayılan: 2000 bps, RX 11, TX 12 / defaults
11Paket p = {0, 0, 0};
12
13void setup() {
14  pinMode(2, INPUT_PULLUP);              // buton D2-GND / button D2-GND
15  rf.init();
16}
17
18void loop() {
19  p.no++;
20  p.deger = analogRead(A0);              // örneğin LDR ya da potansiyometre / e.g. LDR or potentiometer
21  p.buton = (digitalRead(2) == LOW);
22  rf.send((uint8_t *)&p, sizeof(p));
23  rf.waitPacketSent();
24  delay(200);
25}

1#include <RH_ASK.h>
2#include <SPI.h>
3
4struct __attribute__((packed)) Paket {
5  uint16_t no;
6  int16_t deger;
7  uint8_t buton;
8};
9
10RH_ASK rf;
11const int LED = 13;
12uint16_t sonNo = 0;
13
14void setup() {
15  Serial.begin(9600);
16  pinMode(LED, OUTPUT);
17  rf.init();
18}
19
20void loop() {
21  Paket p;
22  uint8_t len = sizeof(p);
23  if (rf.recv((uint8_t *)&p, &len) && len == sizeof(p)) {
24    digitalWrite(LED, p.buton ? HIGH : LOW);   // uzaktaki buton LED'i yakar / remote button lights the LED
25    if (sonNo != 0 && p.no != (uint16_t)(sonNo + 1)) {
26      Serial.println("Paket kaybi / packet lost");
27    }
28    sonNo = p.no;
29    Serial.print(p.no);
30    Serial.print("  A0 = ");
31    Serial.println(p.deger);
32  }
33}

Das Schlüsselwort __attribute__((packed)) verhindert, dass der Compiler Füllbytes zwischen die Felder einfügt. Das ist wichtig: Dasselbe struct kann auf dem Arduino Uno 5 und auf dem ESP32 6 Bytes belegen, und wenn zwei verschiedene Boards kommunizieren, verrutschen die Daten. Dank der Paketnummer kann der Empfänger verlorene Pakete zählen. Da 433-MHz-Module keine Empfangsbestätigung kennen, ist es eine gute Gewohnheit, wichtige Befehle mehrmals zu senden. Baust du auf beiden Seiten Sender und Empfänger ein, kannst du mit der Klasse RHReliableDatagram von RadioHead auch eine bestätigte Kommunikation mit Wiederholungen aufbauen.

Codes von Funkfernbedienungen mit RCSwitch auslesen

Viele Funksteckdosen, Funkklingeln, Rollladen- und Gartentor-Fernbedienungen sowie Tür-, Fenster- und PIR-Alarmsensoren verwenden Codechips wie den EV1527 oder PT2262. Bei jedem Tastendruck senden diese Chips denselben 12- bis 24-Bit-Code mehrmals hintereinander, getrennt durch Synchronisationspausen. Die Bibliothek RCSwitch (im Bibliotheksverwalter rc-switch) entschlüsselt diese Codes. Schließe den DATA-Pin des Empfängers am Uno an einen Interrupt-Pin an, also D2 oder D3, und lade den folgenden Code hoch:

1#include <RCSwitch.h>
2
3RCSwitch rf = RCSwitch();
4
5void setup() {
6  Serial.begin(9600);
7  rf.enableReceive(digitalPinToInterrupt(2));   // alıcı DATA -> D2 (kesme pini) / receiver DATA -> D2 (interrupt pin)
8  Serial.println(F("Kumandanin tusuna bas / press a remote button"));
9}
10
11void loop() {
12  if (rf.available()) {
13    Serial.print(F("Kod / code: "));
14    Serial.print(rf.getReceivedValue());
15    Serial.print(F("  Bit: "));
16    Serial.print(rf.getReceivedBitlength());
17    Serial.print(F("  Protokol / protocol: "));
18    Serial.print(rf.getReceivedProtocol());
19    Serial.print(F("  Darbe / pulse: "));
20    Serial.print(rf.getReceivedDelay());
21    Serial.println(F(" us"));
22    rf.resetAvailable();                         // bir sonraki koda hazırlan / get ready for the next code
23  }
24}

Öffne den seriellen Monitor und drücke eine Taste der Fernbedienung; du siehst eine Zeile wie "Kod / code: 5393 Bit: 24 Protokol / protocol: 1 Darbe / pulse: 350 us". Notiere für jede Taste Code, Bitlänge, Protokoll und Pulslänge; zum Klonen brauchst du alle vier. Bei Fernbedienungen mit EV1527 sind die ersten 20 der 24 Bits die Kennung der Fernbedienung und die letzten 4 die gedrückte Taste; deshalb liegen die Tastencodes derselben Fernbedienung sehr nah beieinander. Bei Protokoll 1 dauert eine Einheit etwa 350 µs: Ein 0-Bit ist 1 Einheit HIGH und 3 Einheiten LOW, ein 1-Bit 3 Einheiten HIGH und 1 Einheit LOW, und die Synchronisation 1 Einheit HIGH und 31 Einheiten LOW.

Den Fernbedienungscode vom Arduino senden

Um den ausgelesenen Code zu senden, verbinde den DATA-Pin des Senders mit D10 und zwei Taster zwischen D4 bzw. D5 und GND. Bei jedem Tastendruck wiederholt der Arduino den Code 10-mal, genau wie die Fernbedienung; die Ein- und Aus-Tasten der Steckdose sitzen jetzt auf deinem Arduino:

1#include <RCSwitch.h>
2
3RCSwitch rf = RCSwitch();
4const int BTN_AC = 4;            // "aç" butonu D4-GND / "on" button D4-GND
5const int BTN_KAPAT = 5;         // "kapat" butonu D5-GND / "off" button D5-GND
6
7void setup() {
8  pinMode(BTN_AC, INPUT_PULLUP);
9  pinMode(BTN_KAPAT, INPUT_PULLUP);
10  rf.enableTransmit(10);         // verici DATA -> D10 / transmitter DATA -> D10
11  rf.setProtocol(1);             // önce protokol... / protocol first...
12  rf.setPulseLength(350);        // ...sonra okuduğun darbe süresi / ...then the pulse length you read
13  rf.setRepeatTransmit(10);      // her gönderim 10 kez tekrarlanır / each send is repeated 10 times
14}
15
16void loop() {
17  if (digitalRead(BTN_AC) == LOW) {
18    rf.send(5393, 24);           // okuduğun "aç" kodu ve bit sayısı / the "on" code and bit length you read
19    delay(300);
20  }
21  if (digitalRead(BTN_KAPAT) == LOW) {
22    rf.send(5396, 24);           // okuduğun "kapat" kodu / the "off" code you read
23    delay(300);
24  }
25}

Da setProtocol() die Pulslänge auf den Standardwert des Protokolls zurücksetzt, musst du setPulseLength() immer danach aufrufen. Reagiert die Steckdose nicht, trage zuerst exakt die ausgelesene Pulslänge ein (z. B. 320 oder 420 µs) und erhöhe dann die Wiederholungen auf 15. Lernfähige Steckdosen bieten noch eine Abkürzung: Versetzt du die Steckdose in den Anlernmodus und sendest vom Arduino einen beliebigen 24-Bit-Code, speichert sie diesen Code. So kannst du eigene Codes erzeugen, ohne überhaupt eine Fernbedienung zu klonen.

433 MHz Empfänger am ESP32: Relais per Fernbedienung schalten

Der ESP32 ist eine ideale Brücke, um 433-MHz-Fernbedienungen mit der WLAN-Welt zu verbinden. RCSwitch läuft auch auf dem ESP32, und da jeder GPIO des ESP32 Interrupts auslösen kann, kannst du den Empfänger an jeden sicheren Pin anschließen. Der folgende Code liest die Codes eines Empfängers an GPIO 27 (über Spannungsteiler); kommt der Code deiner eigenen Fernbedienung, schaltet er die LED an GPIO 2 oder ein Relaismodul um. Weil eine Fernbedienung ihren Code bei einem Druck mehrfach sendet, schaltet das Programm erst wieder um, nachdem der Code 600 ms lang ausgeblieben ist:

1#include <RCSwitch.h>
2
3RCSwitch rf = RCSwitch();
4const int RX_PIN = 27;              // alıcı DATA, gerilim bölücüyle / receiver DATA, through a divider
5const int ROLE_PIN = 2;             // dahili LED ya da röle girişi / onboard LED or relay input
6const unsigned long KOD = 5393;     // kendi kumandanın kodu / your own remote's code
7bool durum = false;
8unsigned long sonGorulme = 0;
9
10void setup() {
11  Serial.begin(115200);
12  pinMode(ROLE_PIN, OUTPUT);
13  rf.enableReceive(digitalPinToInterrupt(RX_PIN));   // ESP32'de her GPIO kesme alır / every GPIO takes interrupts on the ESP32
14}
15
16void loop() {
17  if (rf.available()) {
18    unsigned long kod = rf.getReceivedValue();
19    Serial.printf("Kod / code: %lu  %u bit  protokol %u\n", kod, rf.getReceivedBitlength(), rf.getReceivedProtocol());
20    if (kod == KOD) {
21      // kumanda kodu art arda tekrarlar; yalnız yeni basışta değiştir / the remote repeats the code; toggle only on a new press
22      if (millis() - sonGorulme > 600) {
23        durum = !durum;
24        digitalWrite(ROLE_PIN, durum ? HIGH : LOW);
25      }
26      sonGorulme = millis();
27    }
28    rf.resetAvailable();
29  }
30}

Auf dieser Grundlage kannst du viel aufbauen: Leite empfangene Codes per MQTT an Home Assistant weiter, um günstige 433-MHz-Türsensoren in dein Smart Home einzubinden, oder steuere Steckdosen per Handy mit einem Sender an GPIO 26. Auch RadioHead unterstützt den ESP32; der einzige Unterschied ist, dass du die Pins im Konstruktor ausdrücklich angibst: RH_ASK rf(2000, 27, 26, 25); (Empfänger 27, Sender 26 und 25 als freier Pin für PTT). Wenn der ESP32 neu für dich ist, wirf einen Blick auf Was ist der ESP32?.

433 MHz Sender mit Raspberry Pi Pico und MicroPython

Für MicroPython gibt es kein fertiges Gegenstück zu RCSwitch, aber das Timing von Protokoll 1 ist so einfach, dass du es mit wenigen Zeilen selbst schreiben kannst. Verbinde VCC des FS1000A mit dem VBUS-Pin (5 V) des Pico, DATA mit GP15 und einen Taster zwischen GP16 und GND. Drückst du den Taster, sendet der Pico wie RCSwitch die 24 Bits beginnend mit dem höchstwertigen Bit, hängt den Synchronisationsimpuls an und wiederholt das ganze Paket 10-mal. Wenn du noch nicht weißt, wie du MicroPython auf den Pico bringst, beginne mit Was ist der Raspberry Pi Pico?.

1from machine import Pin
2import time
3
4tx = Pin(15, Pin.OUT, value=0)        # FS1000A DATA -> GP15
5buton = Pin(16, Pin.IN, Pin.PULL_UP)  # buton GP16-GND / button GP16-GND
6T = 350                               # darbe süresi µs (RCSwitch protokol 1) / pulse length µs (RCSwitch protocol 1)
7
8def darbe(yuksek, dusuk):             # süreler T cinsinden / durations in units of T
9    tx.value(1)
10    time.sleep_us(yuksek * T)
11    tx.value(0)
12    time.sleep_us(dusuk * T)
13
14def gonder(kod, bit=24, tekrar=10):
15    for _ in range(tekrar):
16        for i in range(bit - 1, -1, -1):   # en anlamlı bitten başla / start from the most significant bit
17            if (kod >> i) & 1:
18                darbe(3, 1)                # "1" biti: 3T HIGH, 1T LOW / bit "1"
19            else:
20                darbe(1, 3)                # "0" biti: 1T HIGH, 3T LOW / bit "0"
21        darbe(1, 31)                       # senkron: 1T HIGH, 31T LOW / sync
22
23while True:
24    if buton.value() == 0:                 # butona basıldı / button pressed
25        gonder(5393)                       # okuduğun kodu yaz / put the code you read here
26        time.sleep_ms(300)

Für den 125-MHz-Prozessor des Pico sind Impulse von 350 µs ein gemütliches Tempo; die kleinen Verzögerungen von Python bleiben weit unter der Zeittoleranz von 60 % der RCSwitch-Empfänger. Du kannst den Code sofort testen, indem du einen Arduino mit dem RCSwitch-Lesecode danebenlegst: Im seriellen Monitor sollte die gesendete Zahl erscheinen. Für den Empfang müsstest du die Pulslängen mit Zeitstempeln messen und entschlüsseln; dafür ist ein Arduino oder ESP32 mit RCSwitch praktischer.

Reichweite und Störungen: das Signal weiter tragen

• Vergiss die Antenne nicht: Löte auf beiden Seiten einen geraden 17,3-cm-Draht an; das hat den größten Einfluss auf die Reichweite.
• Erhöhe die Senderspannung: Mit 9–12 V am FS1000A steigen Sendeleistung und Reichweite deutlich. Vergiss die gemeinsame Masse nicht.
• Senke die Geschwindigkeit: 1000 statt 2000 bit/s in RadioHead lassen jedes Bit länger dauern, sodass der Empfänger auch schwächere Signale entschlüsseln kann. Stelle auf beiden Seiten dieselbe Geschwindigkeit ein.
• Sichtverbindung und Höhe: Stahlbetonwände, Metallgehäuse und eine Montage nahe am Boden können die Reichweite halbieren; führe die Antennen aus Metallgehäusen heraus und so hoch wie möglich.
• Saubere Versorgung: Motoren, Relais und Schaltnetzteile machen den Empfänger taub. Gib dem Empfänger eine gefilterte Versorgung und halte die Leitungen kurz.
• Besserer Empfänger: Ein Superhet-Empfänger wie der RXB6 statt des XY-MK-5V erreicht mit demselben Sender oft deutlich größere Entfernungen.
• Mehrfach senden: Da es keine Bestätigung gibt, sende wichtige Befehle 3- bis 5-mal und filtere Doppelte beim Empfänger über die Paketnummer heraus.

Denk daran, dass 433 MHz ein geteiltes Band ist: Die Wetterstation der Nachbarn, Autoschlüssel und Funkklingeln senden auf derselben Frequenz. In Europa und der Türkei ist der Bereich 433,05–434,79 MHz für Funkanwendungen mit geringer Reichweite (SRD) anmeldefrei nutzbar, die Sendeleistung ist aber auf 10 mW (ERP) begrenzt, und du darfst den Kanal nicht dauerhaft belegen. Daten in Abständen oder nur bei einer Änderung statt ununterbrochen zu senden, hält die Regeln ein und verlängert die Akkulaufzeit; für einen batteriebetriebenen Sender kannst du den Akkulaufzeit-Rechner nutzen.

433 MHz Funkmodul oder nRF24L01?

Kurz gesagt: Wenn du unidirektional, selten und kleine Datenmengen senden willst (einen Taster, einen Temperaturwert, die Meldung, dass eine Tür geöffnet wurde) oder mit fertigen Steckdosen und Sensoren arbeiten möchtest, ist das 433-MHz-Modul die günstigste und einfachste Lösung. Für ein ferngesteuertes Auto, einen Joystick oder Sensornetze mit vielen Knoten, die schnelle, bidirektionale und bestätigte Kommunikation brauchen, ist der nRF24L01 die bessere Wahl. Brauchst du Kilometer an Reichweite, sieh dir LoRa-Module an; alle Optionen im Vergleich findest du im Artikel Funkmodule für Arduino.

Projektideen mit dem 433 MHz Funkmodul

• Funkklingel: Spiele im Haus eine Melodie, wenn der Taster am Gartentor ein Signal sendet; für den Ton reicht ein Summer.
• Steckdosen per Arduino steuern: Klone die Codes von Funksteckdosen und schalte Lampen nach Uhrzeit oder Helligkeit.
• Funk-Türsensor: Bringe einen Reedkontakt und einen kleinen Arduino mit Sender an der Tür an; öffnet sich die Tür, löst die Empfängerseite Alarm aus.
• Alarmanlage: Baue eine Arduino-Alarmanlage, die fertige 433-MHz-Bewegungsmelder und Türkontakte in einer Zentrale bündelt.
• Gartensensor-Station: Sende Bodenfeuchte oder Temperatur alle paar Minuten mit einem batteriebetriebenen Sender ins Haus.
• 433-MHz-zu-WLAN-Brücke: Steuere mit einem ESP32 alle 433-MHz-Geräte im Haus per Handy und Smart-Home-System.

Häufige Fehler und ihre Lösungen

433-MHz-Funkmodule verleihen deinen Projekten für sehr wenig Geld einen drahtlosen Arm und gehören zu den wenigen Modulen, die mit fertigen funkgesteuerten Geräten in deinem Zuhause sprechen können. Wenn du die Logik der Funksteuerung verstanden hast, lernst du auch andere Wege wie IR-Fernbedienungen und Bluetooth leicht. In der BlueGrays-App findest du Projekte wie die Kommunikation zwischen zwei Arduinos, eine 220-V-Lampe per Fernbedienung schalten, einen Türsensor mit Reedkontakt und eine ESP32-Bewegungsalarmanlage, jeweils mit Schaltplan und Schritt-für-Schritt-Code.