Arduino UNO Q - Capteur de Pluie
Un capteur de pluie peut détecter la pluie ou la neige et mesurer l'intensité des précipitations. Il fournit à la fois une sortie numérique (pluie/pas de pluie) et une sortie analogique (niveau d'intensité). Sur Arduino UNO Q, l'ADC 12 bits du MCU offre des lectures d'intensité de plus haute résolution. Avec Bridge et Telegram, vous recevez des alertes de pluie instantanées sur votre téléphone.
Dans ce tutoriel, vous apprendrez :
- Ce qu'est un capteur de pluie et comment il fonctionne
- Comment câbler le capteur de pluie au MCU Arduino UNO Q
- Comment lire les sorties numérique (DO) et analogique (AO)
- Comment utiliser Bridge pour exposer l'état de pluie et les événements au côté Linux (Python)
- Comment recevoir des alertes Telegram lorsque la pluie est détectée sur Arduino UNO Q
- Comment utiliser OpenClaw sur Arduino UNO Q avec le capteur de pluie
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
À Propos du Capteur de Pluie
Le capteur de pluie comprend deux parties : un pad de détection et un module électronique.
Pad de détection : Placé à l'extérieur (sur un toit ou un rebord de fenêtre). Possède des lignes de cuivre d'alimentation et de détection alternées — l'eau établit un pont entre ces lignes lorsque la pluie tombe.
Module électronique : Convertit le signal du pad en sorties lisibles :
- Broche VCC : Alimentation 3,3V à 5V
- Broche GND : Masse
- Broche DO : Sortie numérique — HIGH = pas de pluie, LOW = pluie détectée. Sensibilité réglée par le potentiomètre intégré.
- Broche AO : Sortie analogique — valeur plus basse = plus de pluie, valeur plus haute = moins de pluie. Le potentiomètre n'affecte PAS la broche AO.
Il possède également deux LEDs :
- LED PWR : Indicateur d'alimentation
- LED DO : S'allume lorsque la pluie est détectée (broche DO à LOW)
Comment Ça Fonctionne
- Broche DO : Le potentiomètre définit un seuil. Si la pluie dépasse le seuil, DO passe à LOW. Ajustez le potentiomètre pour régler la sensibilité.
- Broche AO : Émet continuellement une tension analogique proportionnelle à l'eau sur le pad. Sur Arduino UNO Q, le MCU lit ceci comme une valeur 12 bits (0–4095) — des valeurs plus basses signifient plus de pluie.
※ Note:
Connectez VCC à une broche de sortie numérique (pas à 5V toujours actif) et alimentez le capteur uniquement pendant les lectures. Cela réduit la corrosion électrochimique et prolonge la durée de vie du capteur.
Schéma de Câblage
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
| Broche Capteur de Pluie | MCU Arduino UNO Q |
|---|---|
| GND | GND |
| VCC | D3 (alimentation contrôlée) |
| DO | D4 |
| AO | A0 |
Comment Programmer Pour le Capteur de Pluie
- Configurer les broches :
pinMode(POWER_PIN, OUTPUT);
pinMode(DO_PIN, INPUT);
- Alimenter le capteur, lire les deux sorties, puis couper l'alimentation :
digitalWrite(POWER_PIN, HIGH); // power on
delay(10); // stabilize
int do_state = digitalRead(DO_PIN); // HIGH = no rain, LOW = rain
int ao_value = analogRead(AO_PIN); // 0-4095, lower = more rain
digitalWrite(POWER_PIN, LOW); // power off
- Vérifier la pluie depuis la sortie numérique :
if (do_state == LOW) {
Serial.println("Rain DETECTED");
} else {
Serial.println("No rain");
}
Code Arduino UNO Q
L'Arduino UNO Q possède deux processeurs qui fonctionnent ensemble :
- Le MCU STM32 lit les sorties DO (numérique) et AO (analogique) du capteur de pluie chaque seconde
- Le MPU Qualcomm exécute Debian Linux et gère le Wi-Fi, Python et la connectivité cloud
- Dans cette section, seul le MCU est programmé — le côté Linux reste inactif. Une section ultérieure montre comment les deux processeurs fonctionnent ensemble via Bridge.
※ Note:
Le MCU Arduino UNO Q utilise un ADC 12 bits (0–4095). Les valeurs d'intensité AO seront dans cette plage — ajustez les seuils de détection en conséquence.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/arduino-uno-q/arduino-uno-q-rain-sensor
*/
// Rain sensor has two outputs:
// DO: digital — HIGH = no rain, LOW = rain detected
// AO: analog — lower value = more rain (12-bit ADC: 0-4095)
// POWER_PIN: power sensor only when reading to reduce corrosion
#define POWER_PIN 3 // The Arduino UNO Q MCU pin providing power to the rain sensor
#define DO_PIN 4 // The Arduino UNO Q MCU pin connected to DO of the rain sensor
#define AO_PIN A0 // The Arduino UNO Q MCU pin connected to AO of the rain sensor
void setup() {
Serial.begin(9600);
pinMode(POWER_PIN, OUTPUT);
pinMode(DO_PIN, INPUT);
digitalWrite(POWER_PIN, LOW); // start with sensor powered off
Serial.println("Arduino UNO Q Rain Sensor ready");
}
void loop() {
digitalWrite(POWER_PIN, HIGH); // power the sensor
delay(10); // allow sensor to stabilize
int do_state = digitalRead(DO_PIN); // HIGH = no rain, LOW = rain
int ao_value = analogRead(AO_PIN); // 0-4095: lower = more rain
digitalWrite(POWER_PIN, LOW); // power off sensor
// Digital output
if (do_state == LOW) {
Serial.print("Rain DETECTED | ");
} else {
Serial.print("No rain | ");
}
// Analog output
Serial.print("Intensity (AO): ");
Serial.println(ao_value);
delay(1000);
}
Étapes Rapides
Première fois avec Arduino UNO Q ? Suivez le tutoriel Démarrer avec Arduino UNO Q avant de continuer.
- Connecter : Câblez le capteur de pluie au MCU Arduino UNO Q comme indiqué dans le schéma de câblage.
- Ouvrir Arduino App Lab : Lancez Arduino App Lab et attendez qu'il détecte votre Arduino UNO Q.
- Créer une nouvelle application : Cliquez sur le bouton Create New App.
- Donnez un nom à l'application, par exemple : RainSensor
- Cliquez sur Create pour confirmer.
- Coller le sketch : Copiez le code MCU ci-dessus et collez-le dans sketch/sketch.ino. Laissez les autres fichiers par défaut.
- Aucune bibliothèque requise — utilise uniquement les fonctions intégrées digitalRead() et analogRead().
- Téléverser : Cliquez sur le bouton Run dans Arduino App Lab.
- Placez quelques gouttes d'eau sur le pad de détection et observez la sortie dans le Serial Monitor.
- Ajustez le potentiomètre sur le module si la LED DO ne répond pas correctement.
Sortie Console d'App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Arduino UNO Q Rain Sensor ready
[2026-04-29 09:00:02] No rain | Intensity (AO): 4090
[2026-04-29 09:00:03] No rain | Intensity (AO): 4088
[2026-04-29 09:00:04] Rain DETECTED | Intensity (AO): 1243
[2026-04-29 09:00:05] Rain DETECTED | Intensity (AO): 876
[2026-04-29 09:00:06] Rain DETECTED | Intensity (AO): 512
[2026-04-29 09:00:07] No rain | Intensity (AO): 3950
Bridge : Linux + MCU
Cette section montre comment programmer les deux processeurs de l'Arduino UNO Q pour que le côté Linux puisse lire l'état de pluie et recevoir des événements de début de pluie via Bridge :
- Le capteur de pluie est connecté au MCU — le MCU lit DO et AO chaque seconde et met en cache les valeurs
- Le MPU ne peut pas lire directement les broches du capteur — il appelle des fonctions Bridge pour obtenir l'état, la valeur analogique ou les événements
- Le MPU dispose du Wi-Fi — exécutant Debian Linux complet, il peut envoyer des alertes Telegram dès que la pluie est détectée
- Arduino_RouterBridge permet la communication RPC entre les deux processeurs
- ⚠️ /dev/ttyHS1 (Linux) et Serial1 (MCU) sont RÉSERVÉS par le routeur — ne les ouvrez jamais dans le code utilisateur
En résumé : Le MCU détecte la pluie via la broche DO → définit l'indicateur d'événement → le MPU interroge le Bridge → le MPU envoie une alerte Telegram.
Code MCU (Bridge)
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/arduino-uno-q/arduino-uno-q-rain-sensor
*/
#include "Arduino_RouterBridge.h"
#define POWER_PIN 3 // The Arduino UNO Q MCU pin providing power to the rain sensor
#define DO_PIN 4 // The Arduino UNO Q MCU pin connected to DO of the rain sensor
#define AO_PIN A0 // The Arduino UNO Q MCU pin connected to AO of the rain sensor
// Cache
int cached_ao = 4095; // start at max (dry)
bool cached_rain = false; // from DO pin
bool rain_event = false;
bool prev_rain = false;
unsigned long last_read_ms = 0;
const unsigned long READ_INTERVAL = 1000;
String get_state(String arg) {
return cached_rain ? "rain" : "no_rain";
}
String get_value(String arg) {
return String(cached_ao);
}
String get_event(String arg) {
if (rain_event) {
rain_event = false;
return "rain_detected";
}
return "none";
}
void setup() {
Bridge.begin();
Monitor.begin();
pinMode(POWER_PIN, OUTPUT);
pinMode(DO_PIN, INPUT);
digitalWrite(POWER_PIN, LOW);
Bridge.provide("get_state", get_state);
Bridge.provide("get_value", get_value);
Bridge.provide("get_event", get_event);
Monitor.println("Arduino UNO Q Rain Sensor Bridge ready");
}
void loop() {
unsigned long now = millis();
if (now - last_read_ms >= READ_INTERVAL) {
last_read_ms = now;
digitalWrite(POWER_PIN, HIGH);
delay(10);
int do_state = digitalRead(DO_PIN);
cached_ao = analogRead(AO_PIN);
digitalWrite(POWER_PIN, LOW);
cached_rain = (do_state == LOW); // LOW = rain detected
if (cached_rain && !prev_rain) {
rain_event = true;
Monitor.print("Rain detected! AO value: ");
Monitor.println(cached_ao);
} else if (!cached_rain && prev_rain) {
Monitor.println("Rain stopped.");
}
prev_rain = cached_rain;
}
}
Code Python (Bridge)
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/arduino-uno-q/arduino-uno-q-rain-sensor
*/
from arduino.app_utils import *
import time
def loop():
state = Bridge.call("get_state")
value = Bridge.call("get_value")
print(f"Rain state: {state} AO value: {value}")
time.sleep(1)
App.run(user_loop=loop)
Étapes Rapides
- Connecter : Câblez le capteur de pluie à l'Arduino UNO Q comme indiqué dans le schéma de câblage.
- Ouvrir Arduino App Lab : Lancez Arduino App Lab et attendez que la carte soit détectée.
- Créer une nouvelle application : Cliquez sur Create New App, nommez-la RainSensorBridge, puis cliquez sur Create.
- Coller le sketch MCU : Copiez le code MCU Bridge ci-dessus et collez-le dans sketch/sketch.ino.
- Coller le code Python : Copiez le code Python Bridge ci-dessus et collez-le dans le fichier Python de l'application.
- Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.
- Search for Arduino_RouterBridge created by Arduino and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Téléverser : Cliquez sur le bouton Run dans Arduino App Lab.
- Ajoutez de l'eau sur le pad du capteur — observez le changement d'état de pluie dans les deux consoles.
Sortie Console d'App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Arduino UNO Q Rain Sensor Bridge ready
[2026-04-29 09:00:05] Rain detected! AO value: 987
[2026-04-29 09:00:08] Rain stopped.
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:02] Rain state: no_rain AO value: 4090
[2026-04-29 09:00:05] Rain state: rain AO value: 987
[2026-04-29 09:00:08] Rain state: no_rain AO value: 4080
Telegram
Recevez des alertes Telegram instantanées lorsque la pluie est détectée par le capteur de pluie Arduino UNO Q.
Sketch MCU : Conservez le même sketch MCU de la section Bridge précédente.
Code Python (Telegram)
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/arduino-uno-q/arduino-uno-q-rain-sensor
*/
from arduino.app_utils import *
import requests
import time
TELEGRAM_BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"
CHAT_ID = "YOUR_CHAT_ID"
last_update_id = 0
def get_updates():
global last_update_id
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/getUpdates"
params = {"offset": last_update_id + 1, "timeout": 5}
try:
response = requests.get(url, params=params, timeout=10)
data = response.json()
if data["ok"]:
return data["result"]
except Exception as e:
print(f"Error getting updates: {e}")
return []
def send_message(chat_id, text):
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
payload = {"chat_id": chat_id, "text": text}
try:
requests.post(url, data=payload, timeout=10)
except Exception as e:
print(f"Error sending message: {e}")
def loop():
# Auto-alert when rain starts
event = Bridge.call("get_event")
if event == "rain_detected":
value = Bridge.call("get_value")
print(f"Rain detected! AO value: {value}")
send_message(CHAT_ID, f"🌧️ Rain detected! Intensity (AO): {value}")
# Telegram commands
updates = get_updates()
for update in updates:
last_update_id = update["update_id"]
if "message" not in update:
continue
message = update["message"]
chat_id = message["chat"]["id"]
text = message.get("text", "").strip()
print(f"Received: {text}")
if text == "/start":
send_message(chat_id,
"Arduino UNO Q Rain Sensor Bot\n"
"/state - Rain detected or not (digital)\n"
"/value - Read analog intensity (0-4095)\n"
"Automatic alert when rain starts")
elif text == "/state":
result = Bridge.call("get_state")
send_message(chat_id, f"Rain state: {result}")
elif text == "/value":
result = Bridge.call("get_value")
send_message(chat_id, f"AO intensity value: {result}")
else:
send_message(chat_id, "Unknown command. Send /start for help.")
time.sleep(0.5)
App.run(user_loop=loop)
Étapes Rapides
- Remplacez YOUR_TELEGRAM_BOT_TOKEN par votre vrai token de bot depuis BotFather.
- Remplacez YOUR_CHAT_ID par votre identifiant de chat Telegram.
- Collez ce code Python dans le fichier Python de votre application (conservez le même sketch MCU).
- Cliquez sur le bouton Run. Ajoutez des gouttes d'eau sur le capteur — recevez l'alerte Telegram instantanément.
Sortie Console d'App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:10:00] Waiting for Telegram messages...
[2026-04-29 09:10:05] Rain detected! AO value: 875
[2026-04-29 09:10:12] Received: /state
Telegram
12:45
Welcome to Telegram!
ArduinoBot
10:19
Chatting with Arduino...
BotFather
Yesterday
Your bot has been created.
ArduinoBot
bot
Intégration d'OpenClaw
Vous pouvez adapter OpenClaw à ce tutoriel en vous référant aux instructions du tutoriel Arduino UNO Q - OpenClaw.
Idées de Projets
Vous pouvez construire de nombreux projets utiles avec le capteur de pluie et Arduino UNO Q :
- Système d'Alerte Pluie : Montez le pad de détection sur un toit — quand la pluie commence, le MPU envoie une alerte Telegram avec la valeur d'intensité AO, vous permettant d'agir (fermer les fenêtres, rentrer le linge) depuis n'importe où
- Contrôleur de Store Automatique : Utilisez le capteur de pluie avec un moteur/relais — quand la pluie est détectée, le MCU ferme automatiquement un store ou un volet via Bridge, et envoie une notification Telegram
- Enregistreur de Précipitations : Enregistrez chaque événement de détection de pluie avec horodatage et intensité AO dans un fichier CSV sur Linux — générez un résumé quotidien des précipitations et envoyez-le à Telegram à minuit
- Inhibiteur d'Irrigation Intelligent : Combinez avec le tutoriel de pompe — si la pluie est détectée, Python ignore le cycle d'irrigation programmé pour économiser l'eau, et envoie un message Telegram expliquant pourquoi
- Moniteur de Jardin sur Toit : Suivez l'intensité de la pluie au fil du temps en utilisant les valeurs AO — Python calcule les précipitations moyennes toutes les 15 minutes et envoie un résumé Telegram périodique
Défiez-Vous
Prêt à aller plus loin avec le capteur de pluie sur Arduino UNO Q ? Essayez ces défis :
- Facile : Classifiez l'intensité AO en Python : si int(value) > 3000 → "sec", > 1500 → "pluie légère", > 500 → "pluie modérée", sinon "pluie forte" — incluez cette étiquette dans chaque alerte Telegram.
- Moyen : Implémentez un suivi de la durée de pluie : enregistrez l'heure de début lorsque la pluie est détectée et l'heure de fin lorsqu'elle s'arrête — envoyez un message Telegram quand la pluie s'arrête indiquant combien de temps elle a duré.
- Avancé : Construisez un graphique de précipitations sur 24 heures : enregistrez les valeurs AO chaque minute dans une liste en Python — implémentez une commande Telegram /chart qui envoie un graphique en barres textuel de l'intensité des précipitations par heure sur les dernières 24 heures.