Station météo Arduino : DHT22, BMP280, capteur de pluie et LCD
Fabriquer une station météo Arduino : DHT22 pour température et humidité, BMP280 pour la pression, capteur de pluie, LDR, adresses I2C, LCD et carte SD.
Une station météo Arduino est l'un des projets les plus agréables pour apprendre : avec quelques capteurs bon marché, tu mesures la température, l'humidité, la pression atmosphérique et la pluie sur ton balcon ou dans ton jardin et tu les affiches sur un écran. Dans ce guide, tu vas brancher sur un Arduino Uno un DHT22 (température et humidité), un BMP280 (pression), un capteur de pluie et une LDR pour distinguer le jour de la nuit, puis afficher les mesures sur un LCD 16x2 I2C sous forme de pages qui changent toutes les quelques secondes. Avec un module microSD en plus, la station écrit une ligne de journal chaque heure ; après quelques jours, tu peux tracer les données dans Excel.
Le projet ne se limite pas à lire des capteurs : nous allons convertir la pression mesurée en pression au niveau de la mer selon ton altitude pour la comparer aux sites météo, calculer le point de rosée à partir de la température et de l'humidité, et prévoir si le temps va se gâter grâce à la variation de pression des trois dernières heures. Au programme, dans l'ordre : tableaux de câblage et d'adresses I2C, montage pas à pas, code complet, explication des calculs, enregistrement horaire, version Wi-Fi avec l'ESP32, installation des capteurs en extérieur et erreurs fréquentes.

Que mesure une station météo Arduino ?
Chaque capteur a été choisi parce qu'il fait une seule chose mieux que les autres. Le DHT22 fournit la température et l'humidité relative sur une seule ligne de données et il est bien plus précis que le DHT11. Le BMP280 mesure la pression atmosphérique en hectopascals (hPa) à ±1 hPa près ; une variation de pression est le signe le plus fiable d'une pluie qui approche. La plaque du capteur de pluie donne une valeur analogique qui baisse à mesure qu'elle se mouille. La LDR est une simple photorésistance dont la résistance change avec la lumière, ce qui suffit pour distinguer le jour de la nuit. Tout s'affiche sur le LCD I2C ; l'écran et le BMP280 partagent les deux mêmes fils (SDA et SCL).
| Mesure | Capteur | Plage et précision | Branchement |
|---|---|---|---|
| Température et humidité | DHT22 (AM2302) | -40…80 °C ±0,5 °C ; 0–100 % ±2–5 % | Une ligne de données (D2) |
| Pression atmosphérique | BMP280 | 300–1100 hPa, ±1 hPa | I2C (A4, A5) |
| Pluie | Plaque FC-37 / YL-83 et module LM393 | Pourcentage d'humidité de la plaque (calibré dans le code) | Analogique A0, alimentation D7 |
| Jour / nuit | LDR (GL5528) et résistance de 10 kΩ | Niveau de lumière approximatif | Analogique A1 |
| Écran | LCD 16x2 avec module I2C (PCF8574) | 2 lignes × 16 caractères | I2C (A4, A5) |
| Enregistrement (facultatif) | Module carte microSD | FAT32, fichier CSV | SPI (D10–D13) |
Liste du matériel
- Arduino Uno (un Arduino Nano fonctionne avec les mêmes broches)
- Module DHT22 (trois broches, résistance de tirage intégrée) ou DHT22 à quatre pattes et une résistance de 10 kΩ
- Module BMP280 (de préférence la version 5 V avec régulateur) ou un BME280, qui mesure aussi l'humidité
- Plaque du capteur de pluie et module comparateur LM393
- LDR et résistance de 10 kΩ
- LCD 16x2 avec module I2C soudé au dos
- Module microSD avec régulateur et une carte de 32 Go maximum formatée en FAT32 (facultatif)
- Plaque d'essai, fils de connexion et un chargeur USB 5 V d'au moins 1 A





Schéma de câblage : tableau des broches et adresses I2C
L'idée clé du circuit est le bus I2C partagé : le LCD et le BMP280 sont branchés en parallèle sur les mêmes broches SDA (A4) et SCL (A5), et l'Arduino s'adresse à chacun avec une adresse différente. Le module SD utilise le bus SPI (D10–D13) et n'entre donc pas en conflit avec l'I2C. Le VCC du module de pluie n'est pas relié directement au 5V mais à D7 : le code n'alimente la plaque que quelques millisecondes pendant la mesure, ce qui freine fortement la corrosion. Nous expliquons le fonctionnement du bus I2C dans Qu'est-ce que l'I2C ?.
| Composant et broche | Arduino Uno | ESP32 (version Wi-Fi) |
|---|---|---|
| DHT22 VCC / GND | 5V / GND | 3V3 / GND |
| DHT22 DATA | D2 | GPIO 4 |
| BMP280 VCC | 3.3V (6 broches) ou 5V (avec régulateur) | 3V3 |
| BMP280 SDA / SCL | A4 / A5 | GPIO 21 / GPIO 22 |
| Module I2C du LCD VCC / SDA / SCL | 5V / A4 / A5 | Non utilisé (page web) |
| VCC du module de pluie | D7 (seulement pendant la mesure) | GPIO 25 |
| AO du module de pluie | A0 | GPIO 34 (ADC1) |
| Pont diviseur LDR et 10 kΩ | LDR au 5V, 10 kΩ au GND, point milieu sur A1 | LDR au 3V3, 10 kΩ au GND, point milieu sur GPIO 35 |
| Module SD CS / MOSI / MISO / SCK | D10 / D11 / D12 / D13 | Non utilisé |
| VCC du module SD | 5V | — |
| Périphérique I2C | Adresse par défaut | Remarque |
|---|---|---|
| Module I2C du LCD (PCF8574T) | 0x27 | 0x20–0x27 avec les ponts de soudure |
| Module I2C du LCD (PCF8574AT) | 0x3F | 0x38–0x3F avec les ponts de soudure |
| BMP280 (modules violets) | 0x76 | 0x77 si la broche SDO est reliée au 3,3 V |
| BMP280 (carte Adafruit) | 0x77 | 0x76 si SDO est reliée au GND |
| BME280 (à la place du BMP280) | 0x76 ou 0x77 | Chip ID 0x60 ; celui du BMP280 est 0x58 |
| RTC DS3231 / DS1307 (facultatif) | 0x68 | L'EEPROM du module DS3231 est en 0x57 |
Installer les bibliothèques
- Ouvre le gestionnaire de bibliothèques de l'IDE Arduino et installe LiquidCrystal I2C (Frank de Brabander).
- Cherche Adafruit BMP280 Library ; quand l'IDE propose les dépendances, choisis Install all pour installer aussi Adafruit Unified Sensor et Adafruit BusIO.
- Installe DHT sensor library (Adafruit).
- Les bibliothèques SD et SPI sont fournies avec l'IDE Arduino, inutile de les installer. Les détails d'installation sont dans ajouter une bibliothèque Arduino.
Montage pas à pas
- Monte d'abord le bus I2C : branche le LCD et le BMP280 sur A4 et A5, lance le scanner I2C et note les deux adresses.
- Ajoute le DHT22 : relie la broche de données à D2. Avec le capteur nu à quatre pattes, place une résistance de tirage de 10 kΩ entre données et VCC.
- Branche le capteur de pluie : relie la plaque au module, le VCC du module à D7 et AO à A0. Mesure les valeurs plaque sèche et plaque mouillée, puis écris-les dans les constantes RAIN_DRY et RAIN_WET du code.
- Monte le pont diviseur de la LDR : une patte de la LDR au 5V, l'autre sur A1, et une résistance de 10 kΩ de A1 au GND. Plus il fait clair, plus la lecture monte.
- Ajoute le module SD : alimente-le en 5V et relie CS à D10, MOSI à D11, MISO à D12 et SCK à D13. Sans carte, la station continue de fonctionner sans enregistrement.
- Indique ton altitude : cherche l'altitude de ton lieu au-dessus du niveau de la mer et écris-la dans la constante ALTITUDE_M ; la précision du calcul de pression en dépend.
Code de la station météo : pages tournantes et enregistrement horaire sur SD
Le code ci-dessous rassemble toutes les pièces. Les capteurs sont lus toutes les 5 secondes, l'écran alterne entre trois pages toutes les 4 secondes et, si une carte SD est présente, une ligne est enregistrée au démarrage puis toutes les heures. Comme il utilise millis() au lieu de delay(), les trois tâches ne s'attendent pas. Les textes de l'écran sont de courtes abréviations anglaises : T température, H humidité, Dew pt point de rosée et P pression.
1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include <Adafruit_BMP280.h>
4#include <DHT.h>
5#include <SPI.h>
6#include <SD.h>
7
8// Pinler / pins
9const byte DHT_PIN = 2; // DHT22 veri / DHT22 data
10const byte RAIN_POWER_PIN = 7; // yağmur modülü VCC / rain module VCC
11const byte RAIN_PIN = A0; // yağmur modülü AO / rain module AO
12const byte LDR_PIN = A1; // LDR bölücü orta noktası / LDR divider midpoint
13const byte SD_CS_PIN = 10; // SD modülü CS / SD module CS
14
15// Kendi değerlerinle değiştir / replace with your own values
16const float ALTITUDE_M = 850.0; // rakım, metre / altitude in metres
17const int RAIN_DRY = 1015; // kuru pano okuması / dry board reading
18const int RAIN_WET = 350; // ıslak pano okuması / wet board reading
19const byte RAIN_ON = 25; // % ve üstü: yağıyor / % and above: raining
20const byte RAIN_OFF = 10; // % ve altı: kurudu / % and below: dry
21const int DAY_LEVEL = 450; // LDR bu değerin üstünde: gündüz / above: day
22const int NIGHT_LEVEL = 350; // LDR bu değerin altında: gece / below: night
23
24const unsigned long READ_MS = 5000UL; // sensör okuma aralığı / sensor read interval
25const unsigned long PAGE_MS = 4000UL; // sayfa süresi / page duration
26const unsigned long LOG_MS = 3600000UL; // saatte bir kayıt / log once an hour
27
28LiquidCrystal_I2C lcd(0x27, 16, 2); // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
29Adafruit_BMP280 bmp;
30DHT dht(DHT_PIN, DHT22);
31
32float temperature = NAN, humidity = NAN, pressure = NAN, dewPoint = NAN;
33float history[4] = {NAN, NAN, NAN, NAN}; // saatlik basınç geçmişi / hourly pressure history
34int rainPercent = 0, light = 0;
35bool raining = false, isDay = true, bmpOk = false, sdOk = false, firstLog = true;
36byte page = 0;
37unsigned long lastRead = 0, lastPage = 0, lastLog = 0;
38
39float calcDewPoint(float t, float rh) { // Magnus formülü / Magnus formula
40 const float a = 17.62, b = 243.12;
41 float g = log(rh / 100.0) + a * t / (b + t);
42 return b * g / (a - g);
43}
44
45int readRain() {
46 digitalWrite(RAIN_POWER_PIN, HIGH); // panoyu yalnız ölçerken besle / power the board only while measuring
47 delay(20);
48 long sum = 0;
49 for (byte i = 0; i < 4; i++) sum += analogRead(RAIN_PIN);
50 digitalWrite(RAIN_POWER_PIN, LOW); // korozyonu yavaşlatır / slows corrosion
51 return constrain(map(sum / 4, RAIN_DRY, RAIN_WET, 0, 100), 0, 100);
52}
53
54void readSensors() {
55 float t = dht.readTemperature();
56 float h = dht.readHumidity();
57 if (!isnan(t) && !isnan(h)) { // hatalı okumada eski değer kalır / keep the old value on a failed read
58 temperature = t;
59 humidity = h;
60 dewPoint = calcDewPoint(t, h);
61 }
62 if (bmpOk && bmp.takeForcedMeasurement()) { // tek ölçüm, az ısınma / one-shot, less self-heating
63 pressure = bmp.seaLevelForAltitude(ALTITUDE_M, bmp.readPressure() / 100.0); // deniz seviyesi, hPa / sea level, hPa
64 }
65 rainPercent = readRain();
66 if (!raining && rainPercent >= RAIN_ON) raining = true; // histerezis / hysteresis
67 if (raining && rainPercent <= RAIN_OFF) raining = false;
68 light = analogRead(LDR_PIN);
69 if (!isDay && light >= DAY_LEVEL) isDay = true;
70 if (isDay && light <= NIGHT_LEVEL) isDay = false;
71}
72
73float trend3h() { // son 3 saatteki basınç değişimi / pressure change over 3 hours
74 if (isnan(history[0]) || isnan(history[3])) return NAN;
75 return history[3] - history[0];
76}
77
78void showPage() {
79 lcd.clear();
80 if (page == 0) { // sıcaklık, nem, çiy noktası / temperature, humidity, dew point
81 lcd.print(F("T "));
82 lcd.print(temperature, 1);
83 lcd.print((char)223); // derece işareti / degree sign
84 lcd.print(F("C H "));
85 lcd.print(humidity, 0);
86 lcd.print('%');
87 lcd.setCursor(0, 1);
88 lcd.print(F("Dew pt "));
89 lcd.print(dewPoint, 1);
90 lcd.print((char)223);
91 lcd.print('C');
92 } else if (page == 1) { // basınç ve eğilim / pressure and trend
93 lcd.print(F("P "));
94 lcd.print(pressure, 1);
95 lcd.print(F(" hPa"));
96 lcd.setCursor(0, 1);
97 float tr = trend3h();
98 if (isnan(tr)) {
99 lcd.print(F("3h trend: wait")); // ilk 3 saat / first 3 hours
100 } else {
101 lcd.print(F("3h "));
102 if (tr > 0) lcd.print('+');
103 lcd.print(tr, 1);
104 if (tr <= -1.6) lcd.print(F(" Falling"));
105 else if (tr >= 1.6) lcd.print(F(" Rising"));
106 else lcd.print(F(" Steady"));
107 }
108 } else { // yağmur, ışık, SD durumu / rain, light, SD status
109 lcd.print(F("Rain "));
110 lcd.print(rainPercent);
111 lcd.print(raining ? F("% RAIN") : F("% dry"));
112 lcd.setCursor(0, 1);
113 lcd.print(isDay ? F("Day ") : F("Night"));
114 lcd.print(sdOk ? F(" SD:ok") : F(" SD:off"));
115 }
116}
117
118void logHourly() {
119 for (byte i = 0; i < 3; i++) history[i] = history[i + 1]; // geçmişi kaydır / shift the history
120 history[3] = pressure;
121 if (!sdOk) return;
122 File f = SD.open("WEATHER.CSV", FILE_WRITE); // sona ekler / appends
123 if (!f) {
124 sdOk = false;
125 return;
126 }
127 f.print(millis() / 60000UL); // açılıştan beri dakika / minutes since power-up
128 f.print(',');
129 f.print(temperature, 1);
130 f.print(',');
131 f.print(humidity, 0);
132 f.print(',');
133 f.print(pressure, 1);
134 f.print(',');
135 f.print(dewPoint, 1);
136 f.print(',');
137 f.print(rainPercent);
138 f.print(',');
139 f.println(isDay ? F("day") : F("night"));
140 f.close(); // elektrik kesilirse veri kaybolmasın / safe against power loss
141}
142
143void setup() {
144 pinMode(RAIN_POWER_PIN, OUTPUT);
145 lcd.init();
146 lcd.backlight();
147 lcd.print(F("Weather station"));
148 dht.begin();
149 bmpOk = bmp.begin(0x76); // mor modül 0x76, Adafruit 0x77 / purple module 0x76, Adafruit 0x77
150 if (bmpOk) {
151 bmp.setSampling(Adafruit_BMP280::MODE_FORCED, Adafruit_BMP280::SAMPLING_X1,
152 Adafruit_BMP280::SAMPLING_X1, Adafruit_BMP280::FILTER_OFF); // hava izleme ayarı / weather monitoring
153 }
154 sdOk = SD.begin(SD_CS_PIN);
155 if (sdOk && !SD.exists("WEATHER.CSV")) {
156 File f = SD.open("WEATHER.CSV", FILE_WRITE);
157 if (f) {
158 f.println(F("minutes,temp_c,hum_pct,press_hpa,dew_c,rain_pct,light")); // başlık satırı / header row
159 f.close();
160 }
161 }
162 lcd.setCursor(0, 1);
163 lcd.print(bmpOk ? F("BMP280 ok") : F("BMP280 ?"));
164 delay(2000); // DHT22 ilk ölçüme hazırlansın / let the DHT22 get ready
165}
166
167void loop() {
168 unsigned long now = millis();
169 if (lastRead == 0 || now - lastRead >= READ_MS) {
170 lastRead = now;
171 readSensors();
172 }
173 if (firstLog || now - lastLog >= LOG_MS) { // açılışta ve her saat / at power-up and every hour
174 firstLog = false;
175 lastLog = now;
176 logHourly();
177 }
178 if (now - lastPage >= PAGE_MS) {
179 lastPage = now;
180 showPage();
181 page = (page + 1) % 3; // 3 sayfa arasında dön / cycle through 3 pages
182 }
183}| Constante ou fonction | Rôle |
|---|---|
| ALTITUDE_M | Altitude ; sert à ramener la pression mesurée au niveau de la mer |
| RAIN_DRY / RAIN_WET | Les valeurs analogiques que tu as mesurées plaque sèche et mouillée |
| RAIN_ON / RAIN_OFF | Seuils (%) de début et de fin de pluie ; l'écart entre les deux est l'hystérésis |
| DAY_LEVEL / NIGHT_LEVEL | Seuils jour et nuit de la LDR ; la zone intermédiaire évite les basculements à l'aube |
| readRain() | Alimente la plaque par D7, fait la moyenne de 4 lectures, coupe l'alimentation et convertit en pourcentage |
| calcDewPoint() | Calcule le point de rosée avec la formule de Magnus |
| takeForcedMeasurement() | Demande une mesure unique au BMP280 ; évite l'échauffement du mode continu |
| history[4] et trend3h() | Gardent la pression de chaque heure et donnent la variation sur 3 heures |
| logHourly() | Décale l'historique de pression et ajoute une ligne CSV sur la carte SD |
Les calculs : pression au niveau de la mer, point de rosée et tendance barométrique
Ce que mesure le BMP280, c'est la pression locale à l'endroit où tu te trouves, et elle baisse avec l'altitude : une pression d'environ 1013 hPa au niveau de la mer tombe à environ 915 hPa à 850 mètres, et à Clermont-Ferrand, vers 400 mètres, elle tourne autour de 965 hPa. Les sites météo, eux, donnent la pression de chaque station ramenée au niveau de la mer. C'est la fonction seaLevelForAltitude() du code qui fait cette conversion : P0 = P / (1 − h / 44330)^5,255. Pour 915 hPa mesurés à 850 mètres, 1 − 850 / 44330 = 0,9808 et 0,9808^5,255 ≈ 0,903 ; 915 / 0,903 ≈ 1013 hPa. Une erreur de 10 mètres sur l'altitude décale le résultat d'environ 1,2 hPa, alors prends l'altitude sur une carte ou un GPS aussi précisément que possible.
Le point de rosée est la température à laquelle l'air commence à se condenser quand il se refroidit, et c'est un indicateur de confort plus parlant que l'humidité relative : jusqu'à 13 °C l'air paraît agréable, au-dessus de 16 °C humide et au-dessus de 20 °C étouffant. Le code utilise la formule de Magnus : γ = ln(HR / 100) + 17,62·T / (243,12 + T) et Td = 243,12·γ / (17,62 − γ). Pour 24 °C et 50 % d'humidité, on obtient γ ≈ 0,890 et Td ≈ 12,9 °C. Si la température nocturne s'approche du point de rosée, attends-toi à du brouillard ou de la rosée au matin ; si le point de rosée est sous 0 °C, il se forme du givre au lieu de la rosée, un bon déclencheur pour une alarme de gel.
L'outil de prévision le plus utile reste la tendance barométrique : la variation sur 3 heures en dit bien plus que la pression elle-même. Le code range la pression dans un tableau toutes les heures ; dès qu'il a quatre valeurs, c'est-à-dire 3 heures après la mise sous tension, il affiche l'écart entre la dernière valeur et celle d'il y a 3 heures, et écrit Falling pour une baisse de plus de 1,6 hPa ou Rising pour une hausse. La classification utilisée en météorologie est la suivante.
| Variation de pression sur 3 heures | Classe | Ce que cela signifie en général |
|---|---|---|
| Moins de 0,1 hPa | Stable | Le temps actuel se maintient |
| 0,1–1,5 hPa | Hausse / baisse lente | Petit changement ; en baisse, le ciel peut se couvrir |
| 1,6–3,5 hPa | Hausse / baisse | En baisse, le risque de pluie augmente ; en hausse, le ciel se dégage |
| 3,6–6 hPa | Hausse / baisse rapide | En baisse, un temps venteux et pluvieux arrive |
| Plus de 6 hPa | Très rapide | Tempête ; changement de temps très brutal |
Enregistrement horaire sur carte SD et graphiques dans Excel
Si une carte SD est présente, la station crée le fichier WEATHER.CSV à la racine, écrit les en-têtes de colonnes sur la première ligne puis ajoute une ligne chaque heure. La bibliothèque SD d'Arduino n'accepte que des noms de fichier au format 8+3, d'où ce nom court. Fermer le fichier après chaque enregistrement fait qu'une coupure de courant ne perd au pire que la dernière ligne. L'Uno n'ayant pas d'horloge réelle, la première colonne indique les minutes écoulées depuis la mise sous tension ; pour avoir la date et l'heure, ajoute un module RTC et prends l'horodatage sur lui. Pour choisir et formater la carte, vois l'article sur le module carte SD.
| minutes | temp_c | hum_pct | press_hpa | dew_c | rain_pct | light |
|---|---|---|---|---|---|---|
| 0 | 21.4 | 58 | 1016.2 | 12.8 | 0 | day |
| 60 | 20.8 | 61 | 1015.1 | 13.0 | 0 | day |
| 120 | 18.9 | 72 | 1013.4 | 13.7 | 34 | night |
Dans l'exemple ci-dessus, la pression a baissé de 2,8 hPa en deux heures et la pluie a commencé au troisième enregistrement : voilà comment la tendance annonce la pluie. Ouvre le fichier sur ton ordinateur avec Excel ou Google Sheets et trace les colonnes de pression et de température en courbes. Un Excel en français attend une virgule comme séparateur décimal, si bien que des valeurs comme 1016.2 peuvent s'afficher en texte ou en date ; à l'importation, règle les paramètres régionaux de la colonne sur Anglais (États-Unis). La méthode complète est dans envoyer des données Arduino vers Excel.
Station météo Wi-Fi avec l'ESP32
Pour voir les mesures sur ton téléphone, tu peux brancher les mêmes capteurs sur un ESP32. Dans cette version, le LCD est remplacé par une page web servie par l'ESP32 lui-même : ouvre sur un téléphone connecté au même réseau Wi-Fi l'adresse IP affichée dans le moniteur série et les valeurs apparaissent ; la page se rafraîchit toute seule toutes les 30 secondes. L'adresse /json renvoie les mêmes données dans un format lisible par d'autres programmes. Les broches de l'ESP32 fonctionnent en 3,3 V : alimente les capteurs en 3V3 et utilise pour les entrées analogiques les broches ADC1 (GPIO 32–39), qui marchent même Wi-Fi actif. L'ADC de l'ESP32 est sur 12 bits et lit de 0 à 4095 : il faut donc mesurer à nouveau les seuils de pluie.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Wire.h>
4#include <Adafruit_BMP280.h>
5#include <DHT.h>
6
7const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
8const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
9
10const int DHT_PIN = 4; // DHT22 veri / DHT22 data
11const int RAIN_POWER_PIN = 25; // yağmur modülü VCC / rain module VCC
12const int RAIN_PIN = 34; // yağmur AO, ADC1 / rain AO, ADC1
13const int LDR_PIN = 35; // LDR bölücü, ADC1 / LDR divider, ADC1
14const float ALTITUDE_M = 850.0; // rakım, metre / altitude in metres
15const int RAIN_DRY = 4095; // 12 bit: kuru pano / 12-bit: dry board
16const int RAIN_WET = 1400; // kendi ıslak ölçümün / your own wet reading
17
18WebServer server(80);
19Adafruit_BMP280 bmp;
20DHT dht(DHT_PIN, DHT22);
21float temperature = NAN, humidity = NAN, pressure = NAN;
22int rainPercent = 0, lightPercent = 0;
23unsigned long lastRead = 0;
24
25String num(float v, int digits) { // okunamayan değer için null / null for a missing value
26 return isnan(v) ? String("null") : String(v, digits);
27}
28
29void readSensors() {
30 float t = dht.readTemperature();
31 float h = dht.readHumidity();
32 if (!isnan(t) && !isnan(h)) {
33 temperature = t;
34 humidity = h;
35 }
36 if (bmp.takeForcedMeasurement()) {
37 pressure = bmp.seaLevelForAltitude(ALTITUDE_M, bmp.readPressure() / 100.0);
38 }
39 digitalWrite(RAIN_POWER_PIN, HIGH); // yalnız ölçerken besle / power only while measuring
40 delay(20);
41 int raw = analogRead(RAIN_PIN);
42 digitalWrite(RAIN_POWER_PIN, LOW);
43 rainPercent = constrain(map(raw, RAIN_DRY, RAIN_WET, 0, 100), 0, 100);
44 lightPercent = map(analogRead(LDR_PIN), 0, 4095, 0, 100);
45}
46
47void handleRoot() {
48 String html = "<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width,initial-scale=1'>"
49 "<meta http-equiv='refresh' content='30'><title>Weather</title></head>"
50 "<body style='font-family:sans-serif;font-size:1.3em;padding:1em'><h2>Weather station</h2>";
51 html += "<p>Temp: " + num(temperature, 1) + " °C</p>";
52 html += "<p>Humidity: " + num(humidity, 0) + " %</p>";
53 html += "<p>Pressure: " + num(pressure, 1) + " hPa</p>";
54 html += "<p>Rain: " + String(rainPercent) + " %</p>";
55 html += "<p>Light: " + String(lightPercent) + " %</p></body></html>";
56 server.send(200, "text/html", html);
57}
58
59void handleJson() { // başka programlar için / for other programs
60 String json = "{\"temp\":" + num(temperature, 1) + ",\"hum\":" + num(humidity, 0) +
61 ",\"press\":" + num(pressure, 1) + ",\"rain\":" + String(rainPercent) +
62 ",\"light\":" + String(lightPercent) + "}";
63 server.send(200, "application/json", json);
64}
65
66void setup() {
67 Serial.begin(115200);
68 pinMode(RAIN_POWER_PIN, OUTPUT);
69 dht.begin();
70 if (!bmp.begin(0x76)) Serial.println(F("BMP280 yok / not found"));
71 bmp.setSampling(Adafruit_BMP280::MODE_FORCED, Adafruit_BMP280::SAMPLING_X1,
72 Adafruit_BMP280::SAMPLING_X1, Adafruit_BMP280::FILTER_OFF);
73 WiFi.begin(ssid, password);
74 while (WiFi.status() != WL_CONNECTED) delay(300);
75 Serial.print(F("IP: "));
76 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this address on your phone
77 server.on("/", handleRoot);
78 server.on("/json", handleJson);
79 server.begin();
80}
81
82void loop() {
83 server.handleClient();
84 if (lastRead == 0 || millis() - lastRead >= 5000) { // 5 sn'de bir oku / read every 5 s
85 lastRead = millis();
86 readSensors();
87 }
88}Pour consulter les données de n'importe où, les enregistrer dans Google Sheets ou comparer tes mesures aux prévisions en ligne, vois ESP32 et Google Sheets et API météo avec l'ESP32. Le code compile sans modification avec les versions 2.x et 3.x du core ESP32, car il n'utilise que des fonctions WiFi et WebServer identiques dans les deux.
Bien placer les capteurs
- Mets le capteur de température à l'ombre : un DHT22 au soleil peut afficher 5–10 °C de plus que la vraie température de l'air. Place-le dans une boîte blanche ventilée ou dans un abri anti-rayonnement fait d'assiettes en plastique empilées.
- Éloigne-le des murs : les murs et les encadrements de fenêtre chauffés par le soleil faussent la mesure vers le haut ; installe le capteur à au moins 30 cm du mur et, si possible, à 1,5–2 m du sol.
- Laisse l'électronique à l'intérieur : l'Arduino, le LCD et le BMP280 peuvent rester dans un boîtier fermé, car la pression y est la même. Seuls le DHT22, la plaque de pluie et la LDR doivent être dehors.
- Incline la plaque de pluie : pose-la avec 30–45 degrés d'inclinaison pour que l'eau s'écoule quand la pluie s'arrête ; une plaque à plat reste mouillée pendant des heures.
- Oriente la LDR vers le ciel : si un lampadaire ou la lampe du balcon l'éclaire, la station croit qu'il fait jour ; place-la loin des lampes, tournée vers le haut.
- Surveille la longueur des câbles : le DHT22 fonctionne bien avec quelques mètres de câble ; si des erreurs de lecture apparaissent au-delà de 10 mètres, baisse la résistance de tirage à 4,7 kΩ. Le bus I2C n'est prévu que pour quelques dizaines de centimètres, garde donc le BMP280 près de l'Arduino.
Faire évoluer la station : idées de projets
- Intensité lumineuse : remplace la LDR par un BH1750, qui mesure en lux, et calcule la durée d'ensoleillement.
- Qualité de l'air : ajoute un capteur de CO2 MH-Z19 à une station d'intérieur ou un capteur de particules PMS5003 à une station d'extérieur.
- Horodatage réel : avec un module RTC, écris la date et l'heure dans le journal et enregistre chaque nuit à minuit le maximum et le minimum de la journée.
- Alerte gel et serre : monte une alarme de gel qui fait sonner un buzzer sous 2 °C ou une serre connectée qui gère l'aération.
- Énergie solaire : avec un petit panneau, un module de charge TP4056 et un accu 18650, la station se passe de prise ; dans la version ESP32, le deep sleep fait durer la batterie des semaines.
- Vent et cumul de pluie : compte la vitesse du vent avec un anémomètre à interrupteur reed et la pluie en millimètres avec un pluviomètre à augets basculants.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Le LCD n'affiche que des pavés pleins | Contraste mal réglé ou mauvaise adresse I2C | Tourne le potentiomètre bleu au dos du module et essaie 0x3F au lieu de 0x27 |
| L'écran affiche nan | Le DHT22 ne répond pas : câblage, résistance de tirage ou lectures plus fréquentes que toutes les 2 secondes | Vérifie le fil de données et la résistance de 10 kΩ ; le code garde l'ancienne valeur en cas d'échec |
| La pression vaut nan ou ne bouge jamais | BMP280 introuvable : adresse 0x77 ou module 3,3 V mal alimenté | Essaie begin(0x77) et alimente le module à la bonne tension |
| La pression est 80–100 hPa sous celle de la météo | Altitude non renseignée, la pression locale est affichée | Mets à jour ALTITUDE_M avec ton altitude réelle |
| Température beaucoup trop haute en journée | Le capteur est au soleil ou chauffe dans le boîtier | Utilise un abri ombragé et ventilé |
| Pourcentage de pluie élevé même par temps sec | Plaque sale, couverte de rosée ou mal calibrée | Nettoie la plaque, mesure à nouveau RAIN_DRY et relève le seuil RAIN_ON |
| L'écran indique SD:off | Pas de carte, carte en exFAT ou module alimenté en 3,3 V | Formate une carte de 32 Go maximum en FAT32 et branche le module sur le 5V |
| À l'aube, l'affichage hésite entre Day et Night | Les seuils sont trop proches | Laisse au moins 100 points d'écart entre DAY_LEVEL et NIGHT_LEVEL |
Cette station réunit presque tout ce que tu as appris sur Arduino : lectures numériques et analogiques, bus I2C et SPI, multitâche avec millis, calculs et enregistrement de données. Fais d'abord fonctionner chaque capteur seul, assemble ensuite les éléments et mets le tout en boîtier en dernier. Dans l'application BlueGrays, tu trouveras la mesure de température et d'humidité avec un DHT11, la lecture de la lumière avec une LDR, la mesure avec ESP32 et DHT22 sur LCD, un enregistreur de température sur carte SD et une station météo à afficheur matriciel, chacun avec schémas pas à pas et code prêt à l'emploi.
Questions fréquentes
Comment faire une station météo avec Arduino ?
Tu branches sur un Arduino Uno un DHT22 pour la température et l'humidité, un BMP280 pour la pression, un capteur de pluie et une LDR pour la lumière ; tu affiches les valeurs sur un LCD I2C et, si tu veux, tu les enregistres sur une carte SD. Teste d'abord chaque capteur séparément, puis réunis-les dans un seul programme. Placer les capteurs à l'ombre dans un abri ventilé est la condition la plus importante pour des mesures justes.
DHT22 ou BME280 : lequel choisir pour une station météo ?
Le DHT22 est un peu plus précis en température (±0,5 °C) mais ne se lit qu'une fois toutes les 2 secondes ; le BME280 réunit température, humidité et pression dans une seule puce I2C. Pour avoir moins de fils et de broches, un BME280 seul suffit. Ce projet utilise les deux, car le DHT22 est dehors alors que le BMP280 peut rester dans le boîtier.
Pourquoi la pression du BMP280 est-elle plus basse que celle de la météo ?
Le capteur mesure la pression locale à ton altitude, alors que les sites météo donnent la pression ramenée au niveau de la mer. La pression baisse d'environ 12 hPa tous les 100 mètres. Si tu indiques ton altitude dans la constante ALTITUDE_M, seaLevelForAltitude() rend la valeur comparable.
Une station météo Arduino peut-elle prévoir la pluie ?
Elle ne donne pas de prévision exacte, mais la tendance barométrique est un bon indice : une baisse de plus de 1,6 hPa en 3 heures annonce souvent nuages et pluie, une hausse plutôt une éclaircie. Le capteur de pluie détecte en plus le moment où il commence à pleuvoir. Ensemble, ils forment un système d'alerte simple mais utile.
Pourquoi le capteur de pluie s'oxyde-t-il et comment l'éviter ?
Quand les pistes de la plaque sont sous tension en permanence, l'eau provoque une électrolyse et le métal s'use vite. Relier le VCC du module à une broche numérique et n'alimenter la plaque que pendant la mesure multiplie sa durée de vie. L'installer inclinée pour qu'elle sèche vite après la pluie ralentit aussi la corrosion.
Combien de temps une station météo Arduino tient-elle sur batterie ?
Un Arduino Uno avec le rétroéclairage du LCD et les capteurs consomme environ 70–90 mA ; une batterie externe de 2000 mAh le fait tourner environ une journée. Couper le rétroéclairage allonge cette durée, mais pour une longue autonomie un ESP32 en deep sleep est bien plus adapté. Tu peux estimer l'autonomie de ton montage avec le calculateur d'autonomie de batterie.
Projets à réaliser après cet article
Voir tous les projets
Température et humidité avec DHT11
Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

Mesurer l'intensité lumineuse avec une LDR
Envie de voir en chiffres à quel point ta chambre est lumineuse ? Le LDR, une petite pièce sensible à la lumière, mesure la lumière ambiante, et l'Arduino écrit la valeur sur l'écran de ton…

Horloge matricielle, calendrier et station météo (MAX7219, DS1307)
Un panneau à texte défilant pour ton bureau ou ton mur, qui affiche tour à tour l'heure, la date et la météo de la pièce.

ESP32 DHT22 Température et humidité (avec écran LCD)
Il s'agit d'un projet permettant de mesurer la température ambiante et le taux d'humidité à l'aide d'un capteur DHT22 et d'afficher ces données en temps réel sur un écran LCD I2C 16x2. Les données du capteur sont lues à l'aide du protocole one-wire grâce à la bibliothèque Adafruit DHT. Ce projet constitue la base des stations météo IoT, de la domotique ou des systèmes de surveillance de l'environnement dans les serres.

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.

ESP32 HTTPClient + API météo (avec écran LCD)
L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. La réponse JSON est analysée avec ArduinoJson v7, puis la ville, la température, l'humidité, la météo et le vent s'affichent sur un LCD I2C. wttr.in ne demande aucune clé d'API : il suffit de taper le nom de n'importe quelle ville.

Mesure de la température avec NTC et écran LCD 2x16
Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

Utilisation de l'écran LCD avec I2C
Offre un écran à ton Arduino et fais-lui écrire son premier message. L'écran LCD à deux lignes se branche avec seulement quelques fils ; un bonjour s'affiche sur la ligne du haut, puis un deuxième…
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

