Sensor de chuva com Arduino: ligações, código e janela automática

Um sensor de chuva permite que o seu Arduino detecte gotas de chuva e avise “começou a chover” em milissegundos, e é um dos sensores mais baratos e divertidos que você pode comprar. Ele é formado por uma placa sensora que capta a água e por uma pequena placa com um comparador LM393, e se liga ao Arduino com só quatro fios. Um lembrete para recolher a roupa antes que ela se encharque, uma janela ou um toldo que fecha sozinho quando a chuva começa, um sistema de jardim que pula a irrigação em dias de chuva e uma pequena estação meteorológica começam todos com este módulo.

Neste guia você vai aprender o que há dentro do módulo sensor de chuva vendido como FC-37, YL-83 e MH-RD, a diferença entre as saídas analógica (AO) e digital (DO), como ajustar o limite com o potenciômetro e o assunto mais esquecido de todos: como impedir que a placa sensora corroa. Depois vamos montar passo a passo um alarme de chuva com níveis de intensidade no Arduino, um fechador automático de janela com servo motor, notificações no celular com o ESP32 e um exemplo em MicroPython para o Raspberry Pi Pico.

O que é um sensor de chuva e como ele funciona?

A placa sensora tem duas trilhas condutoras que se intercalam como os dentes de dois pentes, sem nunca se tocar. Com a placa seca, a resistência entre elas fica na casa dos megaohms, então o circuito fica praticamente aberto. Quando uma gota de chuva cai sobre duas trilhas, a água forma uma ponte entre elas e a resistência cai. Quanto mais gotas caem e quanto mais da placa se molha, mais baixa fica a resistência. Na placa de controle, a placa sensora forma um divisor de tensão junto com um resistor, de 10 kΩ na maioria dos modelos: com a placa seca, a tensão no pino AO fica perto da alimentação (VCC) e cai à medida que a placa se molha. Você pode testar como a saída muda com resistências diferentes usando a calculadora de divisor de tensão.

O LM393 da placa é um CI comparador que compara duas tensões. Uma entrada recebe a tensão da placa sensora, e a outra recebe uma tensão de referência que você ajusta com o potenciômetro. No momento em que a tensão da placa sensora cai abaixo da referência, ou seja, quando é detectada água suficiente, a saída DO vai a LOW e o LED DO da placa acende. O LM393 tem saída de coletor aberto; graças a um resistor de pull-up na placa, o DO fica em HIGH quando não há chuva. O outro LED (PWR) só mostra que o módulo está alimentado.

FC-37, YL-83 e MH-RD: há alguma diferença?

Resumindo, não. FC-37, YL-83 e MH-RD são nomes que fabricantes diferentes dão ao mesmo circuito; todos são formados por uma placa sensora e uma placa de controle com LM393, e todos funcionam com o mesmo código. As diferenças costumam estar no tamanho da placa sensora, em pequenas mudanças no desenho das trilhas e na qualidade do revestimento. A placa de controle é quase idêntica à usada com o sensor de umidade do solo, então as placas dos dois módulos são intercambiáveis. Os dois pinos entre a placa sensora e a placa de controle não têm positivo nem negativo, então tanto faz o lado em que você encaixa o cabo. Quando a placa sensora se desgasta com o tempo, você só precisa trocar a placa sensora.

Saída analógica (AO) ou digital (DO)

A saída que você usa depende do seu projeto. O DO só diz “está chovendo” ou “não está chovendo”; você ajusta o limite com o potenciômetro da placa, e um único digitalRead() no Arduino basta. Já o AO dá um número de 0 a 1023 que mostra quão molhada está a placa sensora, então você consegue distinguir garoa de temporal, mudar o limite no código e decidir quando a chuva começou ou parou olhando leituras consecutivas. Você também pode usar as duas saídas ao mesmo tempo.

Ligações do sensor de chuva: Arduino Uno, ESP32 e Pico

Você deve ter notado que, na tabela, o VCC vai a um pino digital em vez do 5V. O módulo consome só uns 8 mA em 5 V, então um pino do Arduino o alimenta com facilidade (o limite recomendado é de 20 mA por pino). Assim você liga o módulo só durante os poucos milissegundos da medição e o mantém desligado no resto do tempo. Vamos ver por que isso importa tanto na seção sobre corrosão. Os pinos do Pico vêm com capacidade de corrente de 4 mA por padrão; como o módulo consome só alguns mA em 3,3 V, isso costuma bastar, mas se as suas leituras ficarem instáveis, você pode alimentar o módulo pelo pino 3V3(OUT).

Ajustando a sensibilidade: o limite no potenciômetro

1. Seque bem a placa sensora e alimente o módulo; o LED PWR deve estar aceso e o LED DO apagado.
2. Gire devagar o potenciômetro com uma chave de fenda pequena até o LED DO acender. Se o LED já estiver aceso com a placa seca, gire para o outro lado.
3. Volte até o ponto exato em que o LED apaga. Esse é o ajuste mais sensível em que o DO fica em HIGH com a placa seca.
4. Gire mais um pouco no mesmo sentido para deixar uma margem de segurança; senão, até o ar úmido ou o orvalho podem disparar o alarme.
5. Deixe cair duas ou três gotas de água do dedo na placa sensora. O LED DO deve acender; se não acender, aumente um pouco a sensibilidade.
6. Seque a placa sensora e veja quanto tempo o LED leva para apagar; isso dá uma ideia de quanto o seu sistema deve esperar antes de decidir que “a chuva parou”.

Passo a passo: a sua primeira leitura com Arduino

1. Ligue o VCC do módulo ao D7, o GND ao GND, o AO ao A0 e o DO ao D2. Encaixe a placa sensora na placa de controle com o cabo de dois fios.
2. Abra o código abaixo no Arduino IDE, selecione Arduino Uno como placa e carregue.
3. Abra o Monitor Serial em 9600 baud e anote o valor do AO com a placa sensora seca.
4. Pingue algumas gotas de água na placa sensora, depois mais, e anote o valor do AO a cada vez.
5. Anote também o valor com a placa totalmente molhada; esses valores serão as constantes DRY e WET que você vai usar nos próximos sketches.

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}

Antes de cada medição, o código põe o D7 em HIGH para alimentar o módulo, espera 50 ms para os capacitores da placa carregarem e a leitura se estabilizar, lê o AO e o DO e desliga o módulo na hora. Assim o módulo fica alimentado só 50 ms em cada ciclo de 2 segundos, ou seja, 2,5% do tempo. Como o DO vai a LOW com chuva, escrevemos a condição como digitalRead(RAIN_DO) == LOW. As palavras em turco das mensagens impressas foram escritas sem caracteres especiais porque alguns terminais mostram esses caracteres embaralhados.

Esses números são só um guia aproximado; o tamanho da placa sensora, o estado do revestimento, a pureza da água e a poeira na placa os mudam bastante. Até os valores do mesmo módulo se desviam depois de a placa ficar alguns meses ao ar livre. Por isso, nos próximos sketches, em vez de usar o valor bruto direto, nós o convertemos em uma porcentagem de umidade de 0 a 100 usando os valores de seco (DRY) e molhado (WET) que você mesmo mediu; assim você só precisa atualizar essas duas constantes, sem mexer nos limites.

Alarme de chuva com Arduino: níveis de intensidade e um buzzer

Agora vamos transformar a medição em um alarme útil. O código faz 8 leituras seguidas do AO, tira a média, converte o resultado em porcentagem de umidade com map() e o coloca em um de quatro níveis: seco, garoa, chuva e temporal. Conforme a chuva engrossa, o buzzer ativo apita tantas vezes quanto o número do nível: uma vez para garoa, duas para chuva e três para temporal. Ligue o terminal positivo do buzzer ao D8 e o negativo ao GND; a diferença entre buzzer ativo e passivo está em O que é um buzzer?.

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}

A porcentagem aqui mostra quanto da placa sensora está molhada; não é uma medição de chuva em milímetros por hora como as que os meteorologistas usam. Mesmo assim, na prática é muito útil: uma garoa fina só faz ponte entre algumas trilhas, enquanto um temporal cobre quase toda a superfície. Você pode mudar os limites dos níveis (10, 40 e 75) de acordo com as suas observações. Como o buzzer só toca quando o nível sobe, você não vai ouvir um bipe a cada 3 segundos enquanto a chuva continua no mesmo nível.

Corrosão: por que a placa sensora enferruja e como fazê-la durar

O maior problema dos sensores de chuva é que eles se desgastam com o tempo. Quando corrente contínua (CC) é aplicada à placa sensora o tempo todo, a água entre as trilhas age como eletrólito e começa a eletrólise: o metal da trilha ligada ao lado positivo se dissolve aos poucos, o revestimento de níquel afina e o cobre de baixo fica escuro ou esverdeado. O resultado é que a resistência da placa seca cai, as leituras se desviam e, por fim, as trilhas se rompem. Uma placa deixada ao ar livre com 5 V constantes pode se desgastar visivelmente em poucas semanas. A boa notícia: o desgaste é proporcional ao tempo em que a placa fica alimentada, e você controla esse tempo.

• Alimente só durante a medição: alimente o VCC por um pino digital e mantenha o módulo ligado só 50 ms por leitura. Em um sistema que mede a cada 2 segundos, a placa fica alimentada 2,5% do tempo, o que desacelera o desgaste cerca de 40 vezes.
• Meça com menos frequência: a chuva não muda em segundos. Para projetos de janela ou de notificação, uma leitura a cada 5–30 segundos basta; um sistema que mede a cada 30 segundos mantém a placa alimentada só cerca de 0,2% do tempo.
• Inverta a polaridade (avançado): se você ligar a placa sensora direto a dois pinos digitais e alternar qual ponta fica em HIGH a cada leitura, o desgaste se divide igualmente entre as duas trilhas. Com esse método, você não usa a placa de controle; você mesmo monta o divisor de tensão com um resistor e faz uma leitura em cada sentido.
• Mantenha a placa limpa: poeira, pólen e fezes de passarinho aumentam a condutividade e baixam a leitura de seco. Limpe a placa de vez em quando com álcool isopropílico e uma escova macia; lixa ou esponja abrasiva arranham o revestimento.
• Proteja a placa de controle, não a placa sensora: ponha a placa de controle em uma caixa à prova d'água ou aplique um verniz protetor (conformal coating). Nunca cubra a placa sensora com verniz, silicone ou fita; a água precisa tocar nas trilhas.
• Tenha uma placa sensora reserva: a placa sensora é um consumível barato. Quando as leituras se desviarem muito ou as trilhas escurecerem, basta trocá-la e medir de novo o DRY e o WET.

Fechamento automático de janela ou toldo com servo motor

A aplicação mais popular do sensor de chuva é um sistema que fecha sozinho uma janela, um toldo ou o teto de uma estufa quando a chuva começa. Você pode montar isso em uma maquete com um servo motor SG90. Duas regras importam aqui. A primeira é a confirmação: uma única gota ou um inseto pousando na placa não deve fechar a janela, então esperamos 3 leituras molhadas seguidas antes de fechar. A segunda é a histerese: quando a chuva para, a placa não seca na hora e o valor fica rondando o limite. Para impedir que a janela abra e feche sem parar, usamos dois limites separados para “chovendo” e “seco”, e só abrimos a janela depois que a placa fica seca por 10 minutos sem interrupção. Para as ligações do servo e o controle do ângulo, veja O que é um servo motor?.

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}

Notificações de chuva no celular com o ESP32

Para saber que começou a chover quando você está fora de casa, você pode usar um ESP32. O código abaixo manda uma mensagem “recolha a roupa” pelo Telegram quando a chuva começa e uma mensagem “a chuva parou” depois que a placa fica seca por 15 minutos. Você vai precisar instalar as bibliotecas UniversalTelegramBot e ArduinoJson pelo Gerenciador de Bibliotecas. Explicamos passo a passo como criar um bot e descobrir o seu chat ID em bot do Telegram com ESP32.

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}

O ADC do ESP32 é de 12 bits, então os valores vão de 0 a 4095 e, com o módulo alimentado em 3,3 V, uma placa seca costuma marcar muito perto de 4095; mesmo assim, meça você mesmo os valores de DRY e WET. Como mandar uma mensagem pode levar um ou dois segundos, mantivemos o intervalo de medição em 5 segundos, e usamos a flag raining para que a mesma pancada de chuva não dispare uma mensagem atrás da outra. Se quiser rodar o sistema com bateria, você pode pôr o ESP32 em deep sleep entre as leituras e, se usa o Home Assistant, pode mandar os dados por MQTT.

Sensor de chuva com Raspberry Pi Pico e MicroPython

A lógica é a mesma no Raspberry Pi Pico. Alimente o módulo com 3,3 V pelo GP15 e ligue o AO ao GP26, o DO ao GP14, o buzzer ativo ao GP13 e o fio de sinal do servo ao GP16. O ADC do Pico retorna valores de 0 a 65535 com read_u16(). O código abaixo apita três vezes quando detecta chuva e recolhe um toldo com o servo; depois que a placa fica seca por 10 minutos, ele abre o toldo de novo.

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)

O MicroPython não tem uma classe de servo pronta, então nós mesmos convertemos o ângulo em largura de pulso: os servos são posicionados por pulsos de cerca de 0,5–2,5 ms que chegam a cada 20 ms. A função set_angle() leva 0–180 graus para a mesma faixa de 544–2400 microssegundos usada pela biblioteca Servo do Arduino e depois converte esse tempo em uma proporção de 0–65535 para o duty_u16(). Se você salvar o código no Pico como main.py com o Thonny, ele roda automaticamente toda vez que o Pico liga.

Instalação ao ar livre: dicas para o posicionamento certo

• Monte a placa sensora inclinada: uma inclinação de 20–45 graus deixa as gotas escorrerem e ajuda a placa a secar mais rápido depois que a chuva para. Em uma placa na horizontal, a água empoça e o sistema pode continuar dizendo “chovendo” por horas.
• Escolha um lugar com céu aberto: não ponha a placa sensora embaixo de beirais, árvores ou de um ar-condicionado que pinga; nesses lugares ela perde a chuva de verdade e é disparada por pingos perdidos.
• Mantenha a eletrônica dentro de casa: só a placa sensora deve ficar do lado de fora. Ponha a placa de controle e o Arduino em uma caixa à prova d'água e vede a entrada do cabo com um prensa-cabo ou silicone.
• Mantenha o cabo curto: o cabo entre a placa sensora e a placa de controle pode ser estendido a alguns metros; em cabos mais longos, o ruído aumenta. Fazer a média das leituras reduz essa oscilação.
• Cuidado com orvalho e neblina: em noites frias, a umidade que condensa na placa pode gerar uma pequena leitura de umidade. Um limite RAIN_ON um pouco mais alto e a confirmação com leituras consecutivas evitam a maioria desses alarmes falsos.
• Ele demora para detectar neve: a neve seca não conduz eletricidade; o sensor só reage quando a neve derrete e vira água. Em climas frios, considere o sensor confiável só para chuva.

Sensor de chuva, sensor de umidade do solo e sensor de nível de água: as diferenças

Um sensor de chuva não responde à pergunta “quanto choveu?”; para isso você precisa do pluviômetro de báscula usado em estações meteorológicas. A água de um funil enche uma pequena báscula, que vira com uma quantidade definida (nos kits comuns de estação meteorológica, cada basculada equivale a 0,2794 mm de chuva), e a cada basculada um ímã fecha por um instante um reed switch. O Arduino conta esses pulsos com uma interrupção e multiplica a contagem pelo valor da báscula para ter a chuva em milímetros. Usar os dois sensores juntos também faz sentido: o sensor de chuva avisa na hora que a chuva começou, enquanto o pluviômetro registra o total. Se quiser medir a altura da água que se acumula em um recipiente, um sensor de nível de água é a melhor escolha.

Ideias de projetos com sensor de chuva

• Aviso da roupa no varal: um buzzer que toca e um LED que acende quando a chuva começa; com um ESP32, você também recebe uma mensagem no celular.
• Teto de estufa inteligente: feche a ventilação do teto com um servo na chuva e abra para ventilar conforme a temperatura. Veja os detalhes no projeto de estufa inteligente.
• Pular a irrigação na chuva: impeça que o sistema de irrigação automática que você montou com um sensor de umidade do solo ligue a bomba enquanto chove.
• Miniestação meteorológica: mostre o estado da chuva em um display OLED junto com a temperatura, a umidade e a pressão medidas com um BME280.
• Maquete de limpador de para-brisa: um projeto divertido que imita os limpadores automáticos de um carro, balançando um servo mais rápido à medida que a chuva engrossa.
• Cenário de casa inteligente: para um sistema que fecha as janelas, recolhe o toldo e avisa você quando a chuva começa, confira o guia do projeto de casa inteligente com Arduino.

Erros comuns e como corrigir

O sensor de chuva é um módulo barato, mas instrutivo, que ensina de uma vez divisores de tensão, comparadores, histerese e problemas do mundo real como a corrosão. Se você lembrar de alimentar a placa sensora só durante a medição e de definir os limites a partir das suas próprias leituras, ele vai servir você por muito tempo. No app BlueGrays você encontra projetos passo a passo, com esquemas de circuito e código, que usam as peças deste artigo, como um buzzer, um servo motor, uma estação de irrigação inteligente e um alarme no Telegram com ESP32, e pode acrescentar um sensor de chuva a eles com facilidade.