Capteurs Arduino : câbler et coder DHT22, HC-SR04, PIR et BMP280
Capteurs Arduino expliqués : câblage, résistances de tirage, tensions 3,3 V et 5 V, code commenté et dépannage du DHT22, HC-SR04, PIR HC-SR501 et BMP280.

Cet article contient des liens d'affiliation : si tu achètes via ces liens, Press & Pixel touche une commission, sans surcoût pour toi. Ça ne change pas nos verdicts. Comment on travaille.
Quatre capteurs Arduino couvrent l'essentiel des projets maison : le DHT22 pour la température et l'humidité, le HC-SR04 pour la distance, le PIR HC-SR501 pour le mouvement et le BMP280 pour la pression. Chacun a son piège : lecture trop rapide, écho en 5 V, temps de chauffe ou mauvaise adresse I2C. Ce guide donne le câblage, le code et la solution à chaque symptôme.
Les capteurs Arduino les plus utilisés tiennent en quatre références : DHT22 (température et humidité), HC-SR04 (distance par ultrasons), PIR HC-SR501 (mouvement) et BMP280 (pression et température). Les quatre se branchent sur un Arduino Uno sans soudure, à condition de respecter trois règles : la bonne tension, la bonne résistance de tirage et le bon rythme de lecture. Voici le câblage, le code testé ligne par ligne et le dépannage de chacun.
Ce qu'il faut savoir avant de brancher un capteur
Un capteur parle à l'Arduino de trois façons. En analogique, il sort une tension que l'Arduino mesure. En numérique simple, il passe une broche à l'état haut ou bas (le PIR). En protocole, il envoie des octets : le DHT22 utilise son propre protocole sur un seul fil, le BMP280 parle I2C (deux fils partagés, SDA pour les données et SCL pour l'horloge).
La tension compte autant que le protocole. L'Arduino Uno R3 travaille en 5 V. Les ESP32 et les Raspberry Pi travaillent en 3,3 V et n'aiment pas qu'on leur envoie du 5 V sur une entrée. Retiens ce réflexe : avant chaque branchement, lis la tension d'alimentation et la tension du signal de sortie.
Dernier point : les résistances de tirage (pull-up). Une ligne de données au repos doit être maintenue à un niveau connu. Sans tirage, elle « flotte » et l'Arduino lit n'importe quoi. Les modules sur petite carte en intègrent souvent une, les capteurs nus jamais.
| Capteur | Mesure | Alimentation (fiche) | Interface | Piège principal |
|---|---|---|---|---|
| DHT22 (AM2302) | Température, humidité | 3,3 à 6 V | 1 fil propriétaire | Lecture plus rapide que 2 s |
| HC-SR04 | Distance 2 cm à 4 m | 5 V | Impulsion Trig/Echo | Écho en 5 V sur carte 3,3 V |
| PIR HC-SR501 | Mouvement (infrarouge) | 5 à 12 V (régulateur 3,3 V) | Sortie numérique 3 V | 30 à 60 s de stabilisation |
| BMP280 | Pression, température | 1,71 à 3,6 V (puce) | I2C ou SPI | Adresse 0x76 ou 0x77 |
Sources : fiches Aosong DHT22, HC-SR04, Bosch BMP280, Adafruit PIR.
DHT22 : température et humidité avec un Arduino
Le DHT22 (vendu aussi sous le nom AM2302) mesure l'humidité de 0 à 100 % HR et la température de -40 à 80 °C. Sa fiche technique Aosong annonce ±2 % HR (±5 % au pire) et moins de ±0,5 °C, avec une résolution de 0,1. Le chiffre qui piège tout le monde : une mesure toutes les 2 secondes au minimum.
Câblage du DHT22
- Broche 1 (VCC) du capteur vers le 5 V de l'Uno (la plage admise va de 3,3 à 6 V).
- Broche 2 (DATA) vers la broche numérique D2.
- Une résistance de 10 kΩ entre VCC et DATA. Adafruit la recommande parce que les tirages internes de l'Arduino, autour de 20 à 50 kΩ, sont trop faibles (guide de câblage). Si tu as un module sur carte à trois broches, elle est en général déjà soudée.
- Broche 3 : non connectée.
- Broche 4 (GND) vers GND.
Code DHT22
Installe depuis le gestionnaire de bibliothèques de l'IDE Arduino la « DHT sensor library » d'Adafruit (version 1.4.7 sur GitHub) et sa dépendance « Adafruit Unified Sensor ».
// DHT22 sur Arduino Uno : lecture température + humidité toutes les 2,5 s
#include <DHT.h>
const uint8_t BROCHE_DHT = 2; // fil DATA du capteur
DHT dht(BROCHE_DHT, DHT22); // DHT22 et non DHT11 : sinon valeurs fausses
void setup() {
Serial.begin(115200);
dht.begin();
}
void loop() {
delay(2500); // la fiche impose plus de 2 s entre deux mesures
float humidite = dht.readHumidity();
float temperature = dht.readTemperature(); // en °C
// isnan() détecte une lecture ratée (câblage, tirage, rythme)
if (isnan(humidite) || isnan(temperature)) {
Serial.println(F("Lecture DHT22 impossible"));
return;
}
// Indice de chaleur (température ressentie), calcul fourni par la bibliothèque
float ressenti = dht.computeHeatIndex(temperature, humidite, false);
Serial.print(F("T = ")); Serial.print(temperature, 1);
Serial.print(F(" °C HR = ")); Serial.print(humidite, 1);
Serial.print(F(" % ressenti = ")); Serial.print(ressenti, 1);
Serial.println(F(" °C"));
}
Place le capteur loin de toute source de chaleur, régulateur de la carte compris : la fiche Aosong demande de l'éloigner le plus possible des composants qui chauffent.
HC-SR04 : mesurer une distance par ultrasons
Le HC-SR04 envoie une salve d'ultrasons et chronomètre l'écho. Selon sa fiche technique, il mesure de 2 cm à 4 m, dans un cône de 15°, avec 15 mA de consommation sous 5 V. La conversion est simple : la durée de l'écho en microsecondes divisée par 58 donne des centimètres. La fiche conseille au moins 60 ms entre deux mesures, pour que l'écho précédent ne pollue pas le suivant.
Câblage du HC-SR04
- VCC vers 5 V, GND vers GND.
- Trig vers D9 : l'Arduino y envoie une impulsion d'au moins 10 µs.
- Echo vers D10 : le capteur y renvoie une impulsion dont la durée est proportionnelle à la distance.
Sur un ESP32 ou un Raspberry Pi, ne branche jamais Echo directement : il sort du 5 V. Intercale un diviseur de tension, 1 kΩ en série puis 2 kΩ vers la masse. Le calcul : 5 V × 2 / (1 + 2) = 3,33 V, juste ce qu'il faut pour une entrée 3,3 V.
Code HC-SR04
Pas de bibliothèque nécessaire, pulseIn() fait partie du cœur Arduino.
// HC-SR04 : distance en centimètres, une mesure toutes les 100 ms
const uint8_t BROCHE_TRIG = 9;
const uint8_t BROCHE_ECHO = 10;
void setup() {
Serial.begin(115200);
pinMode(BROCHE_TRIG, OUTPUT);
pinMode(BROCHE_ECHO, INPUT);
digitalWrite(BROCHE_TRIG, LOW);
}
void loop() {
// Impulsion de déclenchement : 10 µs à l'état haut (valeur de la fiche)
digitalWrite(BROCHE_TRIG, LOW);
delayMicroseconds(2);
digitalWrite(BROCHE_TRIG, HIGH);
delayMicroseconds(10);
digitalWrite(BROCHE_TRIG, LOW);
// Durée de l'écho ; délai max 30 000 µs, soit environ 5 m aller-retour
unsigned long duree = pulseIn(BROCHE_ECHO, HIGH, 30000UL);
if (duree == 0) {
Serial.println(F("Pas d'écho (hors portée ou surface absorbante)"));
} else {
float distanceCm = duree / 58.0; // formule de la fiche : µs / 58 = cm
Serial.print(F("Distance : "));
Serial.print(distanceCm, 1);
Serial.println(F(" cm"));
}
delay(100); // plus de 60 ms entre deux mesures
}
La formule µs / 58 suppose une vitesse du son de 340 m/s, celle de la fiche. Elle varie avec la température de l'air : si tu veux du précis, couple le HC-SR04 au DHT22 et corrige la vitesse en fonction de la température mesurée.
Capteur PIR HC-SR501 : détecter un mouvement
Un PIR (capteur infrarouge passif) ne mesure rien : il réagit à un changement de rayonnement infrarouge, typiquement un corps chaud qui traverse son champ. Adafruit, pour son module très proche du HC-SR501, donne une portée jusqu'à 6 m, un angle de 110° × 70° et une sortie numérique haute à 3 V quand il détecte (fiche Adafruit). Il s'alimente entre 5 et 12 V grâce à un régulateur 3,3 V embarqué, 5 V étant la valeur conseillée.
Câblage et réglages du PIR
- VCC vers 5 V, GND vers GND, OUT vers D3.
- Le cavalier H/L choisit le mode : en H (redéclenchement), la sortie reste haute tant qu'il y a du mouvement ; en L, elle retombe puis remonte. Adafruit juge le mode H « un peu plus agréable » pour la plupart des usages (test d'un PIR).
- Deux potentiomètres : la sensibilité et la durée d'impulsion. Sur le module Adafruit, la durée va d'environ 2,5 s à 250 s selon la position. Les valeurs changent d'un fabricant à l'autre, teste les tiens.
Sur un Uno 5 V, une sortie à 3 V reste un niveau haut un peu juste. Si la lecture est instable, ajoute un petit transistor NPN en interface, ou passe sur une carte 3,3 V où le problème disparaît.
Code PIR
// PIR HC-SR501 : allume la LED intégrée (D13) et signale chaque détection
const uint8_t BROCHE_PIR = 3;
const uint8_t BROCHE_LED = LED_BUILTIN;
bool etatPrecedent = LOW;
void setup() {
Serial.begin(115200);
pinMode(BROCHE_PIR, INPUT);
pinMode(BROCHE_LED, OUTPUT);
Serial.println(F("Stabilisation du PIR (60 s)..."));
delay(60000); // Adafruit : 30 à 60 s de stabilisation
Serial.println(F("Prêt"));
}
void loop() {
bool etat = digitalRead(BROCHE_PIR);
digitalWrite(BROCHE_LED, etat);
// On ne signale que les fronts, pas l'état continu
if (etat == HIGH && etatPrecedent == LOW) {
Serial.println(F("Mouvement détecté"));
} else if (etat == LOW && etatPrecedent == HIGH) {
Serial.println(F("Fin du mouvement"));
}
etatPrecedent = etat;
delay(50);
}
BMP280 : pression atmosphérique et altitude
Le BMP280 de Bosch mesure la pression de 300 à 1 100 hPa. Sa fiche technique annonce une précision absolue typique de ±1 hPa et une précision relative de ±0,12 hPa, soit environ ±1 m d'altitude. Il consomme 2,7 µA à une mesure par seconde, ce qui en fait un bon candidat pour un montage sur pile.
Câblage I2C du BMP280
- La puce accepte de 1,71 à 3,6 V : alimente le module en 3,3 V sauf si ta carte porte un régulateur (Adafruit, par exemple, accepte 3 à 5 V sur Vin). Dans le doute, 3,3 V.
- SDA vers A4, SCL vers A5 sur l'Uno R3 (ou les broches SDA/SCL près de AREF).
- SDO choisit l'adresse : à la masse, 0x76 ; à VDDIO, 0x77, d'après Bosch.
- CSB relié à VDDIO pour rester en I2C (beaucoup de modules le font d'origine).
Code BMP280
Bibliothèque « Adafruit BMP280 Library », version 3.0.0 sur GitHub, avec ses dépendances Adafruit Unified Sensor et Adafruit BusIO. Attention : elle cherche le capteur à 0x77 par défaut (constante BMP280_ADDRESS du fichier d'en-tête), alors que beaucoup de modules génériques sortent en 0x76.
// BMP280 en I2C : température, pression (hPa) et altitude estimée
#include <Wire.h>
#include <Adafruit_BMP280.h>
Adafruit_BMP280 bmp; // interface I2C
const float PRESSION_MER_HPA = 1013.25; // à remplacer par la valeur du jour
void setup() {
Serial.begin(115200);
// Essai à 0x76 (modules génériques), puis 0x77 (défaut de la bibliothèque)
if (!bmp.begin(0x76) && !bmp.begin(0x77)) {
Serial.println(F("BMP280 introuvable : vérifie SDA/SCL et l'adresse"));
while (true) delay(1000);
}
// Suréchantillonnage et filtre : réglage « station météo » raisonnable
bmp.setSampling(Adafruit_BMP280::MODE_NORMAL,
Adafruit_BMP280::SAMPLING_X2, // température
Adafruit_BMP280::SAMPLING_X16, // pression
Adafruit_BMP280::FILTER_X16,
Adafruit_BMP280::STANDBY_MS_500);
}
void loop() {
float t = bmp.readTemperature(); // °C
float p = bmp.readPressure() / 100.0; // la bibliothèque rend des Pa
float alt = bmp.readAltitude(PRESSION_MER_HPA);
Serial.print(F("T = ")); Serial.print(t, 1);
Serial.print(F(" °C P = ")); Serial.print(p, 1);
Serial.print(F(" hPa altitude ~ ")); Serial.print(alt, 0);
Serial.println(F(" m"));
delay(2000);
}
L'altitude est une estimation. Adafruit prévient qu'à défaut de connaître la pression au niveau de la mer du jour, on fait difficilement mieux que 10 m de précision (test Arduino du BMP280). Pour une station météo, la tendance de pression sur trois heures est bien plus parlante que l'altitude.
Combiner les quatre capteurs sur un seul Arduino
Les quatre tiennent sur un Uno : D2 pour le DHT22, D9 et D10 pour le HC-SR04, D3 pour le PIR, A4 et A5 pour le BMP280. Le vrai sujet devient le rythme. Avec des delay() partout, le DHT22 bloque 2,5 s et le PIR rate des passages. La solution : un minuteur par capteur avec millis().
// Squelette non bloquant : chaque capteur a sa propre cadence
unsigned long dernierDHT = 0, dernierSonar = 0;
void loop() {
unsigned long maintenant = millis();
if (maintenant - dernierDHT >= 2500) { // DHT22 : plus de 2 s
dernierDHT = maintenant;
// lireDHT();
}
if (maintenant - dernierSonar >= 100) { // HC-SR04 : plus de 60 ms
dernierSonar = maintenant;
// lireDistance();
}
// Le PIR est lu à chaque tour : il ne coûte rien
// lirePIR();
}
Le calcul de consommation reste modeste : le HC-SR04 annonce 15 mA, le BMP280 quelques µA, le DHT22 et le PIR peu de chose. Le port USB suffit largement. Si tu passes ensuite au WiFi, l'ESP32 et ses projets pour débutants reprennent ces capteurs avec un serveur web, et notre comparatif Arduino vs ESP32 aide à choisir la carte.
Dépannage des capteurs Arduino
| Symptôme | Cause probable | Solution |
|---|---|---|
| DHT22 renvoie NaN | Lecture trop rapide, pas de tirage, mauvais type | 2,5 s entre lectures, 10 kΩ VCC-DATA, DHT22 dans le constructeur |
| DHT22 affiche une température trop haute | Capteur collé au régulateur ou à la carte | L'éloigner des composants qui chauffent avec une rallonge de fils |
| HC-SR04 renvoie 0 en permanence | Trig et Echo inversés, ou alimentation 3,3 V | Vérifier le câblage, alimenter en 5 V |
| HC-SR04 donne des sauts de valeurs | Mesures trop rapprochées, surface molle ou en biais | Plus de 60 ms entre mesures, viser une surface plane et dure |
| PIR déclenche sans raison | Phase de stabilisation, courant d'air chaud, sensibilité trop haute | Attendre 60 s, éloigner du radiateur, baisser le potentiomètre |
| PIR reste bloqué à HIGH | Durée d'impulsion réglée au maximum | Tourner le potentiomètre de durée dans le sens antihoraire |
| BMP280 introuvable | Adresse 0x76 alors que le code cherche 0x77 | bmp.begin(0x76) ou scanner I2C |
| BMP280 lit une pression absurde | Module BME280 ou faux BMP280 | Lire l'identifiant de puce, changer de bibliothèque si besoin |
Si tes capteurs doivent finir sur un circuit permanent plutôt que sur une plaque d'essai, il faudra souder les connecteurs : notre guide pour choisir un fer à souder pour débutant explique quoi prendre et à quelle température travailler.
Matériel utile
Pour suivre ce guide, il te faut un Uno (l'officiel ou un compatible), une plaque d'essai, des fils mâle-mâle et les quatre modules. Les modules sur carte sont préférables aux capteurs nus pour débuter : résistance de tirage et régulateur sont déjà là.
Pour aller plus loin, un Raspberry Pi 5 et ses projets maker lit le même BMP280 en Python, avec un tableau de bord en prime.
Questions fréquentes
Pourquoi mon DHT22 renvoie NaN ?
Trois causes reviennent. La lecture est trop rapide : la fiche Aosong impose plus de 2 secondes entre deux mesures. Le fil de données n'a pas de résistance de tirage : Adafruit conseille 10 kΩ entre VCC et DATA, les tirages internes de l'Arduino étant trop faibles (20 à 50 kΩ). Enfin, le type déclaré dans le code est faux : DHT11 au lieu de DHT22 donne des valeurs absurdes ou NaN.
Le HC-SR04 fonctionne-t-il en 3,3 V ?
Le modèle d'origine est spécifié pour 5 V d'alimentation, et sa broche Echo renvoie alors un signal 5 V qui peut abîmer une entrée 3,3 V (ESP32, Raspberry Pi). Garde l'alimentation en 5 V et place un diviseur de tension sur Echo : 1 kΩ en série, 2 kΩ vers la masse, ce qui ramène 5 V à environ 3,3 V. Certaines variantes récentes acceptent 3,3 V : vérifie la fiche de ton vendeur.
Peut-on brancher plusieurs capteurs I2C sur le même Arduino ?
Oui, c'est tout l'intérêt du bus I2C : tous les modules partagent SDA et SCL, chacun répond à son adresse. Le BMP280 propose deux adresses, 0x76 si SDO est à la masse et 0x77 si SDO est relié à VDDIO, selon la fiche Bosch. Tu peux donc en brancher deux. Au-delà, ou si deux modules ont la même adresse fixe, il faut un multiplexeur I2C.
Combien de temps faut-il attendre avant qu'un capteur PIR fonctionne ?
Adafruit indique 30 à 60 secondes de stabilisation après la mise sous tension. Pendant ce temps, la sortie peut basculer toute seule. Dans ton code, ajoute une pause d'une minute dans setup() ou ignore les détections de la première minute, sinon tu déclencheras une alarme à chaque démarrage.
Sources et méthode
Les valeurs et procédures de ce guide viennent de la documentation des fabricants et de références techniques reconnues de la communauté maker, listées ci-dessous. Notre méthode en détail.
- Digital-output relative humidity & temperature sensor/module DHT22 (AM2302), Aosong (copie SparkFun) (2026-11)
- Ultrasonic Ranging Module HC-SR04, Elec Freaks (copie SparkFun) (2026-11)
- BMP280 Digital Pressure Sensor, data sheet, Bosch Sensortec (2026-11)
- PIR Motion Sensor, overview, Adafruit Learning System (2024-03)
- PIR Motion Sensor, testing a PIR, Adafruit Learning System (2024-03)
- DHTxx sensors, connecting to a DHTxx sensor, Adafruit Learning System (2026-11)
- DHT-sensor-library (v1.4.7), Adafruit / GitHub (2026-11)
- Adafruit_BMP280_Library (v3.0.0), Adafruit / GitHub (2026-11)
- Adafruit BMP280 breakout, Arduino test, Adafruit Learning System (2026-11)
- UNO R3, Arduino Docs (2026-11)




