Yağmur Sensörü Arduino: Bağlantı, Kod ve Otomatik Pencere

Yağmur sensörü, Arduino ile yağmur damlalarını algılayıp "yağmur başladı" bilgisini birkaç milisaniyede veren, en ucuz ve en eğlenceli sensörlerden biridir. Üzerine su düşen bir algılama panosu ile LM393 karşılaştırıcılı küçük bir karttan oluşur ve Arduino'ya yalnızca dört kabloyla bağlanır. Çamaşırları ıslanmadan toplamanı hatırlatan bir alarm, yağmur başlayınca kendiliğinden kapanan bir pencere ya da tente, yağmurlu günlerde sulamayı atlayan bir bahçe sistemi ve küçük bir hava istasyonu, hep bu modülle başlar.

Bu rehberde piyasada FC-37, YL-83 ve MH-RD adlarıyla satılan yağmur sensörü modülünün içinde ne olduğunu, analog (AO) ve dijital (DO) çıkışların farkını, potansiyometreyle eşik ayarını ve en çok gözden kaçan konuyu, yani panonun paslanmasını nasıl önleyeceğini öğreneceksin. Ardından Arduino ile şiddet seviyeli bir yağmur alarmı, servo motorla otomatik pencere kapatma, ESP32 ile telefona bildirim ve Raspberry Pi Pico için MicroPython örneğini adım adım kuracağız.

Yağmur sensörü nedir, nasıl çalışır?

Algılama panosunun üzerinde birbirine değmeyen, tarak dişleri gibi iç içe geçmiş iki iletken iz vardır. Pano kuruyken bu izler arasındaki direnç megaohmlar mertebesindedir; yani devre neredeyse açıktır. Bir yağmur damlası iki izin arasına düştüğünde su, izleri birbirine bağlayan bir köprü kurar ve direnç düşer. Ne kadar çok damla düşer ve panonun ne kadar büyük bir kısmı ıslanırsa direnç o kadar azalır. Kontrol kartında pano, çoğu modelde 10 kΩ'luk bir dirençle birlikte bir gerilim bölücü oluşturur: kuru panoda AO pinindeki gerilim beslemeye (VCC) yakındır, pano ıslandıkça bu gerilim düşer. Farklı direnç değerlerinde çıkışın nasıl değiştiğini gerilim bölücü hesaplayıcısıyla kendin deneyebilirsin.

Kartın üzerindeki LM393, iki gerilimi kıyaslayan bir karşılaştırıcı entegredir. Bir girişine panodan gelen gerilim, diğerine potansiyometreyle ayarladığın referans gerilim bağlanır. Pano geriliminin referansın altına düştüğü anda, yani yeterince su algılandığında, DO çıkışı LOW olur ve karttaki DO LED'i yanar. LM393'ün çıkışı açık kolektörlüdür; kartta bulunan bir pull-up direnç sayesinde DO, yağmur yokken HIGH seviyesinde durur. Karttaki diğer LED (PWR) ise yalnızca modülün enerji aldığını gösterir.

FC-37, YL-83 ve MH-RD: aralarında fark var mı?

Kısaca hayır. FC-37, YL-83 ve MH-RD, farklı üreticilerin aynı devreye verdiği adlardır; hepsi bir algılama panosu ile LM393'lü bir kontrol kartından oluşur ve aynı kodla çalışır. Farklar genellikle panonun boyutunda, iz desenindeki küçük değişikliklerde ve kaplama kalitesindedir. Kontrol kartı, toprak nem sensöründe kullanılan kartla neredeyse aynıdır; bu yüzden iki modülün kartları birbirinin yerine kullanılabilir. Pano ile kart arasındaki iki pinin artısı ya da eksisi yoktur, kabloyu hangi yönde taktığın fark etmez. Pano zamanla aşındığında yalnızca panoyu değiştirmen yeterlidir.

Analog (AO) ve dijital (DO) çıkış farkı

Hangi çıkışı kullanacağın projene bağlıdır. DO yalnızca "yağıyor" ya da "yağmıyor" der; eşiği karttaki potansiyometreyle belirlersin ve Arduino'da tek bir digitalRead() yeterlidir. AO ise panonun ne kadar ıslak olduğunu 0–1023 arası bir sayıyla verir; böylece çiselemeyi sağanaktan ayırabilir, eşiği kodda değiştirebilir ve yağmurun başlayıp bittiğine art arda gelen ölçümlere bakarak karar verebilirsin. İki çıkışı aynı anda da kullanabilirsin.

Yağmur sensörü bağlantısı: Arduino Uno, ESP32 ve Pico

Tabloda VCC'nin 5V yerine bir dijital pine bağlandığını fark etmişsindir. Modül 5 V'ta yalnızca 8 mA civarında akım çektiği için bir Arduino pini onu rahatça besler (pin başına önerilen sınır 20 mA'dir). Böylece modülü yalnızca ölçüm yaptığın birkaç milisaniye boyunca açar, geri kalan zamanda kapalı tutarsın. Bunun neden bu kadar önemli olduğunu korozyon bölümünde ayrıntılı olarak göreceğiz. Pico'nun pinleri varsayılan olarak 4 mA'lik çıkış gücüne ayarlıdır; modül 3,3 V'ta birkaç mA çektiği için bu çoğu zaman yeterlidir, ama okumalar kararsızsa modülü 3V3(OUT) pininden besleyebilirsin.

Hassasiyet ayarı: potansiyometre ile eşik belirleme

1. Panoyu silip kurula ve modülü besle; PWR LED'i yanmalı, DO LED'i sönük olmalı.
2. DO LED'i yanana kadar potansiyometreyi küçük bir tornavidayla yavaşça çevir. Kuru panoda LED zaten yanıyorsa ters yöne çevir.
3. LED'in tam söndüğü noktaya geri dön. Bu, kuru panoda DO'nun HIGH kaldığı en hassas ayardır.
4. Bir miktar daha aynı yönde çevirerek güvenlik payı bırak; aksi halde nemli hava ya da çiy bile alarm verdirebilir.
5. Panoya parmağınla iki üç damla su damlat. DO LED'i yanmalı; yanmıyorsa hassasiyeti biraz artır.
6. Panoyu kurula ve LED'in ne kadar sürede söndüğünü gözle; bu süre, sisteminin "yağmur bitti" demesi için ne kadar beklemesi gerektiği hakkında fikir verir.

Adım adım: Arduino ile ilk okuma

1. Modülün VCC'sini D7'ye, GND'sini GND'ye, AO'yu A0'a ve DO'yu D2'ye bağla. Panoyu iki telli kabloyla karta tak.
2. Aşağıdaki kodu Arduino IDE'de aç, kart olarak Arduino Uno'yu seçip yükle.
3. Seri Monitör'ü 9600 baud hızında aç ve kuru panoda okunan AO değerini not et.
4. Panoya önce birkaç damla, sonra daha fazla su damlat ve her durumda AO değerini yaz.
5. Panoyu tamamen ıslattığında okunan değeri de kaydet; bu değerler sonraki kodlarda kullanacağın DRY ve WET sabitleri olacak.

1// Yağmur sensörü: AO ve DO okuma / Rain sensor: reading AO and DO
2const int SENSOR_POWER = 7;   // modülün VCC'si bu pinden beslenir / module VCC is fed from this pin
3const int RAIN_AO = A0;       // analog çıkış / analog output
4const int RAIN_DO = 2;        // dijital çıkış / digital output
5
6void setup() {
7  Serial.begin(9600);
8  pinMode(SENSOR_POWER, OUTPUT);
9  digitalWrite(SENSOR_POWER, LOW);  // başlangıçta kapalı / off at start-up
10  pinMode(RAIN_DO, INPUT);
11}
12
13void loop() {
14  digitalWrite(SENSOR_POWER, HIGH);             // modülü aç / power the module
15  delay(50);                                    // değerin oturmasını bekle / let the reading settle
16  int analogValue = analogRead(RAIN_AO);        // 0-1023: kuruyken yüksek / high when dry
17  bool raining = digitalRead(RAIN_DO) == LOW;   // yağmurda DO = LOW / DO goes LOW in rain
18  digitalWrite(SENSOR_POWER, LOW);              // modülü kapat / power it off
19
20  Serial.print(F("AO: "));
21  Serial.print(analogValue);
22  Serial.print(F("  DO: "));
23  Serial.println(raining ? F("YAGMUR / RAIN") : F("KURU / DRY"));
24  delay(2000);                                  // 2 sn'de bir ölç / measure every 2 s
25}

Kod her ölçümden önce D7'yi HIGH yaparak modülü açar, kart üzerindeki kondansatörlerin dolması ve değerin oturması için 50 ms bekler, AO ile DO'yu okur ve modülü hemen kapatır. Böylece modül 2 saniyelik döngünün yalnızca 50 ms'sinde, yani zamanın yüzde 2,5'inde enerjili kalır. DO yağmurda LOW olduğu için koşulu digitalRead(RAIN_DO) == LOW şeklinde yazdık. Seri Monitör'e yazdırılan metinlerde Türkçe karakter kullanmamamızın sebebi ise bazı terminallerin bu karakterleri bozuk göstermesidir.

Bu sayılar yalnızca fikir vermesi içindir; panonun boyutu, kaplamanın durumu, suyun saflığı ve panodaki toz, değerleri belirgin biçimde değiştirir. Aynı modülün değerleri bile panoyu birkaç ay dışarıda kullandıktan sonra kayar. Bu yüzden sonraki kodlarda ham değeri doğrudan kullanmak yerine kendi ölçtüğün kuru (DRY) ve ıslak (WET) değerleriyle 0–100 arası bir ıslaklık yüzdesine çeviriyoruz; böylece eşiklere dokunmadan yalnızca bu iki sabiti güncellemen yeterli olur.

Arduino ile yağmur alarmı: şiddet seviyeleri ve buzzer

Şimdi ölçümü işe yarar bir alarma çevirelim. Kod AO'dan art arda 8 ölçüm alıp ortalamasını hesaplar, bu değeri map() ile ıslaklık yüzdesine çevirir ve dört seviyeden birine yerleştirir: kuru, çiseleme, yağmur ve sağanak. Yağmur şiddetlendikçe aktif buzzer seviye sayısı kadar öter: çiselemede bir, yağmurda iki, sağanakta üç kez. Buzzer'ın artı ucunu D8'e, eksi ucunu GND'ye bağla; aktif ve pasif buzzer farkını Buzzer Nedir? yazısında bulabilirsin.

1// Yağmur şiddeti seviyeleri ve sesli alarm / Rain intensity levels and audible alarm
2const int SENSOR_POWER = 7;     // modülün VCC'si / module VCC
3const int RAIN_AO = A0;         // analog çıkış / analog output
4const int BUZZER = 8;           // aktif buzzer / active buzzer
5const int DRY = 1015;           // kuru panel değeri / dry pad reading (kendin ölç / measure yours)
6const int WET = 350;            // tamamen ıslak panel / fully wet pad (kendin ölç / measure yours)
7
8const char* const LEVEL_NAMES[] = {"Kuru / Dry", "Ciseleme / Drizzle", "Yagmur / Rain", "Saganak / Downpour"};
9int lastLevel = 0;
10
11int readWetness() {
12  digitalWrite(SENSOR_POWER, HIGH);
13  delay(50);
14  long sum = 0;
15  for (int i = 0; i < 8; i++) sum += analogRead(RAIN_AO);  // 8 ölçümün ortalaması / average of 8 readings
16  digitalWrite(SENSOR_POWER, LOW);
17  return constrain(map(sum / 8, DRY, WET, 0, 100), 0, 100);  // % ıslaklık / % wetness
18}
19
20void beep(int count) {
21  for (int i = 0; i < count; i++) {
22    digitalWrite(BUZZER, HIGH);
23    delay(150);
24    digitalWrite(BUZZER, LOW);
25    delay(150);
26  }
27}
28
29void setup() {
30  Serial.begin(9600);
31  pinMode(SENSOR_POWER, OUTPUT);
32  pinMode(BUZZER, OUTPUT);
33}
34
35void loop() {
36  int wet = readWetness();
37  int level;
38  if (wet < 10) level = 0;        // kuru / dry
39  else if (wet < 40) level = 1;   // çiseleme / drizzle
40  else if (wet < 75) level = 2;   // yağmur / rain
41  else level = 3;                 // sağanak / downpour
42
43  Serial.print(F("Islaklik / Wetness: %"));
44  Serial.print(wet);
45  Serial.print(F("  "));
46  Serial.println(LEVEL_NAMES[level]);
47
48  if (level > lastLevel) beep(level);  // şiddet artınca seviye kadar bip / beep once per level when it gets heavier
49  lastLevel = level;
50  delay(3000);                         // 3 sn'de bir ölç / measure every 3 s
51}

Buradaki yüzde, panonun ne kadarının ıslandığını gösterir; meteorolojideki gibi saatte milimetre cinsinden bir yağış ölçümü değildir. Yine de pratikte çok işe yarar: hafif bir çiseleme panonun yalnızca birkaç izini köprüler, sağanak ise neredeyse tüm yüzeyi kaplar. Seviye sınırlarını (10, 40 ve 75) kendi gözlemlerine göre değiştirebilirsin. Buzzer'ın yalnızca seviye arttığında ötmesi, aynı seviyede beklerken her 3 saniyede bir bip sesi duymanı engeller.

Korozyon: pano neden paslanır, nasıl uzun ömürlü olur?

Yağmur sensörlerinin en büyük sorunu zamanla aşınmalarıdır. Panoya sürekli doğru akım (DC) verildiğinde izlerin arasındaki su bir elektrolit gibi davranır ve elektroliz başlar: artı uca bağlı izdeki metal yavaş yavaş çözünür, nikel kaplama incelir, altındaki bakır kararır ya da yeşillenir. Sonuçta kuru panonun direnci düşer, değerler kayar ve sonunda izler kopar. Sürekli 5 V ile dışarıda bırakılan bir pano birkaç hafta içinde belirgin şekilde aşınabilir. İyi haber şu: aşınma, panonun enerjili kaldığı süreyle doğru orantılıdır ve bu süreyi kısaltmak senin elinde.

• Yalnızca ölçerken besle: VCC'yi bir dijital pinden ver ve modülü her ölçümde yalnızca 50 ms açık tut. 2 saniyede bir ölçüm yapan bir sistemde pano zamanın yüzde 2,5'inde enerjili kalır; bu, aşınmayı yaklaşık 40 kat yavaşlatır.
• Daha seyrek ölç: Yağmur saniyeler içinde değişmez. Pencere ya da bildirim projelerinde 5–30 saniyede bir ölçüm yeterlidir; 30 saniyede bir ölçen bir sistemde pano zamanın yalnızca binde ikisi kadar enerjili kalır.
• Kutupları değiştir (ileri seviye): Panoyu doğrudan iki dijital pine bağlayıp her ölçümde hangi ucun HIGH olacağını değiştirirsen aşınma iki ize eşit dağılır. Bu yöntemde kontrol kartını kullanmazsın; gerilim bölücüyü bir dirençle kendin kurar ve okumayı her iki yönde ayrı ayrı yaparsın.
• Panoyu temiz tut: Toz, polen ve kuş pisliği iletkenliği artırır ve kuru değeri düşürür. Panoyu ara sıra izopropil alkol ve yumuşak bir fırçayla temizle; zımpara ya da sert sünger kaplamayı çizer.
• Kartı koru, panoyu kaplama: Kontrol kartını su geçirmez bir kutuya koy ya da koruyucu vernikle kapla. Panonun üzerine ise vernik, silikon ya da bant sürme; suyun izlere değmesi gerekir.
• Yedek pano bulundur: Pano ucuz bir sarf malzemesidir. Değerler belirgin biçimde kaydığında ya da izler karardığında yalnızca panoyu değiştir ve DRY ile WET değerlerini yeniden ölç.

Servo motor ile otomatik pencere ya da tente kapatma

Yağmur sensörünün en sevilen uygulaması, yağmur başladığında pencereyi, tenteyi ya da sera çatısını kendiliğinden kapatan sistemdir. Bunu bir maket üzerinde SG90 servo motorla kurabilirsin. Burada iki kural önemlidir. Birincisi doğrulama: tek bir damla ya da panoya konan bir böcek pencereyi kapatmamalı, bu yüzden kapatmadan önce art arda 3 ıslak ölçüm bekleriz. İkincisi histerezis: yağmur dindiğinde pano hemen kurumaz ve değer eşiğin etrafında gidip gelir. Pencere sürekli açılıp kapanmasın diye "yağıyor" ve "kurudu" için iki ayrı eşik kullanır, pencereyi ancak pano 10 dakika boyunca kesintisiz kuru kaldıktan sonra açarız. Servonun bağlantısı ve açı ayarı için Servo Motor Nedir? yazısına bakabilirsin.

1// Yağmurda pencereyi servo ile kapatan sistem / Closes a window with a servo when it rains
2#include <Servo.h>
3
4const int SENSOR_POWER = 7;     // modülün VCC'si / module VCC
5const int RAIN_AO = A0;         // analog çıkış / analog output
6const int BUZZER = 8;           // aktif buzzer / active buzzer
7const int SERVO_PIN = 9;        // servo sinyal kablosu / servo signal wire
8
9const int DRY = 1015;           // kuru panel / dry pad (kendin ölç / measure yours)
10const int WET = 350;            // ıslak panel / wet pad (kendin ölç / measure yours)
11const int RAIN_ON = 25;         // %25 ve üstü: yağıyor / 25% and above: raining
12const int RAIN_OFF = 8;         // %8 ve altı: panel kurudu / 8% and below: pad is dry
13const int CONFIRM_COUNT = 3;    // art arda 3 ıslak ölçüm / 3 wet readings in a row
14const unsigned long SAMPLE_MS = 2000UL;   // 2 sn'de bir ölç / measure every 2 s
15const unsigned long DRY_MS = 600000UL;    // 10 dk kuru kalmalı / must stay dry for 10 min
16
17const int OPEN_ANGLE = 90;      // pencere açık / window open
18const int CLOSED_ANGLE = 0;     // pencere kapalı / window closed
19
20Servo windowServo;
21bool closed = false;
22int wetCount = 0;
23unsigned long lastSample = 0;
24unsigned long drySince = 0;
25
26int readWetness() {
27  digitalWrite(SENSOR_POWER, HIGH);
28  delay(50);                                              // değerin oturmasını bekle / let it settle
29  int raw = analogRead(RAIN_AO);
30  digitalWrite(SENSOR_POWER, LOW);
31  return constrain(map(raw, DRY, WET, 0, 100), 0, 100);  // % ıslaklık / % wetness
32}
33
34void beep(int count) {
35  for (int i = 0; i < count; i++) {
36    digitalWrite(BUZZER, HIGH);
37    delay(150);
38    digitalWrite(BUZZER, LOW);
39    delay(150);
40  }
41}
42
43void setup() {
44  Serial.begin(9600);
45  pinMode(SENSOR_POWER, OUTPUT);
46  pinMode(BUZZER, OUTPUT);
47  windowServo.write(OPEN_ANGLE);   // attach'tan önce açı ver, servo zıplamasın / set the angle before attach to avoid a jump
48  windowServo.attach(SERVO_PIN);
49}
50
51void loop() {
52  unsigned long now = millis();
53  if (now - lastSample < SAMPLE_MS) return;   // ölçüm zamanı gelmedi / not time to measure yet
54  lastSample = now;
55
56  int wet = readWetness();
57  Serial.print(F("Islaklik / Wetness: %"));
58  Serial.println(wet);
59
60  if (wet >= RAIN_ON) {
61    drySince = now;                            // kuruma sayacını sıfırla / reset the drying timer
62    if (wetCount < CONFIRM_COUNT) wetCount++;
63    if (!closed && wetCount >= CONFIRM_COUNT) {
64      closed = true;
65      beep(3);
66      windowServo.write(CLOSED_ANGLE);         // pencereyi kapat / close the window
67      Serial.println(F("Yagmur: pencere kapandi / Rain: window closed"));
68    }
69  } else {
70    wetCount = 0;
71    if (wet > RAIN_OFF) {
72      drySince = now;                          // ara bölge kuru sayılmaz / the middle zone does not count as dry
73    } else if (closed && now - drySince >= DRY_MS) {
74      closed = false;
75      windowServo.write(OPEN_ANGLE);           // 10 dk kuruysa aç / open after 10 dry minutes
76      Serial.println(F("Kuru: pencere acildi / Dry: window opened"));
77    }
78  }
79}

ESP32 ile telefona yağmur bildirimi

Evde değilken yağmurun başladığını öğrenmek için ESP32 kullanabilirsin. Aşağıdaki kod yağmur başladığında Telegram üzerinden "çamaşırları topla" mesajı, pano 15 dakika kuru kaldığında da "yağmur durdu" mesajı gönderir. Kod için Kütüphane Yöneticisi'nden UniversalTelegramBot ve ArduinoJson kütüphanelerini kurman gerekir. Bot oluşturmayı ve chat ID'ni bulmayı ESP32 Telegram Bot yazısında adım adım anlatıyoruz.

1// ESP32 yağmur bildirimi (Telegram) / ESP32 rain notification (Telegram)
2#include <WiFi.h>
3#include <WiFiClientSecure.h>
4#include <UniversalTelegramBot.h>        // ArduinoJson kütüphanesi de gerekir / also needs the ArduinoJson library
5
6const char* WIFI_SSID = "WIFI_ADI";      // Wi-Fi ağının adı / your Wi-Fi name
7const char* WIFI_PASS = "WIFI_SIFRESI";  // Wi-Fi şifren / your Wi-Fi password
8#define BOT_TOKEN "1234567890:ABCdefGhIJKlmNoPQRstuVWXyz"  // BotFather'dan / from BotFather
9#define CHAT_ID "123456789"              // senin chat ID'n / your chat ID
10
11const int SENSOR_POWER = 25;             // modülün VCC'si (3,3 V) / module VCC (3.3 V)
12const int RAIN_AO = 34;                  // ADC1 pini, Wi-Fi ile çalışır / ADC1 pin, works with Wi-Fi
13const int DRY = 4095;                    // kuru panel / dry pad (kendin ölç / measure yours)
14const int WET = 1500;                    // ıslak panel / wet pad (kendin ölç / measure yours)
15const int RAIN_ON = 25;                  // %25 ve üstü: yağıyor / 25% and above: raining
16const int RAIN_OFF = 8;                  // %8 ve altı: kuru / 8% and below: dry
17const unsigned long SAMPLE_MS = 5000UL;  // 5 sn'de bir ölç / measure every 5 s
18const unsigned long DRY_MS = 900000UL;   // 15 dk kuru: yağmur bitti / 15 dry minutes: rain is over
19
20WiFiClientSecure client;
21UniversalTelegramBot bot(BOT_TOKEN, client);
22
23bool raining = false;
24int wetCount = 0;
25unsigned long lastSample = 0;
26unsigned long drySince = 0;
27
28int readWetness() {
29  digitalWrite(SENSOR_POWER, HIGH);
30  delay(50);                             // değerin oturmasını bekle / let it settle
31  int raw = analogRead(RAIN_AO);         // 0-4095
32  digitalWrite(SENSOR_POWER, LOW);
33  return constrain(map(raw, DRY, WET, 0, 100), 0, 100);
34}
35
36void connectWiFi() {
37  WiFi.mode(WIFI_STA);
38  WiFi.begin(WIFI_SSID, WIFI_PASS);
39  unsigned long start = millis();
40  while (WiFi.status() != WL_CONNECTED && millis() - start < 15000) {  // en fazla 15 sn bekle / wait up to 15 s
41    delay(500);
42  }
43}
44
45void notify(const String& text) {
46  if (WiFi.status() != WL_CONNECTED) connectWiFi();  // bağlantı koptuysa yeniden bağlan / reconnect if dropped
47  if (WiFi.status() == WL_CONNECTED) {
48    bot.sendMessage(CHAT_ID, text, "");
49  }
50}
51
52void setup() {
53  Serial.begin(115200);
54  pinMode(SENSOR_POWER, OUTPUT);
55  digitalWrite(SENSOR_POWER, LOW);
56  client.setCACert(TELEGRAM_CERTIFICATE_ROOT);  // api.telegram.org kök sertifikası / root certificate
57  connectWiFi();
58  notify("Yagmur sensoru devrede / Rain sensor is online");
59}
60
61void loop() {
62  unsigned long now = millis();
63  if (now - lastSample < SAMPLE_MS) return;
64  lastSample = now;
65
66  int wet = readWetness();
67  Serial.printf("Islaklik / Wetness: %%%d\n", wet);
68
69  if (!raining) {
70    wetCount = (wet >= RAIN_ON) ? wetCount + 1 : 0;
71    if (wetCount >= 2) {                 // art arda 2 ıslak ölçüm (~10 sn) / 2 wet readings in a row (~10 s)
72      raining = true;
73      drySince = now;
74      String msg = "Yagmur basladi, camasirlari topla! / It's raining, bring in the laundry! %";
75      msg += wet;
76      notify(msg);
77    }
78  } else {
79    if (wet > RAIN_OFF) {
80      drySince = now;                    // hâlâ ıslak / still wet
81    } else if (now - drySince >= DRY_MS) {
82      raining = false;
83      wetCount = 0;
84      notify("Yagmur durdu / The rain has stopped");
85    }
86  }
87}

ESP32'nin ADC'si 12 bitlik olduğu için değerler 0–4095 arasındadır ve modül 3,3 V ile beslendiğinde kuru pano genellikle 4095'e çok yakın okunur; DRY ve WET değerlerini yine kendin ölçmelisin. Mesaj göndermek bir iki saniye sürebileceğinden ölçüm aralığını 5 saniye tuttuk ve aynı yağmur için tekrar tekrar mesaj gelmemesi için raining bayrağını kullandık. Sistemi pille çalıştırmak istiyorsan ESP32'yi ölçümler arasında derin uykuya alabilir, Home Assistant kullanıyorsan veriyi MQTT ile gönderebilirsin.

Raspberry Pi Pico ve MicroPython ile yağmur sensörü

Raspberry Pi Pico'da da mantık aynıdır. Modülü GP15 üzerinden 3,3 V ile besle, AO'yu GP26'ya, DO'yu GP14'e, aktif buzzer'ı GP13'e ve servonun sinyal kablosunu GP16'ya bağla. Pico'nun ADC'si read_u16() ile 0–65535 arası değer verir. Aşağıdaki kod yağmuru algıladığında üç kez bip sesi çıkarır ve bir tenteyi servo ile kapatır; pano 10 dakika kuru kaldığında tenteyi yeniden açar.

1# Raspberry Pi Pico yağmur sensörü + servo tente / Raspberry Pi Pico rain sensor + servo awning
2from machine import Pin, ADC, PWM
3import time
4
5power = Pin(15, Pin.OUT, value=0)   # modülün VCC'si (3,3 V) / module VCC (3.3 V)
6rain_ao = ADC(26)                   # GP26 = ADC0, AO çıkışı / AO output
7rain_do = Pin(14, Pin.IN)           # DO: yağmurda 0 / DO: 0 in rain
8buzzer = Pin(13, Pin.OUT, value=0)  # aktif buzzer / active buzzer
9servo = PWM(Pin(16))
10servo.freq(50)                      # servolar 50 Hz ister / servos expect 50 Hz
11
12DRY, WET = 65000, 24000             # kendi değerlerinle değiştir / replace with your readings
13RAIN_ON, RAIN_OFF = 25, 8           # % eşikler / % thresholds
14DRY_MS = 10 * 60 * 1000             # 10 dk kuru kalmalı / must stay dry for 10 min
15OPEN_ANGLE, CLOSED_ANGLE = 90, 0
16
17def set_angle(deg):
18    us = 544 + deg * (2400 - 544) // 180    # Arduino Servo ile aynı aralık / same range as Arduino Servo
19    servo.duty_u16(us * 65535 // 20000)     # 20 ms periyodun oranı / share of the 20 ms period
20
21def read_sensor():
22    power.value(1)
23    time.sleep_ms(50)                       # değerin oturmasını bekle / let it settle
24    raw = rain_ao.read_u16()                # 0-65535
25    do_wet = rain_do.value() == 0
26    power.value(0)
27    pct = (DRY - raw) * 100 // (DRY - WET)
28    return max(0, min(100, pct)), do_wet
29
30def beep(count):
31    for _ in range(count):
32        buzzer.value(1)
33        time.sleep_ms(150)
34        buzzer.value(0)
35        time.sleep_ms(150)
36
37closed = False
38wet_count = 0
39dry_since = time.ticks_ms()
40set_angle(OPEN_ANGLE)                       # tente açık başlar / awning starts open
41
42while True:
43    wet, do_wet = read_sensor()
44    print("Islaklik / Wetness: %", wet, " DO:", "YAGMUR / RAIN" if do_wet else "KURU / DRY")
45    now = time.ticks_ms()
46    if wet >= RAIN_ON:
47        dry_since = now                     # kuruma sayacını sıfırla / reset the drying timer
48        wet_count += 1
49        if not closed and wet_count >= 3:   # art arda 3 ıslak ölçüm / 3 wet readings in a row
50            closed = True
51            beep(3)
52            set_angle(CLOSED_ANGLE)         # tenteyi kapat / retract the awning
53    else:
54        wet_count = 0
55        if wet > RAIN_OFF:
56            dry_since = now
57        elif closed and time.ticks_diff(now, dry_since) >= DRY_MS:
58            closed = False
59            set_angle(OPEN_ANGLE)           # 10 dk kuruysa aç / open after 10 dry minutes
60    time.sleep(2)

MicroPython'da hazır bir servo sınıfı olmadığı için açıyı darbe genişliğine kendimiz çeviriyoruz: servolar 20 ms'de bir gelen, yaklaşık 0,5–2,5 ms uzunluğundaki darbelerle konumlanır. set_angle() fonksiyonu 0–180 dereceyi Arduino Servo kütüphanesiyle aynı olan 544–2400 mikrosaniye aralığına, bu süreyi de duty_u16() için 0–65535 arasındaki bir orana çevirir. Kodu Thonny ile Pico'ya main.py adıyla kaydedersen Pico her açıldığında kendiliğinden çalışır.

Dış mekâna montaj: doğru yerleştirme ipuçları

• Panoyu eğik monte et: 20–45 derecelik bir eğim, damlaların akıp gitmesini ve yağmur bittikten sonra panonun daha çabuk kurumasını sağlar. Düz duran bir panoda su göllenir ve sistem saatlerce "yağıyor" diyebilir.
• Açık gökyüzü gören bir yer seç: Panoyu saçak, ağaç ya da klima damlaması altına koyma; böyle yerlerde hem gerçek yağmuru kaçırır hem de yanlış damlalarla tetiklenir.
• Elektroniği içeride tut: Dışarıda yalnızca pano kalmalı. Kontrol kartını ve Arduino'yu su geçirmez bir kutuya koy, kablo girişini rakorla ya da silikonla kapat.
• Kabloyu kısa tut: Pano ile kart arasındaki kablo birkaç metreye kadar uzatılabilir; daha uzun kablolarda parazit artar. Okumaların ortalamasını almak bu dalgalanmayı azaltır.
• Çiy ve sise dikkat et: Serin gecelerde panoda yoğuşan nem küçük bir ıslaklık değeri üretebilir. Biraz yüksek tutulmuş bir RAIN_ON eşiği ve art arda ölçümle doğrulama, bu yanlış alarmları büyük ölçüde engeller.
• Karı geç algılar: Kuru kar elektriği iletmez; sensör kara ancak eriyip su olduğunda tepki verir. Soğuk iklimlerde sensörü yalnızca yağmur için güvenilir kabul et.

Yağmur sensörü, toprak nem ve su seviye sensörü: farkları

Yağmur sensörü "ne kadar yağdı?" sorusunu cevaplayamaz; bunun için hava istasyonlarında kullanılan devrilen kovalı yağmur ölçer gerekir. Huniden gelen su küçük bir kovayı doldurur, kova belirli bir miktarda devrilir (yaygın hava istasyonu setlerinde bir devrilme 0,2794 mm yağışa karşılık gelir) ve her devrilmede bir mıknatıs reed röleyi kısa bir süre kapatır. Arduino bu darbeleri kesmeyle (interrupt) sayar ve darbe sayısını kova değeriyle çarparak yağışı milimetre cinsinden bulur. İki sensörü birlikte kullanmak da mantıklıdır: yağmur sensörü yağmurun başladığını anında haber verir, kovalı ölçer toplam miktarı kaydeder. Bir kapta biriken suyun yüksekliğini ölçmek istiyorsan su seviye sensörü daha uygun bir seçimdir.

Yağmur sensörü ile proje fikirleri

• Çamaşır uyarıcısı: Yağmur başlayınca öten bir buzzer ve yanan bir LED; ESP32 kullanırsan telefonuna da mesaj gelir.
• Akıllı sera çatısı: Yağmurda çatı kapağını servo ile kapat, havalandırmayı sıcaklığa göre aç. Ayrıntılar için akıllı sera projesi yazısına göz at.
• Yağmurda sulamayı atla: Toprak nem sensörü ile kurduğun otomatik sulama sistemi, yağmur yağarken pompayı çalıştırmasın.
• Mini hava istasyonu: Yağmur durumunu BME280 ile ölçtüğün sıcaklık, nem ve basınçla birlikte bir OLED ekranda göster.
• Silecek maketi: Yağmur şiddeti arttıkça bir servoyu daha hızlı sallayan, otomobillerdeki otomatik silecek sistemini taklit eden eğlenceli bir proje.
• Akıllı ev senaryosu: Yağmur başladığında pencereleri kapatan, tenteyi toplayan ve seni uyaran bir sistem için Arduino akıllı ev projesi rehberinden yararlanabilirsin.

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

Yağmur sensörü; gerilim bölücüyü, karşılaştırıcıyı, histerezisi ve korozyon gibi gerçek dünya sorunlarını aynı anda öğreten ucuz ama öğretici bir modüldür. Panoyu yalnızca ölçerken beslemeyi ve eşikleri kendi ölçümlerine göre ayarlamayı unutmazsan uzun süre işini görür. BlueGrays uygulamasında buzzer, servo motor, akıllı sulama istasyonu ve ESP32 ile Telegram alarmı gibi bu yazıdaki parçaları kullanan projeleri devre şemaları ve kodlarıyla adım adım bulabilir, yağmur sensörünü bu projelere kolayca ekleyebilirsin.