433 MHz RF Modül Arduino: Verici, Alıcı, Anten ve Kumanda Kodu

433 MHz RF modül, Arduino projelerine kablosuz bağlantı eklemenin en ucuz yoludur: bir verici (FS1000A) ve bir alıcı (XY-MK-5V) modülünden oluşan set çok ucuza bulunur, tek bir veri kablosuyla bağlanır ve 17 cm'lik bir tel antenle onlarca metre uzağa sinyal taşır. Kumandalı prizler, kablosuz kapı zilleri, kepenk kumandaları, kapı-pencere sensörleri ve hava istasyonlarının dış sensörleri de çoğunlukla aynı frekansı kullanır. Bu yüzden bu modüllerle hem iki Arduino arasında veri gönderebilir hem de evindeki hazır kumandaların kodlarını okuyup Arduino'dan tekrar gönderebilirsin.

Bu rehberde modüllerin ASK (OOK) modülasyonuyla nasıl çalıştığını, antenin neden 17,3 cm olması gerektiğini ve Arduino Uno, ESP32 ile Raspberry Pi Pico bağlantılarını öğreneceksin. Ardından RadioHead kütüphanesiyle iki Arduino arasında metin ve sensör verisi gönderecek, RCSwitch kütüphanesiyle bir prizin kumanda kodunu okuyup kopyalayacak, menzili artırmanın yollarını görecek ve modülü nRF24L01 ile karşılaştıracaksın.

433 MHz RF modül nedir, nasıl çalışır?

Set iki ayrı karttan oluşur. Küçük, kare FS1000A verici (XY-FST adıyla da satılır), DATA pinine gelen sinyale göre 433,92 MHz'lik bir taşıyıcı dalgayı açıp kapatır. Daha uzun olan XY-MK-5V alıcı ise havadaki bu sinyali yakalar ve DATA pininden yeniden 0 ve 1 olarak verir. Yani modüllerin kendisinde hiçbir protokol, adres ya da hata denetimi yoktur; tek görevleri bir dijital sinyali kablosuz olarak karşı tarafa taşımaktır. Veriyi paketlemek, doğrulamak ve çözmek Arduino'daki kütüphanenin işidir. Haberleşme tek yönlüdür: verici yalnızca gönderir, alıcı yalnızca dinler.

Alıcıdaki iki DATA pini kart üzerinde birbirine bağlıdır; hangisini kullandığın fark etmez. XY-MK-5V ucuz ama seçiciliği düşük bir süperrejeneratif alıcıdır: frekansı kart üzerindeki ayarlı bir bobinle belirlenir ve yakındaki parazitten kolay etkilenir. Bu bobinin vidasını çevirme; fabrika ayarı bozulursa alıcı vericiyi duymaz hâle gelir. Daha kararlı sonuç istersen RXB6 gibi süperheterodin alıcılar daha hassastır ve 3,3 V ile de çalışır. Setin 315 MHz sürümü de satılır; verici ile alıcının frekansı aynı olmalıdır ve verici kartındaki metal rezonatörün üzerinde genellikle frekans yazar.

ASK (OOK) modülasyonu: neden bir kütüphaneye ihtiyacın var?

ASK (Amplitude Shift Keying, genlik kaydırmalı anahtarlama) yönteminin en basit hâli olan OOK'ta (On-Off Keying) 1 biti için taşıyıcı açılır, 0 biti için kapatılır. Kulağa kolay gelir ama alıcının bir huyu vardır: içindeki otomatik kazanç kontrolü (AGC), hiç sinyal yokken kazancı sonuna kadar açar ve havadaki gürültüyü veri sanarak DATA pininden sürekli rastgele darbeler verir. Bu yüzden vericiyi doğrudan Arduino'nun TX pinine, alıcıyı da RX pinine bağlayıp Serial.print ile haberleşmeye çalışmak çoğu zaman anlamsız karakterlerle sonuçlanır.

RadioHead kütüphanesinin RH_ASK sürücüsü bu sorunu şöyle çözer: her paketten önce alıcının kazancını oturtmak için 36 bitlik bir ön ek ve 12 bitlik bir başlangıç işareti gönderir. Ardından her baytı DC dengeli iki adet 6 bitlik sembole çevirir (4'ten 6'ya kodlama) ve paketin sonuna 16 bitlik bir CRC ekler. Alıcı, CRC'si tutmayan paketleri sessizce atar; böylece eline yalnızca sağlam veri geçer. RCSwitch ise kumanda yongalarının kullandığı darbe genişliği kodlamasını çözer: her bit, belirli sürelerde HIGH ve LOW kalan darbelerle ifade edilir.

433 MHz anten boyu: neden 17,3 cm?

Modüllerde hazır anten yoktur; yalnızca ANT yazan bir lehim noktası bulunur. Antensiz bir set ancak 1–3 metre çalışır. En verimli basit anten, dalga boyunun dörtte biri uzunluğundaki düz bir teldir: λ = c / f = 300.000.000 / 433.920.000 ≈ 0,69 m, dörtte biri ise yaklaşık 17,3 cm eder. 315 MHz'lik modüllerde aynı hesap 23,8 cm verir. Tek damarlı bir telin ucunu ANT noktasına lehimle, teli düz ve dikey tut; alıcıya da aynı uzunlukta bir tel lehimle ve iki anteni aynı yönde konumlandır.

433 MHz RF modül bağlantısı: Arduino Uno, ESP32 ve Pico

Verici, DATA pininde 3,3 V'luk bir sinyalle de sorunsuz çalışır; bu yüzden ESP32 ve Pico'da vericiyi 5 V'tan besleyip DATA'yı doğrudan GPIO'ya bağlayabilirsin. Menzili en çok verici gerilimi belirler: 3,3 V'ta menzil belirgin biçimde kısalır, 9–12 V'ta ise birkaç kat artar. Alıcının VCC ve GND pinlerinin hemen yanına 100 nF'lık bir seramik ve 10 µF'lık bir elektrolitik kondansatör koymak, beslemeden gelen gürültüyü azaltır ve alımı gözle görülür biçimde iyileştirir.

RadioHead ile iki Arduino arasında mesaj göndermek

1. Arduino IDE'de Kütüphane Yöneticisi'ni aç, RadioHead ara ve Mike McCauley'in kütüphanesini kur. Ayrıntılar için Arduino'ya kütüphane ekleme yazısına bakabilirsin.
2. Birinci Arduino'ya vericiyi bağla: DATA → D12, VCC → 5V, GND → GND.
3. İkinci Arduino'ya alıcıyı bağla: DATA → D11, VCC → 5V, GND → GND.
4. İki modülün ANT noktasına da 17,3 cm'lik birer tel lehimle.
5. Verici kodunu birinci, alıcı kodunu ikinci karta yükle ve alıcı tarafta Seri Monitör'ü 9600 baud hızında aç.

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}

Alıcı kodunda len değişkenini her turda yeniden ayarlamak önemlidir: recv() bu değişkene gelen paketin boyunu yazar ve bir sonraki çağrıda bu değer arabelleğin büyüklüğü sanılır; ayarlamazsan uzun mesajlar kırpılır. Her şey yolundaysa Seri Monitör'de saniyede bir "Merhaba 0", "Merhaba 1" satırlarını görürsün. Sayılar arasında atlama varsa bazı paketler yolda kaybolmuştur; bu durumda anteni ve beslemeyi kontrol et.

Sensör verisi göndermek: struct ile paket

Gerçek projelerde metin yerine sayı göndermek daha verimlidir. Ölçümleri bir struct içinde toplayıp baytlarını olduğu gibi yollayabilirsin. Aşağıdaki verici, A0'a bağlı bir LDR ya da potansiyometrenin değerini ve D2'deki butonun durumunu saniyede beş kez gönderir. Alıcı, uzaktaki butona basıldığında D13'teki LED'i yakar ve kaybolan paketleri fark eder.

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}

__attribute__((packed)) ifadesi derleyicinin alanlar arasına boşluk eklemesini önler. Bu önemlidir: aynı struct Arduino Uno'da 5, ESP32'de ise 6 bayt yer kaplayabilir ve iki farklı kart haberleşirken veriler kayar. Paket numarası sayesinde alıcı aradaki kayıpları sayabilir. 433 MHz modüllerde alındı onayı olmadığı için önemli komutları birkaç kez tekrarlamak iyi bir alışkanlıktır. İki tarafa da hem verici hem alıcı takarsan RadioHead'in RHReliableDatagram sınıfıyla onaylı ve yeniden gönderimli haberleşme de kurabilirsin.

RCSwitch ile hazır kumanda kodlarını okumak

Kumandalı prizler, kablosuz kapı zilleri, kepenk ve bahçe kapısı kumandalarının birçoğu ile kapı-pencere ve PIR alarm sensörleri EV1527 ya da PT2262 gibi kod yongaları kullanır. Bu yongalar her tuş basışında aynı 12–24 bitlik kodu, araya senkron boşlukları koyarak art arda gönderir. RCSwitch kütüphanesi (Kütüphane Yöneticisi'nde rc-switch adıyla) bu kodları çözer. Alıcının DATA pinini Uno'da bir kesme pinine, yani D2 ya da D3'e bağla ve aşağıdaki kodu yükle:

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}

Seri Monitör'ü açıp kumandanın bir tuşuna bas; ekranda "Kod / code: 5393 Bit: 24 Protokol / protocol: 1 Darbe / pulse: 350 us" gibi bir satır görürsün. Her tuşun kodunu, bit sayısını, protokolünü ve darbe süresini not al; kopyalarken dördüne de ihtiyacın olacak. EV1527 kullanan kumandalarda 24 bitin ilk 20'si kumandanın kimliği, son 4'ü basılan tuştur; bu yüzden aynı kumandanın tuş kodları birbirine çok yakın çıkar. Protokol 1'de bir birim yaklaşık 350 µs sürer: 0 biti 1 birim HIGH ve 3 birim LOW, 1 biti 3 birim HIGH ve 1 birim LOW, senkron ise 1 birim HIGH ve 31 birim LOW'dur.

Kumanda kodunu Arduino'dan göndermek

Okuduğun kodu göndermek için vericinin DATA pinini D10'a, iki butonu da D4 ve D5 ile GND arasına bağla. Butona her bastığında Arduino, kumandanın yaptığı gibi kodu 10 kez tekrarlar; prizin aç ve kapat tuşları artık Arduino'dadır:

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}

setProtocol() darbe süresini o protokolün varsayılan değerine döndürdüğü için setPulseLength() her zaman ondan sonra çağrılmalıdır. Priz tepki vermiyorsa önce okuduğun darbe süresini (ör. 320 ya da 420 µs) birebir yaz, sonra tekrar sayısını 15'e çıkar. Öğrenen kodlu prizlerde bir kolaylık daha var: prizi öğrenme moduna alıp Arduino'dan herhangi bir 24 bitlik kod gönderirsen priz bu kodu hafızasına kaydeder. Yani hiçbir kumandayı kopyalamadan kendi kodlarını üretebilirsin.

ESP32 ile 433 MHz alıcı: kumandayla röle kontrolü

ESP32, 433 MHz kumandaları Wi-Fi dünyasına bağlamak için harika bir köprüdür. RCSwitch ESP32'de de çalışır ve ESP32'nin bütün GPIO'ları kesme alabildiği için alıcıyı istediğin güvenli pine bağlayabilirsin. Aşağıdaki kod GPIO 27'ye (gerilim bölücüyle) bağlı alıcıdan gelen kodu okur; kendi kumandanın kodu geldiğinde GPIO 2'deki LED'i ya da bir röle modülünü açıp kapatır. Kumanda tek basışta kodu defalarca yolladığı için program, kod 600 ms boyunca kesilmeden ikinci bir değişiklik yapmaz:

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}

Bu temelin üzerine çok şey kurabilirsin: gelen kodu MQTT ile Home Assistant'a göndererek ucuz 433 MHz kapı sensörlerini akıllı ev sistemine katabilir ya da GPIO 26'ya bağlayacağın bir vericiyle prizleri telefondan yönetebilirsin. RadioHead de ESP32'yi destekler; tek fark, kurucuda pinleri açıkça yazmaktır: RH_ASK rf(2000, 27, 26, 25); (alıcı 27, verici 26, PTT için boş bir pin olarak 25). ESP32'yi yeni tanıyorsan ESP32 Nedir? yazısına göz at.

Raspberry Pi Pico ve MicroPython ile 433 MHz verici

MicroPython'da RCSwitch'in hazır bir karşılığı yok, ama protokol 1'in zamanlaması o kadar basit ki birkaç satırla kendin yazabilirsin. FS1000A'nın VCC'sini Pico'nun VBUS (5 V) pinine, DATA'yı GP15'e, bir butonu da GP16 ile GND arasına bağla. Butona bastığında Pico, RCSwitch'in yaptığı gibi 24 biti en anlamlı bitten başlayarak gönderir, sonuna senkron darbesini ekler ve tüm paketi 10 kez tekrarlar. Pico'ya MicroPython kurmayı bilmiyorsan Raspberry Pi Pico Nedir? yazısından başlayabilirsin.

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)

Pico'nun 125 MHz'lik işlemcisi için 350 µs'lik darbeler rahat bir hızdır; Python'un küçük gecikmeleri RCSwitch alıcılarının %60'lık zaman toleransının çok altında kalır. Kodu, RCSwitch okuyucu kodunu yüklediğin bir Arduino'yu yanına koyarak hemen test edebilirsin: Seri Monitör'de gönderdiğin sayı görünmelidir. Alım tarafında ise darbe sürelerini zaman damgalarıyla ölçüp çözmen gerekir; bu iş için RCSwitch'in çalıştığı Arduino ya da ESP32 daha pratiktir.

Menzil ve parazit: sinyali daha uzağa taşımak

• Anteni unutma: İki tarafa da 17,3 cm'lik düz tel lehimle; menzil üzerindeki en büyük etki budur.
• Verici gerilimini yükselt: FS1000A'yı 9–12 V ile beslemek çıkış gücünü ve menzili belirgin şekilde artırır. Ortak GND'yi unutma.
• Hızı düşür: RadioHead'de 2000 yerine 1000 bps kullanmak her bitin daha uzun sürmesini ve alıcının daha zayıf sinyalleri çözebilmesini sağlar. İki tarafa da aynı hızı yaz.
• Görüş hattı ve yükseklik: Betonarme duvarlar, metal kutular ve yere yakın montaj menzili yarıya indirebilir; antenleri metal kutunun dışına ve olabildiğince yükseğe taşı.
• Beslemeyi temizle: Motorlar, röleler ve anahtarlamalı adaptörler alıcıyı sağırlaştırır. Alıcıya filtreli bir besleme ver ve kabloları kısa tut.
• Daha iyi alıcı kullan: XY-MK-5V yerine RXB6 gibi süperheterodin bir alıcı, aynı vericiyle çoğu zaman belirgin şekilde daha uzağa ulaşır.
• Tekrar gönder: Onay mekanizması olmadığı için önemli komutları 3–5 kez gönder, alıcıda paket numarasıyla tekrarları ayıkla.

Unutma ki 433 MHz paylaşılan bir banttır: komşunun hava istasyonu, araba anahtarları ve kapı zilleri aynı frekansta yayın yapar. Türkiye ve Avrupa'da 433,05–434,79 MHz aralığı kısa mesafe cihazlarının lisanssız kullanımına açıktır, ancak yayın gücü 10 mW (ERP) ile sınırlıdır ve kanalı sürekli meşgul etmemen gerekir. Verileri sürekli değil, belirli aralıklarla ya da yalnızca bir şey değiştiğinde göndermek hem kurallara uygundur hem de pil ömrünü uzatır; pille çalışan bir verici için pil ömrü hesaplayıcısını kullanabilirsin.

433 MHz RF modül mü, nRF24L01 mi?

Kısacası tek yönlü, seyrek ve küçük veriler (bir buton, bir sıcaklık değeri, kapının açıldığı bilgisi) ya da hazır priz ve sensörlerle uyum gerekiyorsa 433 MHz modül en ucuz ve en basit çözümdür. Çift yönlü, hızlı ve onaylı haberleşme isteyen kumandalı araba, joystick ya da çok düğümlü sensör ağları için nRF24L01 daha doğru seçimdir. Kilometrelerce menzil gerekiyorsa LoRa modüllerine bak; bütün seçenekleri yan yana görmek için Arduino kablosuz haberleşme modülleri yazısını oku.

433 MHz RF modül ile proje fikirleri

• Kablosuz kapı zili: Bahçe kapısındaki butondan gelen sinyalle evin içinde melodi çal; ses için bir buzzer yeterli.
• Prizleri Arduino'dan yönetmek: Kumandalı prizlerin kodlarını kopyalayıp lambaları saate ya da ışık seviyesine göre aç kapat.
• Kablosuz kapı sensörü: Kapıya bir reed röle ve vericili küçük bir Arduino koy; kapı açıldığında alıcı taraf alarm versin.
• Ev alarm sistemi: Hazır 433 MHz PIR ve kapı sensörlerini tek bir merkeze toplayan bir Arduino alarm sistemi kur.
• Bahçe sensör istasyonu: Toprak nemini ya da sıcaklığı, pille çalışan bir vericiyle birkaç dakikada bir eve gönder.
• 433 MHz ve Wi-Fi köprüsü: ESP32 ile evdeki bütün 433 MHz cihazlarını telefondan ve akıllı ev sisteminden yönet.

Sık yapılan hatalar ve çözümleri

433 MHz RF modüller birkaç liralık maliyetle projelerine kablosuz bir kol kazandırır ve evdeki hazır kumandalı cihazlarla konuşabilen nadir modüllerdendir. Kablosuz kontrolün mantığını kavradıktan sonra IR kumanda ve Bluetooth gibi diğer yöntemleri de kolayca öğrenebilirsin. BlueGrays uygulamasında iki Arduino arasında haberleşme, uzaktan kumandayla 220 V ampul yakma, reed röleyle kapı sensörü ve ESP32 hareket alarmı gibi projeleri devre şemaları ve adım adım kodlarıyla bulabilirsin.