Panduan Modul RF 433MHz Arduino: Pemancar, Penerima, dan Antena

Modul RF 433MHz adalah cara termurah untuk menambahkan koneksi nirkabel ke proyek Arduino: satu set berisi pemancar (FS1000A) dan penerima (XY-MK-5V) harganya sangat murah, terhubung hanya dengan satu kabel data, dan dengan antena kawat 17 cm bisa membawa sinyal sampai puluhan meter. Stopkontak remote, bel pintu nirkabel, remote pintu gulung, sensor pintu dan jendela, serta sensor luar ruangan stasiun cuaca kebanyakan juga memakai frekuensi yang sama. Artinya, dengan modul ini kamu bisa mengirim data antara dua Arduino sekaligus membaca kode remote siap pakai di rumahmu lalu mengirimkannya lagi dari Arduino.

Di panduan ini kamu akan belajar cara kerja modul dengan modulasi ASK (OOK), kenapa antenanya sebaiknya sepanjang 17,3 cm, dan cara menghubungkannya ke Arduino Uno, ESP32, dan Raspberry Pi Pico. Setelah itu kamu akan mengirim teks dan data sensor antara dua Arduino dengan library RadioHead, membaca dan menyalin kode remote stopkontak dengan library RCSwitch, melihat cara menambah jangkauan, dan membandingkan modul ini dengan nRF24L01.

Apa itu modul RF 433MHz dan bagaimana cara kerjanya?

Set ini terdiri dari dua board terpisah. Pemancar FS1000A yang kecil dan persegi (juga dijual dengan nama XY-FST) menyalakan dan mematikan gelombang pembawa 433,92 MHz sesuai sinyal yang masuk ke pin DATA-nya. Penerima XY-MK-5V yang lebih panjang menangkap sinyal itu dari udara lalu mengeluarkannya lagi sebagai 0 dan 1 di pin DATA-nya. Dengan kata lain, modulnya sendiri tidak punya protokol, alamat, atau pemeriksaan error; tugasnya hanya membawa sinyal digital secara nirkabel ke sisi seberang. Mengemas, memverifikasi, dan menguraikan data adalah tugas library di Arduino. Komunikasinya satu arah: pemancar hanya mengirim, penerima hanya mendengarkan.

Dua pin DATA di penerima tersambung satu sama lain di board, jadi tidak masalah mana yang kamu pakai. XY-MK-5V adalah penerima super-regeneratif yang murah tapi kurang selektif: frekuensinya diatur oleh kumparan yang bisa disetel di board, dan penerima ini mudah terganggu oleh interferensi di sekitarnya. Jangan putar sekrup di kumparan itu; kalau setelan pabriknya hilang, penerima tidak bisa lagi mendengar pemancar. Untuk hasil yang lebih stabil, penerima superheterodyne seperti RXB6 lebih sensitif dan juga bisa bekerja di 3,3 V. Set ini juga dijual dalam versi 315 MHz; pemancar dan penerima harus berada di frekuensi yang sama, dan resonator logam di board pemancar biasanya bertuliskan frekuensinya.

Modulasi ASK (OOK): kenapa kamu butuh library?

Pada OOK (On-Off Keying), bentuk paling sederhana dari ASK (Amplitude Shift Keying), gelombang pembawa dinyalakan untuk bit 1 dan dimatikan untuk bit 0. Kedengarannya mudah, tapi penerimanya punya kebiasaan unik: kendali penguatan otomatis (AGC) menaikkan penguatan sampai maksimum ketika tidak ada sinyal, mengira derau di udara sebagai data, dan terus-menerus mengeluarkan pulsa acak di pin DATA. Karena itu, menghubungkan pemancar langsung ke pin TX Arduino dan penerima ke pin RX lalu mencoba berkomunikasi dengan Serial.print biasanya berakhir dengan karakter sampah.

Driver RH_ASK di library RadioHead mengatasi masalah ini dengan cara berikut: sebelum setiap paket, driver mengirim preamble 36 bit dan simbol awal 12 bit supaya penguatan penerima sempat stabil. Lalu setiap byte diubah menjadi dua simbol 6 bit yang seimbang secara DC (encoding 4-ke-6), dan CRC 16 bit ditambahkan di akhir paket. Penerima diam-diam membuang paket yang CRC-nya tidak cocok, jadi hanya data utuh yang lolos. Sementara itu, RCSwitch menguraikan pengodean lebar pulsa yang dipakai chip remote: setiap bit diwakili oleh pulsa yang bertahan HIGH dan LOW selama durasi tertentu.

Panjang antena 433MHz: kenapa 17,3 cm?

Modulnya tidak dilengkapi antena; yang ada hanya pad solder bertanda ANT. Tanpa antena, satu set hanya bekerja pada jarak 1–3 meter. Antena sederhana yang paling efisien adalah kawat lurus sepanjang seperempat panjang gelombang: λ = c / f = 300.000.000 / 433.920.000 ≈ 0,69 m, dan seperempatnya sekitar 17,3 cm. Untuk modul 315 MHz, perhitungan yang sama menghasilkan 23,8 cm. Solder salah satu ujung kabel inti tunggal ke pad ANT, lalu jaga kabelnya tetap lurus dan tegak; solder juga kabel dengan panjang yang sama ke penerima dan arahkan kedua antena ke arah yang sama.

Pengkabelan modul RF 433MHz: Arduino Uno, ESP32, dan Pico

Pemancar tetap bekerja baik dengan sinyal 3,3 V di pin DATA-nya, jadi di ESP32 dan Pico kamu bisa memberinya daya dari 5 V dan menghubungkan DATA langsung ke GPIO. Tegangan pemancar paling besar pengaruhnya terhadap jangkauan: di 3,3 V jangkauannya turun cukup jauh, sedangkan di 9–12 V jangkauannya naik beberapa kali lipat. Memasang kapasitor keramik 100 nF dan kapasitor elektrolit 10 µF tepat di sebelah pin VCC dan GND penerima akan mengurangi derau catu daya dan membuat penerimaan jelas lebih baik.

Mengirim pesan antara dua Arduino dengan RadioHead

1. Buka Library Manager di Arduino IDE, cari RadioHead, lalu instal library karya Mike McCauley. Untuk detailnya, lihat Cara Instal Library Arduino.
2. Hubungkan pemancar ke Arduino pertama: DATA → D12, VCC → 5V, GND → GND.
3. Hubungkan penerima ke Arduino kedua: DATA → D11, VCC → 5V, GND → GND.
4. Solder kabel 17,3 cm ke pad ANT di masing-masing modul.
5. Upload kode pemancar ke board pertama dan kode penerima ke board kedua, lalu buka Serial Monitor di sisi penerima pada 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}

Di kode penerima, penting untuk mengatur ulang variabel len di setiap putaran: recv() menulis ukuran paket yang masuk ke variabel ini, dan pada panggilan berikutnya nilai itu dianggap sebagai ukuran buffer; kalau tidak diatur ulang, pesan yang lebih panjang akan terpotong. Kalau semuanya beres, kamu akan melihat baris “Merhaba 0”, “Merhaba 1” (bahasa Turki untuk “Halo”) sekali per detik di Serial Monitor. Kalau ada angka yang terlewat, berarti sebagian paket hilang di jalan; dalam hal itu, periksa antena dan catu dayanya.

Mengirim data sensor: paket dengan struct

Di proyek sungguhan, mengirim angka lebih efisien daripada mengirim teks. Kamu bisa mengumpulkan hasil bacaanmu dalam sebuah struct dan mengirim byte-nya apa adanya. Pemancar di bawah mengirim nilai LDR atau potensiometer di A0 dan status tombol di D2 lima kali per detik. Penerima menyalakan LED di D13 ketika tombol di sisi jauh ditekan, dan bisa mengetahui paket yang hilang.

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}

Kata kunci __attribute__((packed)) mencegah compiler menambahkan padding di antara field. Ini penting: struct yang sama bisa berukuran 5 byte di Arduino Uno dan 6 byte di ESP32, dan datanya jadi bergeser ketika dua board yang berbeda saling berkomunikasi. Berkat nomor paket, penerima bisa menghitung paket yang hilang di antaranya. Karena modul 433MHz tidak punya konfirmasi penerimaan (acknowledgement), sebaiknya biasakan mengulang perintah penting beberapa kali. Kalau kamu memasang pemancar dan penerima di masing-masing sisi, kamu juga bisa membangun komunikasi dengan konfirmasi dan pengiriman ulang memakai kelas RHReliableDatagram dari RadioHead.

Membaca kode remote siap pakai dengan RCSwitch

Banyak stopkontak remote, bel pintu nirkabel, remote pintu gulung dan pagar taman, serta sensor alarm pintu, jendela, dan PIR memakai chip kode seperti EV1527 atau PT2262. Setiap kali tombol ditekan, chip ini mengirim kode 12–24 bit yang sama berulang-ulang dengan jeda sinkronisasi di antaranya. Library RCSwitch (di Library Manager bernama rc-switch) menguraikan kode-kode ini. Di Uno, hubungkan pin DATA penerima ke pin interrupt, yaitu D2 atau D3, lalu upload kode di bawah:

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}

Buka Serial Monitor dan tekan salah satu tombol remote; kamu akan melihat baris seperti “Kod / code: 5393 Bit: 24 Protokol / protocol: 1 Darbe / pulse: 350 us” (label dalam bahasa Turki dan Inggris). Catat kode, panjang bit, protokol, dan panjang pulsa setiap tombol; keempatnya kamu butuhkan ketika menyalin. Pada remote dengan EV1527, 20 bit pertama dari 24 bit adalah ID remote dan 4 bit terakhir adalah tombol yang ditekan, karena itulah kode tombol dari remote yang sama sangat berdekatan. Pada protokol 1, satu unit berlangsung sekitar 350 µs: bit 0 adalah 1 unit HIGH dan 3 unit LOW, bit 1 adalah 3 unit HIGH dan 1 unit LOW, dan sinkronisasinya 1 unit HIGH dan 31 unit LOW.

Mengirim kode remote dari Arduino

Untuk mengirim kode yang sudah kamu baca, hubungkan pin DATA pemancar ke D10 dan dua tombol di antara D4 serta D5 dan GND. Setiap kali kamu menekan tombol, Arduino mengulang kodenya 10 kali, persis seperti yang dilakukan remote; tombol nyala dan mati stopkontak sekarang ada di Arduino-mu:

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}

Karena setProtocol() mengembalikan panjang pulsa ke nilai default protokol tersebut, selalu panggil setPulseLength() sesudahnya. Kalau stopkontak tidak merespons, pertama masukkan panjang pulsa persis seperti yang kamu baca (misalnya 320 atau 420 µs), lalu naikkan jumlah pengulangan menjadi 15. Stopkontak dengan learning code punya satu jalan pintas lagi: kalau stopkontak kamu masukkan ke mode belajar lalu Arduino mengirim kode 24 bit apa pun, stopkontak akan menyimpan kode itu di memorinya. Jadi kamu bisa membuat kode sendiri tanpa perlu menyalin remote sama sekali.

Penerima 433MHz dengan ESP32: mengendalikan relay dengan remote

ESP32 adalah jembatan yang sangat bagus untuk menghubungkan remote 433MHz ke dunia Wi-Fi. RCSwitch juga berjalan di ESP32, dan karena setiap GPIO ESP32 bisa menerima interrupt, kamu bisa menghubungkan penerima ke pin aman mana pun yang kamu suka. Kode di bawah membaca kode dari penerima yang terhubung ke GPIO 27 (lewat pembagi tegangan); ketika kode remote milikmu datang, kode ini membalik status LED di GPIO 2 atau modul relay. Karena remote mengirim kodenya berkali-kali untuk satu kali tekan, program tidak akan membalik status lagi sampai kode itu berhenti datang selama 600 ms:

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}

Banyak hal bisa kamu bangun di atas dasar ini: teruskan kode yang masuk ke Home Assistant lewat MQTT untuk menambahkan sensor pintu 433MHz yang murah ke rumah pintarmu, atau kendalikan stopkontak dari ponsel dengan pemancar di GPIO 26. RadioHead juga mendukung ESP32; bedanya hanya kamu menuliskan pin secara eksplisit di konstruktor: RH_ASK rf(2000, 27, 26, 25); (penerima 27, pemancar 26, dan 25 sebagai pin bebas untuk PTT). Kalau kamu baru mengenal ESP32, lihat Apa Itu ESP32?.

Pemancar 433MHz dengan Raspberry Pi Pico dan MicroPython

MicroPython tidak punya padanan siap pakai untuk RCSwitch, tapi timing protokol 1 begitu sederhana sehingga kamu bisa menulisnya sendiri dalam beberapa baris. Hubungkan VCC FS1000A ke pin VBUS (5 V) Pico, DATA ke GP15, dan sebuah tombol di antara GP16 dan GND. Ketika tombol ditekan, Pico mengirim 24 bit mulai dari bit paling signifikan, sama seperti RCSwitch, menambahkan pulsa sinkronisasi di akhir, dan mengulang seluruh paket 10 kali. Kalau kamu belum tahu cara menginstal MicroPython di Pico, mulailah dari Apa Itu 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)

Untuk prosesor 125 MHz di Pico, pulsa 350 µs adalah kecepatan yang nyaman; delay kecil di Python masih jauh di bawah toleransi timing 60% pada penerima RCSwitch. Kamu bisa langsung menguji kodenya dengan meletakkan Arduino yang menjalankan kode pembaca RCSwitch di dekatnya: angka yang kamu kirim seharusnya muncul di Serial Monitor. Di sisi penerima, kamu harus mengukur dan menguraikan panjang pulsa dengan timestamp; untuk pekerjaan itu, Arduino atau ESP32 dengan RCSwitch lebih praktis.

Jangkauan dan interferensi: membawa sinyal lebih jauh

• Jangan lupa antenanya: solder kawat lurus 17,3 cm di kedua sisi; inilah yang paling besar pengaruhnya terhadap jangkauan.
• Naikkan tegangan pemancar: memberi daya FS1000A dari 9–12 V jelas menaikkan daya keluaran dan jangkauannya. Jangan lupa ground bersama.
• Turunkan kecepatan: memakai 1000 bps alih-alih 2000 di RadioHead membuat setiap bit berlangsung lebih lama sehingga penerima bisa menguraikan sinyal yang lebih lemah. Atur kecepatan yang sama di kedua sisi.
• Garis pandang dan ketinggian: dinding beton bertulang, kotak logam, dan pemasangan yang dekat dengan tanah bisa memangkas jangkauan sampai separuhnya; keluarkan antena dari casing logam dan pasang setinggi mungkin.
• Bersihkan catu daya: motor, relay, dan adaptor switching membuat penerima “tuli”. Beri penerima catu daya yang tersaring dan buat kabelnya pendek.
• Pakai penerima yang lebih baik: penerima superheterodyne seperti RXB6 sebagai pengganti XY-MK-5V sering menjangkau jauh lebih jauh dengan pemancar yang sama.
• Kirim ulang: karena tidak ada konfirmasi penerimaan, kirim perintah penting 3–5 kali dan saring duplikatnya di penerima dengan nomor paket.

Ingat bahwa 433 MHz adalah pita bersama: stasiun cuaca, kunci mobil, dan bel pintu tetanggamu semuanya memancar di frekuensi yang sama. Di Eropa dan Turki, rentang 433,05–434,79 MHz terbuka untuk pemakaian tanpa izin oleh perangkat jarak pendek, tetapi daya pancarnya dibatasi 10 mW (ERP) dan kamu tidak boleh membuat kanal terus-menerus sibuk; aturannya berbeda di tiap negara, dan di AS remote lebih sering memakai 315 MHz. Mengirim data berselang atau hanya ketika ada perubahan, bukan terus-menerus, membuatmu tetap sesuai aturan sekaligus memperpanjang umur baterai; untuk pemancar bertenaga baterai, kamu bisa memakai kalkulator umur baterai.

Modul RF 433MHz atau nRF24L01?

Singkatnya, kalau kamu perlu mengirim data kecil satu arah yang jarang (tombol, nilai suhu, kabar bahwa pintu terbuka) atau bekerja dengan stopkontak dan sensor siap pakai, modul 433MHz adalah solusi yang paling murah dan paling sederhana. Untuk mobil RC, joystick, atau jaringan sensor multi-node yang butuh komunikasi cepat, dua arah, dan berkonfirmasi, nRF24L01 adalah pilihan yang lebih baik. Kalau kamu butuh jangkauan berkilo-kilometer, lihat modul LoRa; untuk melihat semua pilihan berdampingan, baca modul komunikasi nirkabel Arduino.

Ide proyek modul RF 433MHz

• Bel pintu nirkabel: putar melodi di dalam rumah ketika tombol di pagar taman mengirim sinyal; untuk suaranya, buzzer sudah cukup.
• Mengendalikan stopkontak dari Arduino: salin kode stopkontak remote, lalu nyalakan dan matikan lampu berdasarkan waktu atau tingkat cahaya.
• Sensor pintu nirkabel: pasang reed switch dan Arduino kecil dengan pemancar di pintu; ketika pintu terbuka, sisi penerima membunyikan alarm.
• Sistem alarm rumah: bangun sistem alarm Arduino yang mengumpulkan sensor PIR dan sensor pintu 433MHz siap pakai ke satu unit pusat.
• Stasiun sensor taman: kirim data kelembapan tanah atau suhu ke dalam rumah setiap beberapa menit dengan pemancar bertenaga baterai.
• Jembatan 433MHz ke Wi-Fi: kendalikan setiap perangkat 433MHz di rumahmu dari ponsel dan sistem rumah pintar dengan ESP32.

Kesalahan umum dan cara mengatasinya

Modul RF 433MHz memberi proyekmu “lengan” nirkabel dengan biaya sangat kecil, dan modul ini termasuk sedikit modul yang bisa berbicara dengan perangkat remote siap pakai di rumahmu. Begitu kamu memahami logika kendali nirkabel, kamu bisa dengan mudah mempelajari cara lain seperti remote IR dan Bluetooth. Di aplikasi BlueGrays kamu akan menemukan proyek seperti komunikasi antara dua Arduino, menyalakan bohlam 220 V dengan remote, sensor pintu dengan reed switch, dan alarm gerak ESP32, lengkap dengan skema rangkaian dan kode langkah demi langkah.