Composants · 11 min de lecture

Capteur d'humidité du sol capacitif Arduino : calibrage et code

Utiliser le capteur d'humidité du sol capacitif v1.2 avec Arduino : comparé au résistif, TLC555 ou NE555 en 3,3 V, calibrage, tableau des %, ESP32, Pico.

Le capteur d'humidité du sol capacitif mesure l'humidité de la terre d'un pot ou d'un jardin sans qu'aucune électrode métallique ne touche le sol. Il n'a donc pas le défaut des sondes résistives classiques en forme de fourche, qui s'oxydent et lâchent en quelques semaines, et dans un projet d'arrosage automatique avec Arduino il peut tenir des mois, voire des années. Il porte en général l'inscription "Capacitive Soil Moisture Sensor v1.2" ou v2.0, fournit une seule sortie analogique et se branche avec trois fils sur un Arduino Uno, un ESP32 ou un Raspberry Pi Pico.

Ces modules bon marché cachent pourtant des pièges : certaines cartes utilisent le mauvais circuit 555 et ne fonctionnent pas en 3,3 V, sur d'autres il manque la connexion d'une résistance, et les bords découpés absorbent l'eau et font dériver la mesure en quelques semaines. Dans ce guide, tu vas apprendre comment fonctionne le capteur, ce qui le distingue d'un capteur résistif, comment reconnaître une bonne carte, comment le calibrer à sec et dans l'eau et comment convertir la valeur analogique en pourcentage d'humidité. Suivent l'arrosage automatique avec un Uno, un moniteur de plante sur batterie avec un ESP32 et le code MicroPython pour le Pico.

Comment fonctionne un capteur d'humidité du sol capacitif ?

La large zone de cuivre au bout du capteur et la surface de masse qui l'entoure se comportent comme les deux armatures d'un condensateur, et l'isolant entre elles, c'est la terre elle-même. La constante diélectrique de l'eau est d'environ 80, celle de la terre sèche de 3 à 5 et celle de l'air de 1 : plus la terre est humide, plus la capacité augmente. Le circuit 555 en haut de la carte génère un signal carré d'environ 1,5 MHz qui charge et décharge la sonde à travers une résistance, puis une diode et un petit filtre transforment le signal en tension continue. Quand la capacité augmente, l'amplitude du signal sur la sonde diminue : en terre sèche la tension de sortie est haute, en terre humide elle est basse. Comme les électrodes sont recouvertes de vernis épargne, aucun courant ne traverse la terre. Tu peux expérimenter le fonctionnement du 555 avec l'outil minuterie 555.

CaractéristiqueValeur
Alimentation3,3–5,5 V (sur les cartes avec TLC555)
SortieAnalogique, environ 1,2–3,0 V ; haute à sec, basse en milieu humide
ConsommationEnviron 5 mA
ConnecteurPH2.0 à 3 broches : GND, VCC, AOUT
DimensionsEnviron 98 × 23 mm
OscillateurTLC555 (CMOS), environ 1,5 MHz ; NE555 sur les copies
RégulateurXC6206 marqué 662K, 3,3 V
ÉlectrodesCuivre isolé par le vernis épargne ; aucun courant dans la terre

Différence avec le capteur résistif : pas de corrosion

Les capteurs résistifs (YL-69, FC-28) font passer un courant entre deux pointes métalliques nues plantées dans la terre et mesurent sa résistance. Dans une terre humide, ce courant continu provoque une électrolyse : le métal de la pointe positive se dissout, sous alimentation permanente le revêtement disparaît en quelques semaines et la mesure dérive sans cesse. La lecture dépend aussi davantage des sels et de l'engrais que de l'eau : le jour où tu mets de l'engrais, la terre paraît humide. Le capteur capacitif mesure au contraire l'effet diélectrique de l'eau ; il est donc bien moins sensible aux sels, et comme aucun métal n'est exposé il ne s'oxyde pas. Nous avons présenté le capteur résistif dans capteur d'humidité du sol.

Capteur d'humidité du sol résistif YL-69 et module LM393
Capteur résistif YL-69 : les pointes métalliques nues font passer du courant dans la terre et s'usent en quelques semaines sous alimentation permanente.
CaractéristiqueRésistif (YL-69, FC-28)Capacitif v1.2
Principe de mesureRésistance électrique de la terreCapacité (constante diélectrique)
ÉlectrodesMétal nu nickeléCuivre isolé par le vernis épargne
CorrosionEn quelques semaines sous alimentation permanenteAucune (tant que le vernis n'est pas rayé)
Effet de l'engrais et des selsImportantFaible
SortieAO et DO (comparateur LM393)Analogique seulement (AOUT)
Fonctionne en 3,3 VOuiSeulement avec un TLC555
Durée de vieQuelques moisDes années si les bords sont protégés

Versions v1.2 et v2.0 : TLC555, NE555 et le problème du 3,3 V

Le numéro de version imprimé sur la carte n'est pas une garantie ; ce qui compte, c'est l'inscription sur la puce à huit pattes. Les bonnes cartes portent un TLC555 CMOS, qui fonctionne sans souci jusqu'à 2 V. Une partie des copies bon marché utilise au contraire le NE555 classique, qui demande au moins 4,5 V : avec les 3,3 V d'un ESP32 ou d'un Pico, la sortie ne bouge pas ou reste bloquée sur une valeur absurde. Le deuxième point à vérifier est le petit régulateur marqué 662K : s'il manque ou qu'il est ponté, la sortie peut dépasser 3 V avec une alimentation de 5 V. Sur certains lots, la liaison à la masse de la résistance de décharge de 1 MΩ en sortie manque ; sur ces cartes, le passage du sec à l'humide prend plusieurs minutes ou la valeur reste toujours haute. Enfin, la fibre de verre à nu sur les bords découpés absorbe l'eau avec le temps et fait dériver la mesure.

Point à vérifierBonne carteCarte à problèmeSymptôme
Circuit 555TLC555 (CMOS)NE555 ou SA555En 3,3 V la sortie ne bouge pas ou reste figée
RégulateurPetite puce à 3 pattes marquée 662KAbsent ou pontéEn 5 V la sortie peut dépasser 3 V
Résistance de sortie de 1 MΩReliée à la masseLiaison à la masse manquanteRéaction très lente, valeur toujours haute
Bords de la carteProtégés par vernis ou époxyFibre de verre à nuLa mesure dérive en quelques semaines
Les entrées analogiques de l'ESP32 et du Raspberry Pi Pico ne supportent pas plus de 3,3 V. Sur ces cartes, alimente toujours le capteur en 3,3 V. Si tu alimentes en 5 V une carte sans régulateur, la sortie peut dépasser 3,3 V et endommager l'entrée ; en cas de doute, mesure la sortie avec un multimètre avant de la brancher. Si la tension lue avec le capteur à l'air libre est inférieure à 3,3 V, la carte est sans danger.

Branchement : Arduino Uno, ESP32 et Raspberry Pi Pico

Broche du capteurArduino UnoESP32Raspberry Pi Pico
GND (noir)GNDGNDGND
VCC (rouge)5VGPIO 25 (3,3 V seulement pendant la mesure)GP22 (3,3 V seulement pendant la mesure)
AOUT (jaune)A0GPIO 34 (ADC1)GP26 (ADC0)
IN du module relais (pompe de l'exemple Uno)D7——

Dans les exemples ESP32 et Pico, le VCC du capteur n'est pas relié directement à la broche 3V3 mais à un GPIO. Comme le capteur ne consomme que 5 mA, une broche l'alimente sans difficulté ; il est ainsi complètement éteint entre deux mesures et la batterie dure plus longtemps. Sur l'ESP32, utilise pour la lecture analogique les broches ADC1 (GPIO 32 à 39), qui fonctionnent même Wi-Fi actif. Sur l'Uno, le capteur est alimenté en 5V, mais grâce au régulateur de la carte la sortie reste autour de 3 V ; c'est pourquoi l'Uno n'utilise pas toute sa plage de 10 bits, mais environ 250 à 600.

Calibrage : trouver les valeurs à sec et dans l'eau

  1. Téléverse le code Uno ci-dessous sans brancher la pompe et ouvre le moniteur série à 9600 bauds.
  2. Tiens le capteur sec et propre à l'air libre ; après quelques secondes, note la valeur brute stabilisée comme DRY_VALUE (en général 520 à 600 sur l'Uno).
  3. Plonge le capteur dans un verre d'eau sans dépasser la ligne tracée sur la carte et note la mesure comme WET_VALUE (en général 250 à 300).
  4. Pour un résultat plus réaliste, fais une deuxième série : utilise les valeurs dans le terreau complètement sec et dans le même terreau après un arrosage copieux et 30 minutes d'égouttage.
  5. Téléverse de nouveau le code ; le moniteur série affiche maintenant un pourcentage d'humidité de 0 à 100. Chaque capteur donne des valeurs un peu différentes : calibre-les un par un.
Valeur brute (Uno, calibrage d'exemple)HumiditéÉtat de la terreQue faire ?
590 et plus0 %Air ou terre complètement sècheVérifie que le capteur est bien enfoncé
51025 %SècheIl est temps d'arroser la plupart des plantes
43050 %Légèrement humidePlage idéale ; pas besoin d'arroser
35075 %HumideTerre fraîchement arrosée
270 et moins100 %Eau ou boueTrop d'eau ; risque de pourriture des racines

Les pourcentages du tableau sont calculés avec % = (590 − brut) × 100 / (590 − 270) pour DRY_VALUE = 590 et WET_VALUE = 270. Ce n'est pas une mesure de laboratoire mais une valeur relative entre les deux points de calibrage : « 50 % » ne veut pas dire que la moitié du volume de la terre est de l'eau. La réponse du capteur n'est pas parfaitement linéaire non plus, mais elle suffit largement pour décider quand arroser. Le tassement, la température et le type de terre décalent aussi la mesure de quelques points ; après avoir planté le capteur, tasse légèrement la terre autour pour supprimer les poches d'air. Nous détaillons la lecture analogique dans Qu'est-ce qu'un CAN (ADC) ?.

Code Arduino Uno : pourcentage d'humidité et arrosage automatique

Le code ci-dessous lit le capteur 10 fois et en fait la moyenne, convertit la valeur en pourcentage et l'affiche dans le moniteur série. Quand l'humidité passe sous 35 %, l'arrosage démarre et continue jusqu'à ce qu'elle dépasse 60 % ; l'écart entre ces deux seuils (hystérésis) évite que la pompe s'allume et s'éteigne sans arrêt. L'arrosage ne se fait pas d'un coup mais par doses de 4 secondes, avec une attente d'une minute après chaque dose pour laisser l'eau se répartir dans la terre. Comme le capteur ne détecte l'eau qu'avec quelques secondes de retard, faire tourner la pompe en continu ferait déborder le pot.

C++ (Arduino IDE)
1const byte SENSOR_PIN = A0;          // sensör AOUT / sensor AOUT
2const byte PUMP_PIN = 7;             // röle IN (pompa) / relay IN (pump)
3const byte RELAY_ON = HIGH;          // röle LOW ile çekiyorsa LOW yap / use LOW for active-low relays
4const int DRY_VALUE = 590;           // kuru: havada ya da kuru toprakta / dry: in air or dry soil
5const int WET_VALUE = 270;           // ıslak: suda ya da yeni sulanmış toprakta / wet: in water or just-watered soil
6const byte START_PCT = 35;           // bunun altında sulamaya başla / start watering below this
7const byte STOP_PCT = 60;            // bunun üstünde sulamayı bitir / stop watering above this
8const unsigned long PUMP_MS = 4000;  // tek seferde en fazla pompa süresi / max pump time per pulse
9const unsigned long SOAK_MS = 60000; // suyun toprağa yayılması için bekle / let the water spread
10
11bool watering = false;
12
13int readAverage() {                  // 10 okumanın ortalaması / average of 10 readings
14  long sum = 0;
15  for (byte i = 0; i < 10; i++) {
16    sum += analogRead(SENSOR_PIN);
17    delay(10);
18  }
19  return sum / 10;
20}
21
22int toPercent(int raw) {             // ham değeri yüzdeye çevir / raw value to percent
23  long pct = (long)(DRY_VALUE - raw) * 100 / (DRY_VALUE - WET_VALUE);
24  return constrain(pct, 0, 100);
25}
26
27void setup() {
28  Serial.begin(9600);
29  pinMode(PUMP_PIN, OUTPUT);
30  digitalWrite(PUMP_PIN, !RELAY_ON);   // pompa kapalı başlasın / start with the pump off
31}
32
33void loop() {
34  int raw = readAverage();
35  int pct = toPercent(raw);
36  Serial.print(F("Ham / raw: "));
37  Serial.print(raw);
38  Serial.print(F("   Nem / moisture: %"));
39  Serial.println(pct);
40
41  if (!watering && pct < START_PCT) watering = true;    // histerezis / hysteresis
42  if (watering && pct >= STOP_PCT) watering = false;
43
44  if (watering) {
45    digitalWrite(PUMP_PIN, RELAY_ON);  // kısa bir doz su ver / give a short dose of water
46    delay(PUMP_MS);
47    digitalWrite(PUMP_PIN, !RELAY_ON);
48    delay(SOAK_MS);                    // tekrar ölçmeden önce bekle / wait before measuring again
49  } else {
50    delay(2000);
51  }
52}
Mini pompe à eau immergée
Mini pompe immergée 3–6 V : alimentée par une source séparée via un module relais ou un MOSFET.

Ne branche jamais la pompe directement sur une broche de l'Arduino ; alimente-la par une source 5 V séparée via un module relais ou un MOSFET, et relie les masses. Certains modules relais s'activent sur un niveau LOW ; si c'est le cas du tien, passe la constante RELAY_ON du code à LOW. Pour choisir la pompe et brancher le tuyau, vois l'article sur la mini pompe à eau. Ajouter un capteur de niveau d'eau pour détecter un réservoir vide évite à la pompe de tourner à sec et de griller.

Moniteur d'humidité de plante sur batterie avec l'ESP32

Le mode deep sleep de l'ESP32 permet de faire fonctionner le capteur des mois sur batterie. Au réveil, le code ci-dessous allume le capteur par le GPIO 25, attend 1 seconde que la sortie se stabilise, fait la moyenne de 16 mesures, éteint le capteur et affiche le résultat. Si la terre est sous 30 %, la LED intégrée clignote trois fois ; puis l'ESP32 dort 30 minutes. Le compteur marqué RTC_DATA_ATTR est conservé pendant le deep sleep. Comme l'ADC de l'ESP32 est sur 12 bits, les valeurs de calibrage vont de 0 à 4095 et diffèrent de celles de l'Uno ; mesure-les de nouveau avec ton propre capteur.

C++ (Arduino IDE)
1const int SENSOR_PIN = 34;           // AOUT, ADC1 pini / ADC1 pin
2const int SENSOR_POWER_PIN = 25;     // sensörün VCC'si / sensor VCC
3const int LED_PIN = 2;               // dahili LED: kuru uyarısı / onboard LED: dry warning
4const int DRY_VALUE = 3100;          // 12 bit, havada / 12-bit, in air
5const int WET_VALUE = 1350;          // 12 bit, suda / 12-bit, in water
6const uint64_t SLEEP_MIN = 30;       // ölçüm aralığı (dakika) / interval (minutes)
7
8RTC_DATA_ATTR int bootCount = 0;     // derin uykuda korunur / kept through deep sleep
9
10void setup() {
11  Serial.begin(115200);
12  bootCount++;
13  pinMode(SENSOR_POWER_PIN, OUTPUT);
14  pinMode(LED_PIN, OUTPUT);
15
16  digitalWrite(SENSOR_POWER_PIN, HIGH);        // sensörü aç / power the sensor
17  delay(1000);                                 // çıkış otursun / let the output settle
18  long sum = 0;
19  for (int i = 0; i < 16; i++) sum += analogRead(SENSOR_PIN);
20  digitalWrite(SENSOR_POWER_PIN, LOW);         // sensörü kapat / switch it off
21  int raw = sum / 16;
22  int pct = constrain(map(raw, DRY_VALUE, WET_VALUE, 0, 100), 0, 100);
23  Serial.printf("#%d raw %d moisture %d%%\n", bootCount, raw, pct);
24
25  if (pct < 30) {                              // kuruysa 3 kez yanıp sön / blink 3 times if dry
26    for (int i = 0; i < 3; i++) {
27      digitalWrite(LED_PIN, HIGH);
28      delay(200);
29      digitalWrite(LED_PIN, LOW);
30      delay(200);
31    }
32  }
33  esp_sleep_enable_timer_wakeup(SLEEP_MIN * 60ULL * 1000000ULL);   // mikrosaniye / microseconds
34  esp_deep_sleep_start();                      // 30 dk uyu / sleep for 30 min
35}
36
37void loop() {
38}

Estimons grossièrement l'autonomie : à chaque réveil, l'ESP32 consomme 40 à 50 mA pendant environ 1,5 seconde ; avec un réveil toutes les 30 minutes, cela fait en moyenne à peine 50 × 1,5 / 1800 ≈ 0,04 mA. Ce qui compte vraiment, c'est le courant de veille : une carte DevKit ordinaire, avec sa puce USB-série et son régulateur, consomme plusieurs mA même endormie et vide une batterie de 2000 mAh en deux ou trois semaines. Avec un module ESP32 nu et un régulateur à faibles pertes, le courant de veille descend à quelques dizaines de microampères et la batterie tient des mois. Calcule ton montage avec le calculateur d'autonomie de batterie ; les détails sont dans deep sleep de l'ESP32.

Capteur capacitif avec le Raspberry Pi Pico (MicroPython)

Sur le Raspberry Pi Pico, branche la sortie AOUT du capteur sur GP26, c'est-à-dire ADC0, et son VCC sur GP22. En MicroPython, read_u16() renvoie des valeurs de 0 à 65535 ; à l'air libre tu verras environ 50000 à 53000, dans l'eau autour de 22000 à 26000. Comme l'ADC du Pico utilise une référence de 3,3 V, la sortie d'un capteur avec régulateur couvre bien la plage. Le code mesure toutes les 10 secondes et classe la terre en dry, ok ou wet.

MicroPython
1from machine import ADC, Pin
2import time
3
4sensor = ADC(26)                  # GP26 = ADC0, sensör AOUT / sensor AOUT
5power = Pin(22, Pin.OUT)          # sensörün VCC'si / sensor VCC
6DRY = 52000                       # havada okunan (16 bit) / reading in air (16-bit)
7WET = 24000                       # suda okunan (16 bit) / reading in water (16-bit)
8
9def read_moisture():
10    power.value(1)                # sensörü aç / power on
11    time.sleep(1)                 # çıkış otursun / let the output settle
12    total = 0
13    for _ in range(16):
14        total += sensor.read_u16()
15        time.sleep_ms(5)
16    power.value(0)                # sensörü kapat / power off
17    raw = total // 16
18    pct = (DRY - raw) * 100 // (DRY - WET)
19    return raw, max(0, min(100, pct))
20
21while True:
22    raw, pct = read_moisture()
23    state = "dry" if pct < 30 else ("ok" if pct < 80 else "wet")
24    print("raw:", raw, "moisture %:", pct, state)
25    time.sleep(10)

Étanchéité : protéger les bords et bien placer le capteur

  • Protège les bords : la fibre de verre à nu sur les bords découpés de la carte absorbe l'eau et fait dériver la mesure en quelques semaines. Couvre les bords de la sonde de vernis à ongles, de vernis transparent ou d'une fine couche d'époxy.
  • Protège l'électronique : recouvre la partie haute avec le 555, le régulateur et le connecteur de gaine thermorétractable, de colle chaude ou d'époxy pour la mettre à l'abri de la pluie et de l'eau d'arrosage.
  • Ne dépasse pas la ligne : la ligne blanche sur la carte indique la profondeur maximale dans la terre ; l'électronique doit toujours rester hors du sol.
  • Enfonce-le droit et fermement : plante le capteur verticalement et tasse légèrement la terre autour ; les poches d'air font paraître la terre plus sèche.
  • Garde la même position : place le capteur à 1–2 cm de la paroi du pot, dans la zone des racines, et pas juste sous le tuyau d'arrosage. Si tu le déplaces, recalibre-le.
  • Ne raye pas le vernis : le forcer dans une terre dure raye le vernis épargne, et le cuivre mis à nu s'oxyde aussi sur un capteur capacitif. Si besoin, fais d'abord un trou avec une baguette.
Après avoir protégé les bords et la zone de mesure, les valeurs à sec et dans l'eau peuvent changer de quelques points. Recalibre une fois le revêtement complètement sec, et n'applique pas de couche épaisse sur la zone de mesure : elle réduit la sensibilité.

Idées de projets

  • Arrosage automatique de pot : arrose tes plantes pendant tes vacances avec le code Uno, un relais et une mini pompe.
  • Serre connectée : associe l'humidité du sol à la température et à l'humidité de l'air dans une serre connectée qui gère ventilateur et pompe.
  • Alerte sur le téléphone : fais envoyer un message par un bot Telegram quand la terre devient sèche.
  • Courbe d'humidité : enregistre les mesures dans Google Sheets et vois sur une courbe en combien de temps ta plante sèche.
  • Indicateur avec écran : affiche le pourcentage d'humidité sous forme de barre sur un écran OLED.
  • Pas d'arrosage sous la pluie : pour le jardin, ne démarre pas la pompe quand un capteur de pluie détecte des précipitations.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
Sur ESP32 ou Pico la valeur ne change jamaisLa carte porte un NE555 et 3,3 V ne suffisent pasVérifie la puce ; prends une carte avec TLC555 ou remplace le NE555 par un TLC555
Le passage du sec à l'humide prend plusieurs minutesLa résistance de décharge de 1 MΩ n'est pas reliée à la masseRelie l'extrémité libre de la résistance à la masse avec un fil fin
La mesure dérive lentement en quelques semainesLes bords absorbent l'eau ou l'électronique est mouilléeProtège bords et partie haute avec vernis, époxy ou gaine et recalibre
Le pourcentage passe sous zéro ou au-dessus de 100Valeurs de calibrage fausses ou inverséesDRY_VALUE doit être la valeur sèche (la plus grande), WET_VALUE la valeur humide (la plus petite)
Les valeurs sautent sans arrêtCâble long, parasites ou terre meubleFais une moyenne, garde un câble court et tasse la terre autour du capteur
L'Arduino redémarre au démarrage de la pompeLa pompe est alimentée par le 5V de l'ArduinoAlimente la pompe par une autre source et relie les masses
Sur l'ESP32 les mesures déraillent dès que le Wi-Fi s'activeLe capteur est sur une broche ADC2Déplace AOUT sur une broche ADC1 entre GPIO 32 et 39

Si tu choisis la bonne carte et protèges ses bords, le capteur d'humidité du sol capacitif devient la pièce la plus fiable de tes projets de plantes et de jardin. Vérifie d'abord la puce, calibre ensuite dans ta propre terre et arrose avec hystérésis, par petites doses. Dans l'application BlueGrays, tu trouveras une station d'arrosage intelligente avec Arduino, ainsi que la mesure de température et d'humidité, chacun avec un schéma pas à pas et un code prêt à l'emploi.

Questions fréquentes

Quelle est la différence entre un capteur d'humidité du sol capacitif et résistif ?

Le capteur résistif fait passer un courant entre deux pointes métalliques nues plantées dans la terre, et ces pointes s'oxydent en quelques semaines à cause de l'électrolyse. Le capteur capacitif mesure la capacité de la terre avec des électrodes isolées, ne fait passer aucun courant et ne rouille pas. Il est aussi beaucoup moins sensible à l'engrais et aux sels.

Le capteur d'humidité capacitif fonctionne-t-il en 3,3 V ?

Les cartes équipées d'un TLC555 fonctionnent parfaitement en 3,3 V et se branchent directement sur un ESP32 ou un Pico. Les copies avec un NE555 demandent au moins 4,5 V, et en 3,3 V leur sortie ne bouge pas. L'inscription sur la puce à huit pattes de la carte te dit laquelle tu as.

Comment calibrer un capteur d'humidité du sol capacitif ?

Tiens le capteur à l'air libre ou dans une terre complètement sèche et note la valeur sèche, puis plonge-le dans l'eau ou dans une terre fraîchement arrosée et note la valeur humide. Le pourcentage se calcule avec % = (sec − brut) × 100 / (sec − humide). Chaque capteur donne des valeurs différentes : calibre-les un par un.

Quel pourcentage d'humidité faut-il dans la terre ?

Le pourcentage donné par ce capteur est relatif à ses propres points de calibrage. Pour la plupart des plantes en pot, 40 à 70 % est une bonne plage ; arrose quand on descend sous 25–30 % et arrête au-dessus de 80 %. Pour les plantes grasses et les cactus, choisis un seuil plus bas.

Le capteur d'humidité capacitif est-il étanche ?

La sonde de mesure résiste à l'eau, mais pas les bords découpés de la carte ni l'électronique du haut. En couvrant les bords de vernis ou d'époxy et la partie haute de gaine thermorétractable ou de colle chaude, le capteur dure des années. Ne l'enfonce pas au-delà de la ligne tracée sur la carte.

Pourquoi la valeur du capteur change-t-elle si lentement ?

Sur certaines copies, la résistance de 1 MΩ en sortie n'est pas reliée à la masse, et le condensateur de sortie ne peut pas se décharger. Le passage du sec à l'humide prend alors plusieurs minutes. Relier l'extrémité libre de cette résistance à la masse avec un fil fin règle le problème.

Voir tous les projets
Station d'irrigation intelligente
AR-83Avancé
Premium

Station d'irrigation intelligente

Un jardinier qui arrose tes plantes tout seul pour qu'elles ne sèchent pas pendant tes vacances.

5.0(42)
57
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
Mesure de l'intensité lumineuse avec le module LDR ESP32
ES-11Débutant

Mesure de l'intensité lumineuse avec le module LDR ESP32

Suivi en temps réel sur le moniteur série de la valeur brute de l'ADC du module LDR et du pourcentage relatif de luminosité calculé à partir de références dans l'obscurité et à la lumière. Ce pourcentage n'est pas une mesure en lux. Permet de comprendre le principe de calibrage du module. Il est préférable de réaliser cet exercice avant le projet 10, car il sert à déterminer la valeur seuil.

4.6(36)
55
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
Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
ES-13Intermédiaire
Premium

Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)

Dans ce projet, nous contrôlons la luminosité d'une LED de manière analogique à l'aide d'un potentiomètre. La broche ADC de l'ESP32 lit la tension entre 0 et 3,3 V provenant du potentiomètre, puis cette valeur est convertie en signal PWM (modulation de largeur d'impulsion) envoyé à la LED. Ainsi, la LED s'allume et s'éteint progressivement. Avec Arduino Core 3.0+, analogWrite() est utilisable directement; sur ESP32-S2/S3, la résolution de l'ADC est fixée à 12 bits.

4.5(19)
32