Capteur de pluie Arduino : câblage, code et fenêtre automatique

Un capteur de pluie permet à ton Arduino de détecter les gouttes d'eau et de signaler « il commence à pleuvoir » en quelques millisecondes ; c'est l'un des capteurs les moins chers et les plus amusants qui existent. Il se compose d'une plaque de détection qui reçoit l'eau et d'une petite carte de contrôle équipée d'un comparateur LM393, et il se branche à l'Arduino avec seulement quatre fils. Une alerte pour rentrer le linge avant qu'il soit trempé, une fenêtre ou un store qui se ferme tout seul quand il pleut, un arrosage de jardin qui fait une pause les jours de pluie ou une petite station météo commencent tous avec ce module.

Dans ce guide, tu vas découvrir ce que contient le module capteur de pluie vendu sous les noms FC-37, YL-83 ou MH-RD, la différence entre la sortie analogique (AO) et la sortie numérique (DO), comment régler le seuil avec le potentiomètre et le sujet le plus souvent oublié : comment empêcher la plaque de se corroder. Ensuite, nous construirons pas à pas une alarme pluie à plusieurs niveaux d'intensité avec l'Arduino, une fermeture automatique de fenêtre avec un servomoteur, des notifications sur ton téléphone avec l'ESP32 et un exemple MicroPython pour le Raspberry Pi Pico.

Qu'est-ce qu'un capteur de pluie et comment fonctionne-t-il ?

La plaque de détection porte deux pistes conductrices entrelacées comme les dents de deux peignes, sans jamais se toucher. Quand la plaque est sèche, la résistance entre elles se compte en mégohms : le circuit est pratiquement ouvert. Quand une goutte tombe à cheval sur deux pistes, l'eau forme un pont entre elles et la résistance chute. Plus il tombe de gouttes et plus la surface mouillée est grande, plus la résistance baisse. Sur la carte de contrôle, la plaque forme un pont diviseur de tension avec une résistance, de 10 kΩ sur la plupart des modèles : plaque sèche, la tension sur la broche AO est proche de l'alimentation (VCC), puis elle diminue à mesure que la plaque se mouille. Tu peux tester toi-même l'effet de différentes résistances sur la sortie avec le calculateur de pont diviseur.

Le LM393 de la carte est un circuit comparateur qui compare deux tensions. Une entrée reçoit la tension de la plaque, l'autre une tension de référence que tu règles avec le potentiomètre. Dès que la tension de la plaque passe sous la référence, c'est-à-dire dès qu'assez d'eau est détectée, la sortie DO passe à LOW et la LED DO de la carte s'allume. Le LM393 a une sortie à collecteur ouvert ; grâce à une résistance de pull-up sur la carte, DO reste à HIGH quand il ne pleut pas. L'autre LED (PWR) indique simplement que le module est alimenté.

FC-37, YL-83 et MH-RD : y a-t-il une différence ?

En bref, non. FC-37, YL-83 et MH-RD sont des noms que différents fabricants donnent au même circuit ; tous se composent d'une plaque de détection et d'une carte de contrôle à LM393, et tous fonctionnent avec le même code. Les différences portent surtout sur la taille de la plaque, de petites variations du dessin des pistes et la qualité du revêtement. La carte de contrôle est presque identique à celle du capteur d'humidité du sol : les cartes des deux modules sont donc interchangeables. Les deux broches entre la plaque et la carte n'ont ni plus ni moins, le sens de branchement du câble n'a donc aucune importance. Quand la plaque s'use avec le temps, il suffit de remplacer la plaque.

Sortie analogique (AO) ou numérique (DO) : quelle différence ?

Le choix de la sortie dépend de ton projet. DO dit seulement « il pleut » ou « il ne pleut pas » ; tu fixes le seuil avec le potentiomètre de la carte, et un simple digitalRead() suffit côté Arduino. AO, en revanche, fournit un nombre de 0 à 1023 qui indique à quel point la plaque est mouillée : tu peux ainsi distinguer la bruine d'une averse, modifier le seuil dans le code et décider quand la pluie commence ou s'arrête en t'appuyant sur des mesures successives. Tu peux aussi utiliser les deux sorties en même temps.

Branchement du capteur de pluie : Arduino Uno, ESP32 et Pico

Tu as sans doute remarqué que, dans le tableau, VCC est relié à une broche numérique plutôt qu'au 5V. Le module ne consomme qu'environ 8 mA sous 5 V : une broche de l'Arduino l'alimente donc sans problème (la limite conseillée est de 20 mA par broche). Tu n'allumes ainsi le module que pendant les quelques millisecondes de la mesure et tu le laisses éteint le reste du temps. Nous verrons pourquoi c'est si important dans la partie sur la corrosion. Les broches du Pico sont réglées par défaut sur un courant de sortie de 4 mA ; comme le module ne consomme que quelques mA sous 3,3 V, cela suffit généralement, mais si les mesures sont instables, tu peux l'alimenter par la broche 3V3(OUT).

Régler la sensibilité : fixer le seuil avec le potentiomètre

1. Essuie bien la plaque et alimente le module ; la LED PWR doit être allumée et la LED DO éteinte.
2. Tourne lentement le potentiomètre avec un petit tournevis jusqu'à ce que la LED DO s'allume. Si elle est déjà allumée avec la plaque sèche, tourne dans l'autre sens.
3. Reviens exactement au point où la LED s'éteint. C'est le réglage le plus sensible pour lequel DO reste à HIGH avec la plaque sèche.
4. Tourne encore un peu dans le même sens pour garder une marge de sécurité ; sinon, même l'air humide ou la rosée peuvent déclencher l'alarme.
5. Fais tomber deux ou trois gouttes d'eau du bout du doigt sur la plaque. La LED DO doit s'allumer ; sinon, augmente un peu la sensibilité.
6. Sèche la plaque et observe combien de temps la LED met à s'éteindre : cela te donne une idée du délai que ton système doit attendre avant de conclure « la pluie s'est arrêtée ».

Pas à pas : ta première mesure avec Arduino

1. Relie VCC du module à D7, GND à GND, AO à A0 et DO à D2. Branche la plaque sur la carte avec le câble à deux fils.
2. Ouvre le code ci-dessous dans l'Arduino IDE, choisis la carte Arduino Uno et téléverse-le.
3. Ouvre le moniteur série à 9600 bauds et note la valeur de AO avec la plaque sèche.
4. Dépose d'abord quelques gouttes d'eau sur la plaque, puis davantage, et note chaque fois la valeur de AO.
5. Note aussi la valeur quand la plaque est entièrement mouillée : ces valeurs deviendront les constantes DRY et WET des programmes suivants.

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}

Avant chaque mesure, le code met D7 à HIGH pour alimenter le module, attend 50 ms que les condensateurs de la carte se chargent et que la valeur se stabilise, lit AO et DO, puis coupe aussitôt le module. Le module n'est ainsi alimenté que 50 ms par boucle de 2 secondes, soit 2,5 % du temps. Comme DO passe à LOW sous la pluie, nous avons écrit la condition digitalRead(RAIN_DO) == LOW. Les mots turcs des messages affichés sont écrits sans caractères spéciaux, car certains terminaux les affichent mal.

Ces chiffres ne sont qu'indicatifs : la taille de la plaque, l'état du revêtement, la pureté de l'eau et la poussière les modifient nettement. Même les valeurs d'un même module dérivent après quelques mois passés dehors. C'est pourquoi, dans les programmes suivants, nous n'utilisons pas directement la valeur brute : nous la convertissons en pourcentage d'humidité de 0 à 100 à partir des valeurs sèche (DRY) et mouillée (WET) que tu as mesurées toi-même. Il te suffit alors de mettre à jour ces deux constantes sans toucher aux seuils.

Alarme pluie avec Arduino : niveaux d'intensité et buzzer

Transformons maintenant la mesure en une alarme utile. Le code prend 8 mesures successives sur AO, en calcule la moyenne, la convertit en pourcentage d'humidité avec map() et la classe dans l'un des quatre niveaux : sec, bruine, pluie et averse. Quand la pluie s'intensifie, le buzzer actif bipe autant de fois que le numéro du niveau : une fois pour la bruine, deux fois pour la pluie et trois fois pour une averse. Relie la patte positive du buzzer à D8 et la patte négative à GND ; la différence entre buzzer actif et passif est expliquée dans Qu'est-ce qu'un 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}

Ce pourcentage indique la part de la plaque qui est mouillée ; ce n'est pas une mesure des précipitations en millimètres par heure comme en météorologie. Il reste très utile en pratique : une bruine légère ne relie que quelques pistes, alors qu'une averse couvre presque toute la surface. Tu peux adapter les limites des niveaux (10, 40 et 75) selon tes propres observations. Comme le buzzer ne sonne que lorsque le niveau augmente, tu n'entends pas un bip toutes les 3 secondes tant que la pluie garde la même intensité.

Corrosion : pourquoi la plaque rouille-t-elle et comment la faire durer ?

Le plus gros défaut des capteurs de pluie, c'est l'usure. Quand la plaque reçoit en permanence un courant continu (DC), l'eau entre les pistes joue le rôle d'électrolyte et l'électrolyse commence : le métal de la piste reliée au pôle positif se dissout lentement, le nickelage s'amincit et le cuivre en dessous noircit ou verdit. Résultat : la résistance de la plaque sèche diminue, les valeurs dérivent et les pistes finissent par se couper. Une plaque laissée dehors sous 5 V en permanence peut s'user nettement en quelques semaines. Bonne nouvelle : l'usure est proportionnelle au temps pendant lequel la plaque est alimentée, et ce temps, c'est toi qui le contrôles.

• N'alimente que pendant la mesure : Prends VCC sur une broche numérique et n'allume le module que 50 ms par mesure. Dans un système qui mesure toutes les 2 secondes, la plaque n'est alimentée que 2,5 % du temps, ce qui ralentit l'usure d'environ 40 fois.
• Mesure moins souvent : La pluie ne change pas en quelques secondes. Pour une fenêtre ou des notifications, une mesure toutes les 5 à 30 secondes suffit ; avec une mesure toutes les 30 secondes, la plaque n'est alimentée qu'environ 0,2 % du temps.
• Inverse la polarité (niveau avancé) : Si tu relies la plaque directement à deux broches numériques et que tu changes à chaque mesure l'extrémité mise à HIGH, l'usure se répartit équitablement entre les deux pistes. Dans ce cas, tu n'utilises pas la carte de contrôle : tu montes toi-même le pont diviseur avec une résistance et tu fais une mesure dans chaque sens.
• Garde la plaque propre : La poussière, le pollen et les fientes d'oiseaux augmentent la conductivité et font baisser la valeur à sec. Nettoie la plaque de temps en temps avec de l'alcool isopropylique et un pinceau doux ; le papier de verre ou une éponge abrasive rayent le revêtement.
• Protège la carte, pas la plaque : Place la carte de contrôle dans un boîtier étanche ou recouvre-la de vernis de protection. En revanche, ne recouvre jamais la plaque de vernis, de silicone ou de ruban adhésif : l'eau doit toucher les pistes.
• Garde une plaque de rechange : La plaque est un consommable bon marché. Quand les valeurs dérivent nettement ou que les pistes noircissent, remplace seulement la plaque et mesure de nouveau DRY et WET.

Fermer automatiquement une fenêtre ou un store avec un servomoteur

L'application la plus populaire du capteur de pluie est un système qui ferme tout seul une fenêtre, un store ou le toit d'une serre quand il commence à pleuvoir. Tu peux le construire sur une maquette avec un servomoteur SG90. Deux règles comptent ici. La première est la confirmation : une seule goutte ou un insecte posé sur la plaque ne doit pas fermer la fenêtre, c'est pourquoi nous attendons 3 mesures humides consécutives avant de fermer. La seconde est l'hystérésis : quand la pluie s'arrête, la plaque ne sèche pas instantanément et la valeur oscille autour du seuil. Pour que la fenêtre ne s'ouvre et ne se ferme pas sans arrêt, nous utilisons deux seuils distincts pour « il pleut » et « sec », et nous ne rouvrons la fenêtre qu'après 10 minutes ininterrompues de plaque sèche. Pour le branchement du servo et le réglage de l'angle, consulte Qu'est-ce qu'un servomoteur ?.

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}

Alerte pluie sur ton téléphone avec l'ESP32

Pour savoir qu'il pleut chez toi quand tu n'es pas là, tu peux utiliser un ESP32. Le code ci-dessous envoie via Telegram le message « rentre le linge » quand la pluie commence, puis « la pluie s'est arrêtée » quand la plaque est restée sèche 15 minutes. Tu dois installer les bibliothèques UniversalTelegramBot et ArduinoJson depuis le gestionnaire de bibliothèques. La création du bot et la recherche de ton chat ID sont expliquées pas à pas dans Bot Telegram avec 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}

L'ADC de l'ESP32 est sur 12 bits : les valeurs vont donc de 0 à 4095, et avec le module alimenté en 3,3 V, une plaque sèche donne généralement une valeur très proche de 4095 ; mesure tout de même toi-même DRY et WET. Comme l'envoi d'un message peut prendre une ou deux secondes, nous avons fixé l'intervalle de mesure à 5 secondes, et la variable raining évite qu'une même averse déclenche un message après l'autre. Pour un fonctionnement sur batterie, tu peux mettre l'ESP32 en deep sleep entre deux mesures, et si tu utilises Home Assistant, tu peux envoyer les données en MQTT.

Capteur de pluie avec le Raspberry Pi Pico et MicroPython

Sur le Raspberry Pi Pico, la logique est la même. Alimente le module en 3,3 V par GP15 et relie AO à GP26, DO à GP14, le buzzer actif à GP13 et le fil de signal du servo à GP16. L'ADC du Pico renvoie des valeurs de 0 à 65535 avec read_u16(). Le code ci-dessous émet trois bips quand il détecte la pluie et replie un store avec le servo ; quand la plaque est restée sèche 10 minutes, il le redéploie.

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 ne propose pas de classe servo prête à l'emploi : nous convertissons donc nous-mêmes l'angle en largeur d'impulsion. Les servos se positionnent grâce à des impulsions d'environ 0,5 à 2,5 ms envoyées toutes les 20 ms. La fonction set_angle() fait correspondre 0–180 degrés à la même plage de 544–2400 microsecondes que la bibliothèque Servo d'Arduino, puis convertit cette durée en une proportion de 0–65535 pour duty_u16(). Si tu enregistres le code sur le Pico sous le nom main.py avec Thonny, il démarre automatiquement à chaque mise sous tension.

Installation en extérieur : bien placer le capteur

• Incline la plaque : Une inclinaison de 20 à 45 degrés permet aux gouttes de s'écouler et à la plaque de sécher plus vite après la pluie. Sur une plaque à plat, l'eau stagne et le système peut annoncer « il pleut » pendant des heures.
• Choisis un endroit à ciel ouvert : Ne place pas la plaque sous un avant-toit, un arbre ou un climatiseur qui goutte ; à ces endroits, elle rate la vraie pluie et se déclenche avec des gouttes parasites.
• Garde l'électronique à l'abri : Seule la plaque doit rester dehors. Mets la carte de contrôle et l'Arduino dans un boîtier étanche et rends l'entrée du câble étanche avec un presse-étoupe ou du silicone.
• Garde le câble court : Le câble entre la plaque et la carte peut être rallongé de quelques mètres ; au-delà, les parasites augmentent. Faire la moyenne de plusieurs mesures réduit ces fluctuations.
• Attention à la rosée et au brouillard : Par les nuits fraîches, l'humidité qui se condense sur la plaque peut produire une petite valeur d'humidité. Un seuil RAIN_ON un peu plus élevé et une confirmation par plusieurs mesures évitent la plupart de ces fausses alertes.
• Il détecte la neige tardivement : La neige sèche ne conduit pas l'électricité ; le capteur ne réagit que lorsqu'elle fond. Dans les régions froides, considère le capteur comme fiable uniquement pour la pluie.

Capteur de pluie, d'humidité du sol et de niveau d'eau : les différences

Un capteur de pluie ne peut pas répondre à la question « combien est-il tombé ? » ; pour cela, il faut le pluviomètre à augets basculants des stations météo. L'eau recueillie par un entonnoir remplit un petit auget qui bascule à une quantité fixe (sur les kits de station météo courants, un basculement correspond à 0,2794 mm de pluie), et à chaque basculement un aimant ferme brièvement un interrupteur reed (ILS). L'Arduino compte ces impulsions avec une interruption et multiplie leur nombre par la valeur de l'auget pour obtenir la pluie en millimètres. Combiner les deux capteurs a aussi du sens : le capteur de pluie signale immédiatement le début de la pluie, le pluviomètre enregistre le cumul. Si tu veux mesurer la hauteur d'eau accumulée dans un récipient, un capteur de niveau d'eau est plus adapté.

Idées de projets avec un capteur de pluie

• Alerte linge : Un buzzer qui sonne et une LED qui s'allume quand il commence à pleuvoir ; avec un ESP32, tu reçois aussi un message sur ton téléphone.
• Toit de serre intelligent : Ferme le volet du toit avec un servo quand il pleut et ouvre-le selon la température pour aérer. Tous les détails sont dans le projet de serre connectée.
• Pas d'arrosage sous la pluie : Empêche l'arrosage automatique que tu as monté avec un capteur d'humidité du sol de lancer la pompe pendant qu'il pleut.
• Mini station météo : Affiche l'état de la pluie sur un écran OLED avec la température, l'humidité et la pression mesurées par un BME280.
• Maquette d'essuie-glace : Un projet amusant qui imite les essuie-glaces automatiques d'une voiture en faisant balayer un servo d'autant plus vite qu'il pleut fort.
• Scénario maison connectée : Pour un système qui ferme les fenêtres, replie le store et te prévient quand la pluie commence, appuie-toi sur le guide projet de maison connectée avec Arduino.

Erreurs fréquentes et solutions

Le capteur de pluie est un module bon marché mais très formateur, qui t'apprend à la fois le pont diviseur, le comparateur, l'hystérésis et des problèmes bien réels comme la corrosion. Si tu penses à n'alimenter la plaque que pendant la mesure et à régler les seuils d'après tes propres relevés, il te servira longtemps. Dans l'application BlueGrays, tu trouveras des projets pas à pas, avec schémas et code, qui utilisent les composants de cet article, comme le buzzer, le servomoteur, une station d'arrosage intelligente et une alarme Telegram avec ESP32, et tu pourras facilement y ajouter le capteur de pluie.