Sensore polveri sottili Arduino: PMS5003 con PM2.5 e PM10
Collega il sensore PMS5003 ad Arduino, ESP32 e Pico: pin UART, frame da 32 byte, modalità sleep e indicatore LED della qualità dell'aria PM2.5.
Il sensore di polveri sottili è lo strumento più efficace per trasformare in numeri le particelle invisibili presenti nell'aria nei progetti Arduino, e il modello più usato è il sensore laser PMS5003 di Plantower. Questa piccola scatola aspira l'aria con una ventola, la illumina con un raggio laser e analizza la luce diffusa, restituendo le concentrazioni di PM1.0, PM2.5 e PM10 in microgrammi/metro cubo (µg/m³). Invia i risultati da solo ogni pochi secondi su una linea UART a 9600 baud, quindi si legge con pochi fili da Arduino Uno, ESP32 o Raspberry Pi Pico.
In inverno, con il fumo di stufe e caldaie, il traffico intenso e la nebbia, la concentrazione di polveri sottili nelle città sale rapidamente e spesso non te ne accorgi a occhio. In questo articolo imparerai come funziona il PMS5003, come decodificare il frame dati da 32 byte, come metterlo in modalità sleep per allungarne la vita e come costruire un indicatore della qualità dell'aria che si accende verde, giallo o rosso in base ai valori letti. Sono pronti i codici con SoftwareSerial per Uno, con UART hardware per ESP32 e in MicroPython per Pico.
Cos'è il sensore di polveri PMS5003 e come funziona?
Il principio di funzionamento del PMS5003 è la diffusione della luce laser. Una piccola ventola aspira l'aria dal foro di ingresso nella camera di misura. Quando il raggio laser che attraversa la camera colpisce le particelle presenti nell'aria, la luce si diffonde in tutte le direzioni e un fotodiodo cattura questi brevi impulsi luminosi. L'intensità dell'impulso dipende dalla dimensione della particella, mentre il numero di impulsi dipende dalla quantità. Il microcontrollore interno al sensore suddivide gli impulsi in classi di dimensione da 0,3 µm a 10 µm, calcola il numero di particelle in 0,1 litri d'aria e, con la calibrazione di fabbrica, lo converte in concentrazione di massa. Tu devi solo leggere i risultati già pronti dalla porta seriale.
PM sta per "particulate matter", cioè particolato; il numero accanto indica il diametro massimo della particella in micrometri. PM10 comprende tutte le particelle sotto i 10 µm (polline, polvere edile, polvere stradale) e per lo più si ferma nel naso e nella gola. PM2.5 indica le particelle sotto i 2,5 µm, circa 30 volte più sottili di un capello: scendono in profondità nei polmoni ed è il valore più monitorato per la salute. PM1.0 rappresenta la frazione più fine, in particolare fuliggine e fumo da combustione. Poiché PM1.0 è incluso in PM2.5 e PM2.5 in PM10, vale sempre PM1.0 ≤ PM2.5 ≤ PM10.
| Caratteristica | Valore |
|---|---|
| Principio di misura | Diffusione laser |
| Dimensioni misurate | 0,3–10 µm (PM1.0, PM2.5, PM10 e numero di particelle in 6 classi di dimensione) |
| Intervallo di misura effettivo | 0–500 µg/m³ (massimo 1000 µg/m³ e oltre) |
| Precisione | ±10 µg/m³ tra 0 e 100 µg/m³, ±10% tra 100 e 500 µg/m³ |
| Risoluzione | 1 µg/m³ |
| Alimentazione | 5 V (4,5–5,5 V), necessaria per la ventola |
| Corrente | ≤ 100 mA in funzione, ≤ 200 µA in sleep |
| Comunicazione | UART, 9600 baud, 8N1, livello logico 3,3 V |
| Tempo di risposta | Meno di 10 secondi (30 s per dati stabili dopo il risveglio) |
| Ambiente di lavoro | Da -10 a +60 °C, 0–99% di umidità relativa (senza condensa) |
| Dimensioni | 50 × 38 × 21 mm |
| Vita media (MTTF) | Almeno 3 anni |
Cosa significano i valori PM2.5 e PM10?
Per interpretare il numero fornito dal sensore si usano scale ufficiali. Le linee guida 2021 dell'Organizzazione Mondiale della Sanità (OMS) raccomandano per il PM2.5 un limite di 15 µg/m³ sulla media di 24 ore e 5 µg/m³ sulla media annuale; per il PM10, 45 µg/m³ sulle 24 ore e 15 µg/m³ sull'anno. L'indice di qualità dell'aria (AQI) dell'Agenzia statunitense per la protezione ambientale (EPA) divide invece il PM2.5 in sei livelli colorati. Poiché queste scale sono definite su una media di 24 ore, anche nel tuo indicatore domestico usare la media di alcuni minuti dà risultati molto più corretti di una singola misura istantanea.
| PM2.5 (µg/m³, 24 ore) | Livello EPA | Significato |
|---|---|---|
| 0–9,0 | Buono (verde) | Aria pulita, nessun rischio |
| 9,1–35,4 | Moderato (giallo) | Piccolo rischio per le persone molto sensibili |
| 35,5–55,4 | Non salutare per gruppi sensibili (arancione) | Asmatici, cardiopatici, bambini e anziani devono fare attenzione |
| 55,5–125,4 | Non salutare (rosso) | Tutti iniziano a risentirne |
| 125,5–225,4 | Molto non salutare (viola) | Limita le attività all'aperto |
| 225,5 e oltre | Pericoloso (bordeaux) | Livello di emergenza |
Collegamento dei pin del PMS5003: Arduino Uno, ESP32 e Pico
Sul retro del PMS5003 c'è un piccolo connettore a 8 pin con passo di 1,25 mm, che non si adatta alla breadboard. Se usi il cavo in dotazione e la piccola scheda adattatrice che di solito è inclusa nella confezione, i pin diventano una normale strip da 2,54 mm. I pin 7 e 8 sono inutilizzati. I pin SET e RESET hanno un pull-up interno al sensore, quindi se non ti servono puoi lasciarli scollegati.
| Pin PMS5003 | Funzione | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|
| 1 VCC | Alimentazione 5 V | 5V | 5V (VIN) | VBUS (pin 40) |
| 2 GND | Massa | GND | GND | GND |
| 3 SET | HIGH o libero: attivo, LOW: sleep | D4 (opzionale) | GPIO 4 | GP2 (opzionale) |
| 4 RX | Ingresso comandi al sensore (3,3 V) | D3 (con partitore di tensione) | GPIO 17 (TX2) | GP0 (UART0 TX) |
| 5 TX | Uscita dati dal sensore (3,3 V) | D2 | GPIO 16 (RX2) | GP1 (UART0 RX) |
| 6 RESET | LOW: reset | Libero | Libero | Libero |
| 7, 8 | Non collegati | - | - | - |
Frame dati: il significato dei 32 byte
Nella modalità attiva predefinita il sensore invia il risultato della misura da solo e di continuo sotto forma di un frame da 32 byte. Il frame inizia sempre con i byte 0x42 e 0x4D (ASCII "BM"); seguono la lunghezza del frame (28), 13 dati a 16 bit e 2 byte di checksum. Ogni valore a 16 bit viene trasmesso prima con il byte alto e poi con quello basso (big-endian). Il checksum è uguale alla somma dei primi 30 byte, e questo controllo è l'unico modo affidabile per scartare i frame corrotti dal rumore sul cavo. Quando la qualità dell'aria cambia poco il sensore invia un frame circa ogni 2,3 secondi, quando cambia rapidamente ogni 200–800 ms. Se vuoi capire le basi del protocollo, dai un'occhiata all'articolo sulla comunicazione seriale UART.
| Byte | Contenuto | Unità |
|---|---|---|
| 0–1 | Inizio: 0x42 0x4D | - |
| 2–3 | Lunghezza del frame (28) | byte |
| 4–5 | PM1.0 (CF=1, particella standard) | µg/m³ |
| 6–7 | PM2.5 (CF=1) | µg/m³ |
| 8–9 | PM10 (CF=1) | µg/m³ |
| 10–11 | PM1.0 (ambiente atmosferico) | µg/m³ |
| 12–13 | PM2.5 (ambiente atmosferico) | µg/m³ |
| 14–15 | PM10 (ambiente atmosferico) | µg/m³ |
| 16–27 | Numero di particelle maggiori di 0,3 / 0,5 / 1,0 / 2,5 / 5,0 / 10 µm (6 valori) | numero / 0,1 L |
| 28–29 | Riservato | - |
| 30–31 | Checksum (somma dei byte 0–29) | - |
Leggere il PMS5003 con Arduino Uno passo dopo passo
- Inserisci il cavo del sensore nella scheda adattatrice; collega VCC al pin 5V di Uno e GND a GND.
- Collega il pin TX del sensore a D2; questo pin sarà l'RX di SoftwareSerial.
- Se pensi di inviare comandi, collega il pin RX del sensore a D3 tramite un partitore di tensione 10 kΩ / 20 kΩ; altrimenti lascialo libero.
- Carica il codice qui sotto e apri il Monitor Seriale a 115200 baud.
- Ignora i valori dei primi 30 secondi; le misure si stabilizzano quando la velocità della ventola si assesta.
- Scuoti un panno impolverato a pochi centimetri dal sensore o soffia su una candela appena spenta e osserva i valori che salgono.
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}Il cuore del codice è la funzione readPms(). Legge i byte in arrivo uno a uno, cerca prima la coppia di inizio 0x42 e 0x4D e poi li scrive in un buffer finché non si arriva a 32 byte. A frame completo controlla che il campo lunghezza valga 28 e che la somma dei primi 30 byte sia uguale al checksum negli ultimi due byte; se entrambe le condizioni sono vere, copia i valori nella struttura. Poiché la funzione prende un parametro di tipo Stream, lo stesso codice funziona senza modifiche con SoftwareSerial, con Serial1 di Arduino Mega o con l'HardwareSerial di ESP32. Dato che loop() non fa mai attese, puoi aggiungere altre attività; se serve una temporizzazione, è meglio usare millis() al posto di delay().
Modalità sleep: pin SET e comandi UART
Con laser e ventola sempre accesi, la vita media del PMS5003 è di circa 3 anni e in questo periodo il sensore assorbe in continuo quasi 100 mA. Eppure la qualità dell'aria cambia lentamente nell'arco di minuti, quindi basta misurare ogni pochi minuti. Puoi mettere il sensore in sleep in due modi: portando il pin SET a LOW oppure inviando via UART il comando di sleep da 7 byte. In sleep ventola e laser si fermano e la corrente scende sotto i 200 µA. Dopo il risveglio devi aspettare almeno 30 secondi prima di leggere, finché la velocità della ventola si stabilizza. Se per esempio lavori con un ciclo ogni 5 minuti, con 30 secondi di riscaldamento e 20 secondi di misura, il sensore resta attivo solo per un sesto del tempo; il consumo energetico e l'usura del laser diminuiscono nella stessa proporzione.
| Operazione | Byte del comando (hex) |
|---|---|
| Sleep | 42 4D E4 00 00 01 73 |
| Risveglio | 42 4D E4 00 01 01 74 |
| Modalità passiva (invia solo su richiesta) | 42 4D E1 00 00 01 70 |
| Modalità attiva (invia in continuo, predefinita) | 42 4D E1 00 01 01 71 |
| Richiedi una misura singola in modalità passiva | 42 4D E2 00 00 01 71 |
Indicatore LED della qualità dell'aria con ESP32

ESP32 ha tre UART hardware e puoi instradarne i pin su qualsiasi GPIO, quindi SoftwareSerial non serve. Poiché ESP32 lavora a 3,3 V, puoi collegare direttamente le linee RX e TX del sensore; solo VCC deve comunque arrivare dal pin 5V (VIN). Il codice qui sotto risveglia il sensore con il pin SET, attende 30 secondi, calcola la media di PM2.5 e PM10 su 8 frame e rimette il sensore in sleep. In base al risultato si accende uno dei LED verde, giallo e rosso collegati ai GPIO 25, 26 e 27. Non dimenticare una resistenza in serie da 220 Ω per ogni LED; puoi verificare il valore con il calcolatore di resistenza per 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}Nel codice si calcola la media di 8 frame invece di una misura singola; poiché in modalità stabile il sensore invia un frame circa ogni 2,3 secondi, una finestra di 25 secondi è sufficiente. Dopo il risveglio il buffer viene svuotato, perché le vecchie misure accumulate durante il riscaldamento falserebbero la media. Come soglia verde è stato usato il valore OMS di 15 µg/m³ sulle 24 ore, come soglia rossa il limite EPA di 35,4 µg/m³; puoi cambiarli secondo le tue esigenze. Il sensore resta acceso al massimo 55 secondi in un ciclo di circa 5 minuti. Per una stazione a batteria puoi mettere anche l'ESP32 in deep sleep durante l'attesa; in tal caso, perché il pin SET resti a LOW, ricordati di bloccare lo stato del pin con gpio_hold_en(). Mostrare il risultato come numero su un display OLED rende l'indicatore molto più informativo.
Codice MicroPython con Raspberry Pi Pico
Raspberry Pi Pico ha due UART hardware; qui abbiamo scelto UART0, che usa i pin GP0 (TX) e GP1 (RX). Poiché Pico lavora con logica a 3,3 V, comunica direttamente con il sensore. Prendi l'alimentazione a 5 V del sensore dal pin VBUS (pin 40); questo pin fornisce 5 V solo quando Pico è alimentato via USB. Con l'uso a batteria puoi ottenere 5 V con un boost converter come l'MT3608 e darli sia al sensore sia al pin VSYS di Pico. In questo esempio sleep e risveglio avvengono con i comandi UART invece che con il pin SET, così colleghi un filo in meno. Se sei nuovo di MicroPython, dai prima un'occhiata all'articolo sulle basi di 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 funzione di supporto read_exact() attende con timeout finché non arriva il numero di byte richiesto; così, se il cavo si stacca, il programma non resta bloccato per sempre. Nell'espressione struct.unpack(">HHH", ...) il simbolo ">" indica che i dati sono big-endian e ogni "H" un intero a 16 bit senza segno; i byte 10–15 sono i valori atmosferici di PM1.0, PM2.5 e PM10. Anche gli ultimi due byte dei comandi sono un checksum: nel comando di risveglio 0x42 + 0x4D + 0xE4 + 0x00 + 0x01 = 0x0174, quindi il comando termina con 01 74. Il sensore risponde ad alcuni comandi con un breve frame di risposta; il controllo della lunghezza li scarta automaticamente. Se usi un Pico W, puoi anche inviare le misure a un server via MQTT.
Idee di progetto con il PMS5003
- Stazione di qualità dell'aria domestica: mostra il PM2.5 a grandi cifre su un display OLED e, accanto, temperatura, umidità e pressione con il BME280.
- Allarme per stufa e camino: fai suonare un buzzer quando il PM2.5 sale rapidamente in poco tempo; per il monossido di carbonio usa sempre in più un MQ-7 o un rilevatore certificato.
- Lampada AQI colorata: al posto dei tre LED accendi un anello WS2812B con i colori EPA.
- Purificatore d'aria intelligente: regola con il PWM la velocità di una ventola in base alla misura; i dettagli sono nell'articolo sul controllo delle ventole.
- Integrazione con Home Assistant: invia i valori con ESP32 tramite MQTT e segui i grafici dal telefono.
- Registratore dell'inquinamento: scrivi i valori su Google Sheets o su una scheda SD e ricava la curva giornaliera dell'inquinamento per tutto l'inverno.
- Kit completo per ambienti interni: misura le particelle con il PMS5003, l'anidride carbonica con l'MH-Z19 e i composti organici volatili con il CCS811.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Non arriva nessun dato | TX e RX non sono incrociati | Collega il TX del sensore all'RX della scheda e l'RX del sensore al TX della scheda |
| La ventola non gira, nessun valore | VCC alimentato a 3,3 V o pin SET a LOW | Collega VCC a 5 V, porta SET a HIGH o lascialo libero |
| Numeri senza senso che saltano | Baud rate diverso da 9600 o checksum non verificato | Usa 9600 8N1 e verifica lunghezza e checksum |
| Valori sempre tra 0 e pochi punti | L'aria è davvero pulita o il foro di ingresso è ostruito | Prova il sensore vicino a una fonte di polvere, lascia i fori liberi |
| Valori molto alti con nebbia e pioggia | Umidità oltre l'80%, le goccioline d'acqua sono contate come particelle | Misura anche l'umidità e segna i valori come dubbi quando è alta |
| Prime misure incoerenti dopo il risveglio | La ventola non ha ancora raggiunto una velocità stabile | Dopo il risveglio aspetta almeno 30 secondi |
| ESP32 si riavvia a caso | La corrente di ventola e Wi-Fi mette in difficoltà un'alimentazione USB debole | Usa un buon cavo e un alimentatore potente, se serve alimenta il sensore da una fonte 5 V separata |
Con pochi fili e un frame da 32 byte decodificato correttamente, il PMS5003 ti permette di monitorare a basso costo e con buona coerenza l'aria di casa e della tua strada; vedere con i tuoi occhi come i valori salgono nelle ore di accensione delle stufe in inverno aiuta anche a prendere consapevolezza. Usandolo insieme all'MQ-135 puoi costruire una stazione di qualità dell'aria completa. Nell'app BlueGrays trovi passo dopo passo, con schemi dei circuiti e codici, progetti come l'allarme gas con ESP32, la stazione di misura LCD con DHT22 e il registratore di meteo e temperatura con OLED, e puoi aggiungere facilmente il PMS5003 a questi progetti.
Domande frequenti
Qual è la differenza tra PMS5003 e PMS7003?
Sono entrambi sensori laser di polveri di Plantower e usano lo stesso frame dati da 32 byte e gli stessi comandi, quindi i codici dell'articolo funzionano su entrambi. Il PMS7003 ha un corpo più sottile e un connettore diverso, mentre il PMS5003 è più diffuso e di solito più economico. In pratica la precisione di misura è molto simile.
Come si collega un sensore di polveri ad Arduino Uno?
Collega VCC del PMS5003 a 5V, GND a GND e il pin TX a D2, poi leggi con SoftwareSerial a 9600 baud. Se vuoi inviare comandi al sensore, devi abbassare a 3,3 V con un partitore di tensione l'uscita TX a 5 V di Uno prima di darla al pin RX del sensore. Se devi solo leggere i dati, puoi lasciare RX libero.
Quanto è preciso il PMS5003?
Il produttore dichiara una precisione di ±10 µg/m³ tra 0 e 100 µg/m³ e di ±10% tra 100 e 500 µg/m³. Tra i sensori economici ha una buona coerenza, ma non sostituisce le stazioni di riferimento ufficiali. Quando l'umidità relativa supera l'80% vengono contate anche le goccioline d'acqua, quindi i valori possono risultare più alti di quelli reali.
Quale valore di PM2.5 è pericoloso?
L'OMS raccomanda che la media di 24 ore del PM2.5 non superi 15 µg/m³. Nella scala EPA, oltre 35,5 µg/m³ è non salutare per i gruppi sensibili, oltre 55,5 µg/m³ per tutti e oltre 225,5 µg/m³ è pericoloso. Questi limiti valgono per le medie; durante un episodio di fumo di breve durata il valore istantaneo può essere molto più alto.
Il PMS5003 si può lasciare sempre acceso?
Si può, ma la vita media di laser e ventola è di circa 3 anni e il sensore assorbe quasi 100 mA quando lavora. Poiché la qualità dell'aria cambia lentamente, svegliarlo ogni pochi minuti e misurare dopo 30 secondi di riscaldamento migliora in modo sensibile durata e consumo. Per lo sleep basta portare il pin SET a LOW oppure inviare il comando UART di sleep.
Un sensore di polveri rileva fumo o monossido di carbonio?
Il PMS5003 rileva molto bene come PM1.0 e PM2.5 le particelle fini del fumo di sigaretta e di stufa, ma non misura i gas. Il monossido di carbonio è un gas incolore e senza particelle, quindi il sensore non può accorgersene. Nei locali in cui si usa una stufa tieni sempre un rilevatore di monossido di carbonio separato e certificato.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Temperatura e umidità con DHT11
Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

Allarme rilevatore di gas/fumo ESP32 MQ-2
In questo progetto, il rilevamento di gas combustibili (GPL, metano, propano) e fumo viene effettuato tramite un modulo sensore di gas MQ-2; al rilevamento viene emesso un segnale acustico simile a una sirena tramite un cicalino passivo. L'uscita digitale di soglia (DO) del sensore viene collegata al GPIO 4 dell'ESP32; quando gas o fumo superano la soglia, DO passa a LOW e l'allarme si attiva. La sensibilità si regola tramite il potenziometro del modulo. Il cicalino è pilotato con tone().

Utilizzo del sensore di gas
Un piccolo guardiano che si accorge di una fuga di gas in cucina prima di te. Il sensore di gas annusa l'aria di continuo; finché va tutto bene resta acceso il LED verde, e quando il gas nell'aria…

ESP32 DHT22 Temperatura e umidità (con display LCD)
Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

ESP32 HTTPClient + API meteo (con display OLED SSD1306)
L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. A differenza della versione con LCD I2C, qui usiamo un display OLED SSD1306 (128×64), con testo grande e icone vettoriali per una resa più ricca. Sette icone meteo (sole, pioggia, neve e altre) vengono disegnate al volo, senza file bitmap.

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.

Orologio a matrice di punti, calendario e stazione meteo (MAX7219, DS1307)
Un pannello a scritte scorrevoli per la scrivania o la parete che mostra a turno l'ora, la data e il clima della stanza.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

