Guides · 12 min de lecture

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.

Capteur de température et d'humidité DHT22
DHT22 (AM2302) : mesure la température de -40 à 80 °C à ±0,5 °C près ainsi que l'humidité ; c'est le capteur principal de la station.

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).

MesureCapteurPlage et précisionBranchement
Température et humiditéDHT22 (AM2302)-40…80 °C ±0,5 °C ; 0–100 % ±2–5 %Une ligne de données (D2)
Pression atmosphériqueBMP280300–1100 hPa, ±1 hPaI2C (A4, A5)
PluiePlaque FC-37 / YL-83 et module LM393Pourcentage d'humidité de la plaque (calibré dans le code)Analogique A0, alimentation D7
Jour / nuitLDR (GL5528) et résistance de 10 kΩNiveau de lumière approximatifAnalogique A1
ÉcranLCD 16x2 avec module I2C (PCF8574)2 lignes × 16 caractèresI2C (A4, A5)
Enregistrement (facultatif)Module carte microSDFAT32, fichier CSVSPI (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
BMP280
BMP280
Capteur de pluie
Capteur de pluie
LDR
LDR
I2C 16x2 LCD
I2C 16x2 LCD
Module carte MicroSD
Module carte MicroSD

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 brocheArduino UnoESP32 (version Wi-Fi)
DHT22 VCC / GND5V / GND3V3 / GND
DHT22 DATAD2GPIO 4
BMP280 VCC3.3V (6 broches) ou 5V (avec régulateur)3V3
BMP280 SDA / SCLA4 / A5GPIO 21 / GPIO 22
Module I2C du LCD VCC / SDA / SCL5V / A4 / A5Non utilisé (page web)
VCC du module de pluieD7 (seulement pendant la mesure)GPIO 25
AO du module de pluieA0GPIO 34 (ADC1)
Pont diviseur LDR et 10 kΩLDR au 5V, 10 kΩ au GND, point milieu sur A1LDR au 3V3, 10 kΩ au GND, point milieu sur GPIO 35
Module SD CS / MOSI / MISO / SCKD10 / D11 / D12 / D13Non utilisé
VCC du module SD5V—
Périphérique I2CAdresse par défautRemarque
Module I2C du LCD (PCF8574T)0x270x20–0x27 avec les ponts de soudure
Module I2C du LCD (PCF8574AT)0x3F0x38–0x3F avec les ponts de soudure
BMP280 (modules violets)0x760x77 si la broche SDO est reliée au 3,3 V
BMP280 (carte Adafruit)0x770x76 si SDO est reliée au GND
BME280 (à la place du BMP280)0x76 ou 0x77Chip ID 0x60 ; celui du BMP280 est 0x58
RTC DS3231 / DS1307 (facultatif)0x68L'EEPROM du module DS3231 est en 0x57
La plupart des modules BMP280 violets à 6 broches n'ont pas de régulateur ; la puce supporte au maximum 3,6 V, alimente-les donc par la broche 3.3V de l'Uno. Les modules à 4 broches avec un petit régulateur peuvent aller sur le 5V. Si tu n'es pas sûr des adresses, lance d'abord le scanner I2C de l'article LCD I2C : tu dois voir deux adresses, par exemple 0x27 et 0x76. Dans la version ESP32, n'alimente jamais le pont diviseur de la LDR en 5V ; les entrées analogiques de l'ESP32 ne supportent pas plus de 3,3 V.

Installer les bibliothèques

  1. Ouvre le gestionnaire de bibliothèques de l'IDE Arduino et installe LiquidCrystal I2C (Frank de Brabander).
  2. Cherche Adafruit BMP280 Library ; quand l'IDE propose les dépendances, choisis Install all pour installer aussi Adafruit Unified Sensor et Adafruit BusIO.
  3. Installe DHT sensor library (Adafruit).
  4. 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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.

C++ (Arduino IDE)
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 fonctionRôle
ALTITUDE_MAltitude ; sert à ramener la pression mesurée au niveau de la mer
RAIN_DRY / RAIN_WETLes valeurs analogiques que tu as mesurées plaque sèche et mouillée
RAIN_ON / RAIN_OFFSeuils (%) de début et de fin de pluie ; l'écart entre les deux est l'hystérésis
DAY_LEVEL / NIGHT_LEVELSeuils 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 heuresClasseCe que cela signifie en général
Moins de 0,1 hPaStableLe temps actuel se maintient
0,1–1,5 hPaHausse / baisse lentePetit changement ; en baisse, le ciel peut se couvrir
1,6–3,5 hPaHausse / baisseEn baisse, le risque de pluie augmente ; en hausse, le ciel se dégage
3,6–6 hPaHausse / baisse rapideEn baisse, un temps venteux et pluvieux arrive
Plus de 6 hPaTrès rapideTempê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.

minutestemp_chum_pctpress_hpadew_crain_pctlight
021.4581016.212.80day
6020.8611015.113.00day
12018.9721013.413.734night

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.

Ce code occupe environ 61 % des 2 Ko de RAM de l'Arduino Uno et 76 % de ses 32 Ko de mémoire programme ; l'essentiel de la RAM part dans le tampon de 512 octets de la bibliothèque SD. Écrire les textes fixes dans F("...") économise de la RAM. Si l'IDE affiche "Low memory available" quand tu ajoutes des fonctions, tu peux désactiver l'enregistrement SD ou passer la station sur un Arduino Mega ou un ESP32, mieux pourvus en mémoire ; détails dans mémoire insuffisante sur Arduino.

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.

C++ (Arduino IDE)
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) + " &deg;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ômeCause probableSolution
Le LCD n'affiche que des pavés pleinsContraste mal réglé ou mauvaise adresse I2CTourne le potentiomètre bleu au dos du module et essaie 0x3F au lieu de 0x27
L'écran affiche nanLe DHT22 ne répond pas : câblage, résistance de tirage ou lectures plus fréquentes que toutes les 2 secondesVé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 jamaisBMP280 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éoAltitude non renseignée, la pression locale est affichéeMets à jour ALTITUDE_M avec ton altitude réelle
Température beaucoup trop haute en journéeLe capteur est au soleil ou chauffe dans le boîtierUtilise un abri ombragé et ventilé
Pourcentage de pluie élevé même par temps secPlaque sale, couverte de rosée ou mal calibréeNettoie la plaque, mesure à nouveau RAIN_DRY et relève le seuil RAIN_ON
L'écran indique SD:offPas de carte, carte en exFAT ou module alimenté en 3,3 VFormate une carte de 32 Go maximum en FAT32 et branche le module sur le 5V
À l'aube, l'affichage hésite entre Day et NightLes seuils sont trop prochesLaisse au moins 100 points d'écart entre DAY_LEVEL et NIGHT_LEVEL
Pour lisser les sauts brusques du journal, tu peux écrire dans chaque ligne horaire la moyenne des 12 dernières mesures plutôt qu'une mesure isolée ; tu trouveras la moyenne glissante et le filtre médian dans filtrer les données d'un capteur.

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.

Voir tous les projets
Température et humidité avec DHT11
AR-55Intermédiaire

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…

4.7(47)
83
Mesurer l'intensité lumineuse avec une LDR
AR-11Débutant

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…

4.6(83)
143
Horloge matricielle, calendrier et station météo (MAX7219, DS1307)
AR-85Intermédiaire
Premium

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.

5.0(50)
66
ESP32 DHT22 Température et humidité (avec écran LCD)
ES-15Intermédiaire

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.

4.8(38)
57
Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avancé
Premium

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.

4.7(7)
12
ESP32 HTTPClient + API météo (avec écran LCD)
ES-31Avancé
Premium

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.

4.7(13)
20
Mesure de la température avec NTC et écran LCD 2x16
AR-44Débutant
Premium

Mesure de la température avec NTC et écran LCD 2x16

Mesure la température ambiante avec un capteur qui ressemble à une petite perle.

4.5(33)
44
Utilisation de l'écran LCD avec I2C
AR-32Débutant
Premium

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…

4.8(53)
70