Capteur de particules PMS5003 Arduino : mesure PM2.5 et PM10
Branche le capteur PMS5003 à Arduino, ESP32 et Pico : broches UART, trame de 32 octets, mode veille et indicateur LED de qualité de l'air PM2.5.
Pour un projet Arduino, le capteur de particules est l'outil le plus efficace pour transformer en chiffres les particules invisibles de l'air, et le modèle le plus utilisé est le capteur laser PMS5003 de Plantower. Ce petit boîtier aspire l'air avec un ventilateur, l'éclaire avec un faisceau laser et analyse la lumière diffusée pour donner les concentrations de PM1.0, PM2.5 et PM10 en microgrammes par mètre cube (µg/m³). Il envoie les résultats tout seul toutes les quelques secondes sur une liaison UART à 9600 bauds ; tu peux donc le lire avec un Arduino Uno, un ESP32 ou un Raspberry Pi Pico en quelques fils seulement.
En hiver, avec la fumée des poêles et du chauffage, le trafic dense et le brouillard, la concentration de particules fines monte vite en ville, et tu ne le vois souvent pas à l'œil nu. Dans cet article, tu vas apprendre comment fonctionne le PMS5003, comment décoder sa trame de 32 octets, comment le mettre en veille pour prolonger sa durée de vie et comment fabriquer un indicateur de qualité de l'air qui s'allume en vert, jaune ou rouge selon les valeurs. Les codes sont prêts : SoftwareSerial pour l'Uno, UART matériel pour l'ESP32 et MicroPython pour le Pico.
Qu'est-ce que le capteur de particules PMS5003 et comment fonctionne-t-il ?
Le principe de fonctionnement du PMS5003 est la diffusion laser. Un petit ventilateur aspire l'air par l'orifice d'entrée du boîtier jusqu'à la chambre de mesure. Quand le faisceau laser qui traverse la chambre rencontre des particules, la lumière est diffusée dans toutes les directions et une photodiode capte ces brèves impulsions lumineuses. L'intensité de l'impulsion dépend de la taille de la particule, et leur nombre dépend de la quantité de particules. Le microcontrôleur interne trie ces impulsions en classes de taille de 0,3 µm à 10 µm, calcule le nombre de particules dans 0,1 litre d'air et les convertit en concentration massique grâce à l'étalonnage d'usine. Toi, tu n'as qu'à lire les résultats prêts à l'emploi sur le port série.
PM vient de l'anglais « particulate matter », c'est-à-dire matière particulaire ; le chiffre qui suit indique le diamètre maximal de la particule en micromètres. PM10 regroupe toutes les particules de moins de 10 µm (pollens, poussières de chantier, poussières de route) qui se déposent surtout dans le nez et la gorge. PM2.5 désigne les particules de moins de 2,5 µm, environ 30 fois plus fines qu'un cheveu ; elles descendent jusqu'au fond des poumons et c'est la valeur la plus suivie pour la santé. PM1.0 correspond à la fraction la plus fine, en particulier la suie et les fumées issues de la combustion. Comme le PM1.0 est compté dans le PM2.5 et le PM2.5 dans le PM10, on a toujours PM1.0 ≤ PM2.5 ≤ PM10.
| Caractéristique | Valeur |
|---|---|
| Principe de mesure | Diffusion laser |
| Tailles mesurées | 0,3–10 µm (PM1.0, PM2.5, PM10 et nombre de particules sur 6 classes de taille) |
| Plage de mesure effective | 0–500 µg/m³ (jusqu'à 1000 µg/m³ et plus au maximum) |
| Précision | ±10 µg/m³ entre 0 et 100 µg/m³, ±10 % entre 100 et 500 µg/m³ |
| Résolution | 1 µg/m³ |
| Alimentation | 5 V (4,5–5,5 V), nécessaire pour le ventilateur |
| Courant | ≤ 100 mA en fonctionnement, ≤ 200 µA en veille |
| Communication | UART, 9600 bauds, 8N1, niveau logique 3,3 V |
| Temps de réponse | Moins de 10 secondes (30 s après le réveil pour des données stables) |
| Environnement de fonctionnement | -10 à +60 °C, 0–99 % d'humidité relative (sans condensation) |
| Dimensions | 50 × 38 × 21 mm |
| Durée de vie moyenne (MTTF) | Au moins 3 ans |
Que signifient les valeurs PM2.5 et PM10 ?
Pour interpréter le chiffre donné par le capteur, on utilise des échelles officielles. Les lignes directrices 2021 de l'Organisation mondiale de la santé (OMS) recommandent pour les PM2.5 une limite de 15 µg/m³ en moyenne sur 24 heures et de 5 µg/m³ en moyenne annuelle ; pour les PM10, 45 µg/m³ sur 24 heures et 15 µg/m³ par an. L'indice de qualité de l'air (AQI) de l'agence américaine de protection de l'environnement (EPA) répartit les PM2.5 en six niveaux de couleur. Ces échelles étant définies sur une moyenne de 24 heures, utiliser sur ton indicateur une moyenne de quelques minutes plutôt qu'une seule mesure instantanée donne un résultat bien plus juste.
| PM2.5 (µg/m³, 24 h) | Niveau EPA | Signification |
|---|---|---|
| 0–9,0 | Bon (vert) | L'air est propre, aucun risque |
| 9,1–35,4 | Modéré (jaune) | Risque faible pour les personnes très sensibles |
| 35,5–55,4 | Mauvais pour les groupes sensibles (orange) | Les asthmatiques, les personnes cardiaques, les enfants et les personnes âgées doivent faire attention |
| 55,5–125,4 | Mauvais (rouge) | Tout le monde commence à être touché |
| 125,5–225,4 | Très mauvais (violet) | Limite les activités en extérieur |
| 225,5 et plus | Dangereux (bordeaux) | Niveau d'urgence |
Branchement du PMS5003 : Arduino Uno, ESP32 et Pico
À l'arrière du PMS5003, il y a un petit connecteur à 8 broches au pas de 1,25 mm, qui ne rentre pas dans une breadboard. Si tu utilises le câble fourni avec le capteur et la petite carte adaptatrice généralement jointe au paquet, les broches deviennent un en-tête standard de 2,54 mm. Les broches 7 et 8 sont libres. Les broches SET et RESET sont tirées vers le haut (pull-up) à l'intérieur du capteur ; si tu ne les utilises pas, tu peux les laisser non connectées.
| Broche PMS5003 | Rôle | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|
| 1 VCC | Alimentation 5 V | 5V | 5V (VIN) | VBUS (broche 40) |
| 2 GND | Masse | GND | GND | GND |
| 3 SET | HIGH ou libre : marche, LOW : veille | D4 (optionnel) | GPIO 4 | GP2 (optionnel) |
| 4 RX | Entrée des commandes vers le capteur (3,3 V) | D3 (avec diviseur de tension) | GPIO 17 (TX2) | GP0 (UART0 TX) |
| 5 TX | Sortie des données du capteur (3,3 V) | D2 | GPIO 16 (RX2) | GP1 (UART0 RX) |
| 6 RESET | LOW : réinitialise | Libre | Libre | Libre |
| 7, 8 | Non connectées | - | - | - |
Trame de données : le sens des 32 octets
En mode actif par défaut, le capteur envoie le résultat de mesure tout seul et en continu sous forme d'une trame de 32 octets. La trame commence toujours par les octets 0x42 et 0x4D (« BM » en ASCII) ; viennent ensuite la longueur de la trame (28), 13 données de 16 bits et une somme de contrôle de 2 octets. Chaque valeur de 16 bits est transmise d'abord avec l'octet de poids fort, puis celui de poids faible (big-endian). La somme de contrôle est égale à la somme des 30 premiers octets, et cette vérification est le seul moyen fiable d'écarter les trames corrompues par le bruit sur les fils. Quand la qualité de l'air change peu, le capteur envoie une trame environ toutes les 2,3 secondes ; quand elle change vite, toutes les 200–800 ms. Si tu veux comprendre les bases du protocole, jette un œil à l'article communication série UART.
| Octet | Contenu | Unité |
|---|---|---|
| 0–1 | Début : 0x42 0x4D | - |
| 2–3 | Longueur de la trame (28) | octets |
| 4–5 | PM1.0 (CF=1, particule standard) | µg/m³ |
| 6–7 | PM2.5 (CF=1) | µg/m³ |
| 8–9 | PM10 (CF=1) | µg/m³ |
| 10–11 | PM1.0 (environnement atmosphérique) | µg/m³ |
| 12–13 | PM2.5 (environnement atmosphérique) | µg/m³ |
| 14–15 | PM10 (environnement atmosphérique) | µg/m³ |
| 16–27 | Nombre de particules supérieures à 0,3 / 0,5 / 1,0 / 2,5 / 5,0 / 10 µm (6 valeurs) | nombre / 0,1 L |
| 28–29 | Réservé | - |
| 30–31 | Somme de contrôle (somme des octets 0–29) | - |
Lire le PMS5003 avec l'Arduino Uno pas à pas
- Branche le câble du capteur sur la carte adaptatrice ; relie VCC à la broche 5V de l'Uno et GND à GND.
- Relie la broche TX du capteur à D2 ; ce sera le RX de SoftwareSerial.
- Si tu comptes envoyer des commandes, relie la broche RX du capteur à D3 via un diviseur de tension 10 kΩ / 20 kΩ ; sinon, laisse-la libre.
- Téléverse le code ci-dessous et ouvre le moniteur série à 115200 bauds.
- Ignore les valeurs des 30 premières secondes ; les mesures deviennent stables une fois que la vitesse du ventilateur s'est établie.
- À quelques centimètres du capteur, secoue un chiffon poussiéreux ou souffle une bougie pour l'éteindre, et observe la montée des valeurs.
1#include <SoftwareSerial.h>
2
3SoftwareSerial pmsSerial(2, 3); // D2 = RX (sensör TX'i), D3 = TX (sensör RX'i) / D2 = RX (sensor TX), D3 = TX (sensor RX)
4
5struct PmsData {
6 uint16_t pm1Cf, pm25Cf, pm10Cf; // CF=1 değerleri / CF=1 values
7 uint16_t pm1, pm25, pm10; // atmosferik değerler / atmospheric values
8 uint16_t n03, n05, n10; // 0,1 L'deki parçacık sayısı / particles per 0.1 L
9};
10
11PmsData pms;
12uint8_t buf[32];
13uint8_t idx = 0;
14
15uint16_t word16(uint8_t i) {
16 return ((uint16_t)buf[i] << 8) | buf[i + 1]; // yüksek bayt önce / high byte first
17}
18
19bool readPms(Stream &s, PmsData &d) {
20 while (s.available()) {
21 uint8_t c = s.read();
22 if (idx == 0 && c != 0x42) continue; // başlangıç baytını bekle / wait for start byte
23 if (idx == 1 && c != 0x4D) { // ikinci başlangıç baytı / second start byte
24 idx = (c == 0x42) ? 1 : 0;
25 continue;
26 }
27 buf[idx++] = c;
28 if (idx < 32) continue;
29 idx = 0; // çerçeve tamam / frame complete
30 if (word16(2) != 28) return false; // uzunluk kontrolü / length check
31 uint16_t sum = 0;
32 for (uint8_t i = 0; i < 30; i++) sum += buf[i];
33 if (sum != word16(30)) return false; // sağlama toplamı / checksum
34 d.pm1Cf = word16(4); d.pm25Cf = word16(6); d.pm10Cf = word16(8);
35 d.pm1 = word16(10); d.pm25 = word16(12); d.pm10 = word16(14);
36 d.n03 = word16(16); d.n05 = word16(18); d.n10 = word16(20);
37 return true;
38 }
39 return false;
40}
41
42void setup() {
43 Serial.begin(115200);
44 pmsSerial.begin(9600); // PMS5003 sabit hızı / fixed PMS5003 baud rate
45 Serial.println(F("PMS5003 hazir, 30 sn isinma / warming up 30 s"));
46}
47
48void loop() {
49 if (readPms(pmsSerial, pms)) {
50 Serial.print(F("PM1.0: ")); Serial.print(pms.pm1);
51 Serial.print(F(" PM2.5: ")); Serial.print(pms.pm25);
52 Serial.print(F(" PM10: ")); Serial.print(pms.pm10);
53 Serial.print(F(" ug/m3 | >0.3um: ")); Serial.print(pms.n03);
54 Serial.println(F(" /0.1L"));
55 }
56}Le cœur du code est la fonction readPms(). Elle lit les octets reçus un par un, cherche d'abord la paire de début 0x42 et 0x4D, puis les écrit dans le tampon jusqu'à en avoir 32. Quand la trame est complète, elle vérifie que le champ de longueur vaut 28 et que la somme des 30 premiers octets est égale à la valeur de contrôle des deux derniers octets ; si les deux sont corrects, elle copie les valeurs dans la structure. Comme la fonction prend un paramètre de type Stream, le même code fonctionne sans changement avec SoftwareSerial, le Serial1 de l'Arduino Mega ou le HardwareSerial de l'ESP32. loop() n'attend jamais, tu peux donc y ajouter d'autres tâches ; si tu as besoin de temporisation, le mieux est d'utiliser millis() plutôt que delay().
Mode veille : broche SET et commandes UART
Quand le laser et le ventilateur du PMS5003 tournent en continu, sa durée de vie moyenne est d'environ 3 ans et le capteur consomme tout ce temps un courant proche de 100 mA. Or la qualité de l'air change lentement, sur plusieurs minutes ; mesurer toutes les quelques minutes suffit donc. Tu peux mettre le capteur en veille de deux façons : mettre la broche SET à LOW ou envoyer la commande de veille de 7 octets par UART. En veille, le ventilateur et le laser s'arrêtent et le courant tombe sous 200 µA. Après le réveil, tu dois attendre au moins 30 secondes que le ventilateur se stabilise avant de lire. Par exemple, si tu fonctionnes toutes les 5 minutes avec 30 secondes de préchauffage et 20 secondes de mesure, le capteur n'est actif qu'un sixième du temps ; la consommation d'énergie et l'usure du laser diminuent dans la même proportion.
| Opération | Octets de la commande (hex) |
|---|---|
| Veille | 42 4D E4 00 00 01 73 |
| Réveil | 42 4D E4 00 01 01 74 |
| Mode passif (envoie seulement sur demande) | 42 4D E1 00 00 01 70 |
| Mode actif (envoie en continu, par défaut) | 42 4D E1 00 01 01 71 |
| Demander une mesure unique en mode passif | 42 4D E2 00 00 01 71 |
Indicateur de qualité de l'air à LED avec l'ESP32

L'ESP32 possède trois UART matériels dont tu peux router les broches vers n'importe quel GPIO ; SoftwareSerial est donc inutile. Comme l'ESP32 fonctionne en 3,3 V, tu peux relier directement les lignes RX et TX du capteur ; seul VCC doit encore venir de la broche 5V (VIN). Le code ci-dessous réveille le capteur avec la broche SET, attend 30 secondes, fait la moyenne PM2.5 et PM10 de 8 trames, puis remet le capteur en veille. Selon le résultat, une des LED verte, jaune ou rouge reliées aux GPIO 25, 26 et 27 s'allume. N'oublie pas de mettre une résistance de 220 Ω en série avec chaque LED ; tu peux vérifier la valeur avec le calculateur de résistance de LED.
1#include <Arduino.h>
2
3#define PMS_RX 16 // ESP32 RX2 <- sensör TX / ESP32 RX2 <- sensor TX
4#define PMS_TX 17 // ESP32 TX2 -> sensör RX / ESP32 TX2 -> sensor RX
5#define PMS_SET 4 // HIGH = çalış, LOW = uyku / HIGH = run, LOW = sleep
6#define LED_GREEN 25
7#define LED_YELLOW 26
8#define LED_RED 27
9
10HardwareSerial pmsSerial(2); // UART2
11
12uint8_t buf[32];
13uint8_t idx = 0;
14
15uint16_t word16(uint8_t i) {
16 return ((uint16_t)buf[i] << 8) | buf[i + 1]; // yüksek bayt önce / high byte first
17}
18
19// Geçerli çerçeve gelirse atmosferik PM2.5 ve PM10 döndürür
20// Returns atmospheric PM2.5 and PM10 when a valid frame arrives
21bool readPms(uint16_t &pm25, uint16_t &pm10) {
22 while (pmsSerial.available()) {
23 uint8_t c = pmsSerial.read();
24 if (idx == 0 && c != 0x42) continue;
25 if (idx == 1 && c != 0x4D) { idx = (c == 0x42) ? 1 : 0; continue; }
26 buf[idx++] = c;
27 if (idx < 32) continue;
28 idx = 0;
29 if (word16(2) != 28) return false; // uzunluk / length
30 uint16_t sum = 0;
31 for (uint8_t i = 0; i < 30; i++) sum += buf[i];
32 if (sum != word16(30)) return false; // sağlama toplamı / checksum
33 pm25 = word16(12);
34 pm10 = word16(14);
35 return true;
36 }
37 return false;
38}
39
40void showLevel(float pm25) {
41 digitalWrite(LED_GREEN, pm25 <= 15.0); // DSÖ 24 saat sınırı / WHO 24 h guideline
42 digitalWrite(LED_YELLOW, pm25 > 15.0 && pm25 <= 35.4);
43 digitalWrite(LED_RED, pm25 > 35.4); // EPA hassas grup sınırı / EPA sensitive group limit
44}
45
46void setup() {
47 Serial.begin(115200);
48 pinMode(PMS_SET, OUTPUT);
49 pinMode(LED_GREEN, OUTPUT);
50 pinMode(LED_YELLOW, OUTPUT);
51 pinMode(LED_RED, OUTPUT);
52 pmsSerial.begin(9600, SERIAL_8N1, PMS_RX, PMS_TX);
53}
54
55void loop() {
56 digitalWrite(PMS_SET, HIGH); // sensörü uyandır / wake the sensor
57 Serial.println("Isinma 30 sn / Warm-up 30 s");
58 delay(30000); // fan kararlı hale gelsin / let the fan stabilise
59
60 while (pmsSerial.available()) pmsSerial.read(); // eski verileri at / drop stale data
61 idx = 0;
62
63 uint32_t sum25 = 0, sum10 = 0;
64 uint8_t count = 0;
65 unsigned long start = millis();
66 while (count < 8 && millis() - start < 25000) {
67 uint16_t pm25, pm10;
68 if (readPms(pm25, pm10)) {
69 sum25 += pm25;
70 sum10 += pm10;
71 count++;
72 }
73 delay(10);
74 }
75
76 digitalWrite(PMS_SET, LOW); // uyku: fan ve lazer durur / sleep: fan and laser stop
77
78 if (count > 0) {
79 float avg25 = (float)sum25 / count;
80 float avg10 = (float)sum10 / count;
81 Serial.printf("PM2.5: %.1f PM10: %.1f ug/m3 (%u olcum / samples)\n", avg25, avg10, (unsigned)count);
82 showLevel(avg25);
83 } else {
84 Serial.println("Veri yok, kabloyu kontrol et / No data, check wiring");
85 }
86
87 delay(4UL * 60UL * 1000UL); // yaklaşık 5 dakikada bir ölç / measure about every 5 minutes
88}Dans le code, on fait la moyenne de 8 trames au lieu d'une seule mesure ; comme le capteur envoie une trame environ toutes les 2,3 secondes en mode stable, une fenêtre de 25 secondes suffit. Après le réveil, on vide le tampon, car les anciennes mesures accumulées pendant le préchauffage fausseraient la moyenne. Le seuil vert utilise la recommandation OMS de 15 µg/m³ sur 24 heures et le seuil rouge la limite EPA de 35,4 µg/m³ ; tu peux les modifier selon tes besoins. Le capteur fonctionne au maximum 55 secondes dans un cycle d'environ 5 minutes. Pour une station sur batterie, tu peux aussi mettre l'ESP32 en veille profonde pendant l'attente ; dans ce cas, n'oublie pas de verrouiller l'état de la broche avec gpio_hold_en() pour que SET reste à LOW. Afficher le résultat en chiffres sur un écran OLED rend aussi l'indicateur beaucoup plus informatif.
Code MicroPython avec le Raspberry Pi Pico
Le Raspberry Pi Pico possède deux UART matériels ; ici, nous avons choisi l'UART0, qui utilise les broches GP0 (TX) et GP1 (RX). Comme le Pico fonctionne en logique 3,3 V, il dialogue directement avec le capteur. Prends l'alimentation 5 V du capteur sur la broche VBUS (broche 40) ; elle ne fournit 5 V que lorsque le Pico est alimenté par l'USB. Sur batterie, tu peux produire 5 V avec un élévateur comme le MT3608 et alimenter à la fois le capteur et la broche VSYS du Pico. Dans cet exemple, la veille et le réveil se font par les commandes UART au lieu de la broche SET, ce qui te fait un fil de moins à brancher. Si tu débutes avec MicroPython, consulte d'abord l'article les bases de MicroPython.
1from machine import UART, Pin
2import time
3import struct
4
5uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1)) # GP0 -> sensör RX, GP1 <- sensör TX / GP0 -> sensor RX, GP1 <- sensor TX
6
7SLEEP = bytes([0x42, 0x4D, 0xE4, 0x00, 0x00, 0x01, 0x73]) # uyku / sleep
8WAKE = bytes([0x42, 0x4D, 0xE4, 0x00, 0x01, 0x01, 0x74]) # uyandır / wake up
9
10def read_exact(n, timeout_ms):
11 data = b""
12 t0 = time.ticks_ms()
13 while len(data) < n:
14 if time.ticks_diff(time.ticks_ms(), t0) > timeout_ms:
15 return None # zaman aşımı / timeout
16 chunk = uart.read(n - len(data))
17 if chunk:
18 data += chunk
19 return data
20
21def read_pms(timeout_ms=5000):
22 t0 = time.ticks_ms()
23 while time.ticks_diff(time.ticks_ms(), t0) < timeout_ms:
24 if read_exact(1, 500) != b"\x42": # başlangıç baytı / start byte
25 continue
26 if read_exact(1, 100) != b"\x4d":
27 continue
28 rest = read_exact(30, 500)
29 if rest is None:
30 continue
31 frame = b"\x42\x4d" + rest
32 if (frame[2] << 8 | frame[3]) != 28: # uzunluk / length
33 continue
34 if sum(frame[:30]) != (frame[30] << 8 | frame[31]): # sağlama toplamı / checksum
35 continue
36 return struct.unpack(">HHH", frame[10:16]) # PM1.0, PM2.5, PM10 (atmosferik / atmospheric)
37 return None
38
39def level(pm25):
40 if pm25 <= 15:
41 return "IYI / GOOD"
42 if pm25 <= 35.4:
43 return "ORTA / MODERATE"
44 return "KOTU / POOR"
45
46while True:
47 uart.write(WAKE)
48 time.sleep(30) # fan ısınması / fan warm-up
49 while uart.any():
50 uart.read() # eski verileri at / drop stale data
51 values = []
52 for _ in range(8):
53 r = read_pms()
54 if r:
55 values.append(r[1])
56 uart.write(SLEEP)
57 if values:
58 avg = sum(values) / len(values)
59 print("PM2.5: {:.1f} ug/m3 -> {}".format(avg, level(avg)))
60 else:
61 print("Veri yok / No data")
62 time.sleep(270) # yaklaşık 5 dakikalık döngü / about 5 minute cycleLa fonction utilitaire read_exact() attend avec un délai d'expiration que le nombre d'octets demandé soit arrivé ; ainsi, si un câble se débranche, le programme ne reste pas bloqué indéfiniment. Dans l'expression struct.unpack(">HHH", ...), le signe ">" indique que les données sont en big-endian et chaque "H" désigne un entier non signé de 16 bits ; les octets 10 à 15 sont les valeurs atmosphériques PM1.0, PM2.5 et PM10. Les deux derniers octets des commandes sont aussi une somme de contrôle : pour la commande de réveil, 0x42 + 0x4D + 0xE4 + 0x00 + 0x01 = 0x0174, donc la commande se termine par 01 74. Le capteur répond à certaines commandes par une courte trame de réponse ; la vérification de longueur écarte automatiquement ces réponses. Si tu utilises un Pico W, tu peux aussi envoyer les mesures à un serveur via MQTT.
Idées de projets avec le PMS5003
- Station de qualité de l'air domestique : affiche les PM2.5 en gros chiffres sur un écran OLED, avec à côté la température, l'humidité et la pression mesurées par un BME280.
- Alerte poêle et cheminée : fais sonner un buzzer quand les PM2.5 montent rapidement en peu de temps ; pour le monoxyde de carbone, utilise impérativement en plus un MQ-7 ou un détecteur certifié.
- Lampe AQI colorée : à la place des trois LED, allume un anneau WS2812B selon les couleurs de l'EPA.
- Purificateur d'air intelligent : règle la vitesse d'un ventilateur en PWM selon la mesure ; les détails sont dans l'article contrôle de ventilateur.
- Intégration Home Assistant : envoie les valeurs avec l'ESP32 via MQTT et suis les graphiques depuis ton téléphone.
- Enregistreur de pollution : écris les valeurs dans Google Sheets ou sur une carte SD pour tracer la courbe de pollution quotidienne tout l'hiver.
- Pack complet de l'air intérieur : mesure les particules avec le PMS5003, le dioxyde de carbone avec le MH-Z19 et les composés organiques volatils avec le CCS811.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Aucune donnée ne arrive | TX et RX ne sont pas croisés | Relie le TX du capteur au RX de la carte et le RX du capteur au TX de la carte |
| Le ventilateur ne tourne pas, aucune valeur | VCC alimenté en 3,3 V ou broche SET à LOW | Relie VCC à 5 V, mets SET à HIGH ou laisse-la libre |
| Chiffres absurdes qui sautent | Le débit n'est pas 9600 bauds ou la somme de contrôle n'est pas vérifiée | Utilise 9600 8N1 et vérifie la longueur et la somme de contrôle |
| Valeurs toujours entre 0 et quelques unités | L'air est vraiment propre ou l'orifice d'entrée est bouché | Teste le capteur près d'une source de poussière, laisse les orifices dégagés |
| Valeurs très élevées par temps de brouillard et de pluie | Humidité supérieure à 80 %, les gouttelettes d'eau sont comptées comme des particules | Mesure aussi l'humidité et marque les valeurs comme douteuses en cas d'humidité élevée |
| Premières mesures incohérentes après le réveil | Le ventilateur n'a pas encore atteint une vitesse stable | Attends au moins 30 secondes après le réveil |
| L'ESP32 redémarre au hasard | Le courant du ventilateur et du Wi-Fi fatigue une source USB faible | Utilise un bon câble et un adaptateur puissant, alimente si besoin le capteur avec une source 5 V séparée |
Avec quelques fils et une trame de 32 octets correctement décodée, le PMS5003 te permet de surveiller à faible coût et de façon assez cohérente l'air de ta maison et de ta rue ; voir de tes propres yeux comment les valeurs grimpent aux heures de chauffage en hiver sensibilise vraiment. Pour mesurer les gaz, tu peux l'associer au MQ-135 et monter une station complète de qualité de l'air. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas de circuit et codes, des projets comme l'alarme de gaz ESP32, la station de mesure LCD avec DHT22 et l'afficheur météo OLED avec enregistreur de température, et tu pourras facilement y ajouter le PMS5003.
Questions fréquentes
Quelle est la différence entre le PMS5003 et le PMS7003 ?
Ce sont tous deux des capteurs laser de particules de Plantower et ils utilisent la même trame de 32 octets et les mêmes commandes ; les codes de l'article fonctionnent donc sur les deux. Le PMS7003 a un boîtier plus fin et un connecteur différent, tandis que le PMS5003 est plus répandu et généralement moins cher. En pratique, leur précision de mesure est très proche.
Comment brancher un capteur de particules sur un Arduino Uno ?
Relie VCC du PMS5003 à 5V, GND à GND et la broche TX à D2, puis lis avec SoftwareSerial à 9600 bauds. Si tu veux envoyer des commandes au capteur, tu dois ramener la sortie TX 5 V de l'Uno à 3,3 V avec un diviseur de tension avant de la donner à la broche RX du capteur. Si tu ne fais que lire des données, tu peux laisser RX libre.
Quelle est la précision du PMS5003 ?
Le fabricant indique une précision de ±10 µg/m³ entre 0 et 100 µg/m³ et de ±10 % entre 100 et 500 µg/m³. Sa constance est bonne parmi les capteurs à bas coût, mais il ne remplace pas les stations de référence officielles. Quand l'humidité relative dépasse 80 %, les gouttelettes d'eau sont aussi comptées et les valeurs peuvent donc sortir plus hautes que la réalité.
À partir de quelle valeur de PM2.5 est-ce dangereux ?
L'OMS recommande que la moyenne sur 24 heures des PM2.5 ne dépasse pas 15 µg/m³. Sur l'échelle EPA, au-dessus de 35,5 µg/m³ c'est mauvais pour les groupes sensibles, au-dessus de 55,5 µg/m³ pour tout le monde, et au-dessus de 225,5 µg/m³ c'est considéré comme dangereux. Ces limites valent pour des moyennes ; lors d'un épisode de fumée de courte durée, la valeur instantanée peut être bien plus élevée.
Peut-on laisser le PMS5003 allumé en permanence ?
Oui, mais la durée de vie moyenne du laser et du ventilateur est d'environ 3 ans et le capteur consomme près de 100 mA en fonctionnement. Comme la qualité de l'air change lentement, le réveiller toutes les quelques minutes et mesurer après 30 secondes de préchauffage améliore nettement sa durée de vie et la consommation d'énergie. Pour la veille, il suffit de mettre la broche SET à LOW ou d'envoyer la commande de veille UART.
Un capteur de particules détecte-t-il la fumée ou le monoxyde de carbone ?
Le PMS5003 détecte très bien les particules fines de la fumée de cigarette et de poêle sous forme de PM1.0 et PM2.5, mais il ne mesure pas les gaz. Le monoxyde de carbone étant un gaz incolore sans particules, le capteur ne peut pas le remarquer. Dans les pièces où l'on utilise un poêle, garde toujours un détecteur de monoxyde de carbone séparé et certifié.
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…

Alarme de détection de gaz/fumée ESP32 MQ-2
Dans ce projet, la détection de gaz combustibles (GPL, méthane, propane) et de fumée est assurée par un module capteur de gaz MQ-2 ; dès la détection, une alarme sonore semblable à une sirène retentit via un buzzer passif. La sortie numérique de seuil (DO) du capteur est connectée au GPIO 4 de l'ESP32 ; quand le gaz ou la fumée dépasse le seuil, DO passe à LOW et l'alarme se déclenche. La sensibilité se règle via le potentiomètre du module. Le buzzer est piloté par tone().

Utilisation des capteurs de gaz
Un petit gardien qui repère une fuite de gaz dans la cuisine avant toi. Le capteur de gaz renifle l'air sans arrêt ; tant que tout va bien, la LED verte reste allumée, et quand le gaz dans l'air…

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.

ESP32 HTTPClient + API météo (avec écran OLED SSD1306)
L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. Contrairement à la version LCD I2C, on utilise ici un écran OLED SSD1306 (128×64), avec un grand texte et des icônes vectorielles pour un affichage plus riche. Sept icônes météo (soleil, pluie, neige et plus) sont dessinées à la volée, sans fichier bitmap.

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.

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.

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

