Componenti · 12 min di lettura

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.

CaratteristicaValore
Principio di misuraDiffusione laser
Dimensioni misurate0,3–10 µm (PM1.0, PM2.5, PM10 e numero di particelle in 6 classi di dimensione)
Intervallo di misura effettivo0–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³
Risoluzione1 µg/m³
Alimentazione5 V (4,5–5,5 V), necessaria per la ventola
Corrente≤ 100 mA in funzione, ≤ 200 µA in sleep
ComunicazioneUART, 9600 baud, 8N1, livello logico 3,3 V
Tempo di rispostaMeno di 10 secondi (30 s per dati stabili dopo il risveglio)
Ambiente di lavoroDa -10 a +60 °C, 0–99% di umidità relativa (senza condensa)
Dimensioni50 × 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 EPASignificato
0–9,0Buono (verde)Aria pulita, nessun rischio
9,1–35,4Moderato (giallo)Piccolo rischio per le persone molto sensibili
35,5–55,4Non salutare per gruppi sensibili (arancione)Asmatici, cardiopatici, bambini e anziani devono fare attenzione
55,5–125,4Non salutare (rosso)Tutti iniziano a risentirne
125,5–225,4Molto non salutare (viola)Limita le attività all'aperto
225,5 e oltrePericoloso (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 PMS5003FunzioneArduino UnoESP32Raspberry Pi Pico
1 VCCAlimentazione 5 V5V5V (VIN)VBUS (pin 40)
2 GNDMassaGNDGNDGND
3 SETHIGH o libero: attivo, LOW: sleepD4 (opzionale)GPIO 4GP2 (opzionale)
4 RXIngresso comandi al sensore (3,3 V)D3 (con partitore di tensione)GPIO 17 (TX2)GP0 (UART0 TX)
5 TXUscita dati dal sensore (3,3 V)D2GPIO 16 (RX2)GP1 (UART0 RX)
6 RESETLOW: resetLiberoLiberoLibero
7, 8Non collegati---
Il PMS5003 si alimenta a 5 V, ma i pin dati hanno livello logico 3,3 V. Non collegare i 5 V del pin D3 di Arduino Uno direttamente al pin RX del sensore: inserisci un partitore di tensione con una resistenza da 10 kΩ in serie e una da 20 kΩ verso GND, oppure un convertitore di livello logico. Questo partitore riduce i 5 V a circa 3,33 V; puoi verificare i valori con il calcolatore del partitore di tensione. Se non invierai mai comandi al sensore, lasciare RX scollegato è altrettanto sicuro. Nell'altro senso non ci sono problemi: l'uscita TX a 3,3 V del sensore viene letta da Uno come livello alto.

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.

ByteContenutoUnità
0–1Inizio: 0x42 0x4D-
2–3Lunghezza del frame (28)byte
4–5PM1.0 (CF=1, particella standard)µg/m³
6–7PM2.5 (CF=1)µg/m³
8–9PM10 (CF=1)µg/m³
10–11PM1.0 (ambiente atmosferico)µg/m³
12–13PM2.5 (ambiente atmosferico)µg/m³
14–15PM10 (ambiente atmosferico)µg/m³
16–27Numero di particelle maggiori di 0,3 / 0,5 / 1,0 / 2,5 / 5,0 / 10 µm (6 valori)numero / 0,1 L
28–29Riservato-
30–31Checksum (somma dei byte 0–29)-
Nel frame ci sono due gruppi PM distinti. I valori CF=1 sono calcolati per l'ambiente di calibrazione di fabbrica, mentre i valori ambiente atmosferico sono pensati per misure in casa e all'aperto. A basse concentrazioni (sotto circa 30 µg/m³) i due coincidono; all'aumentare della concentrazione CF=1 risulta più alto. Per un indicatore da casa o da balcone usa i valori atmosferici (byte 10–15).

Leggere il PMS5003 con Arduino Uno passo dopo passo

  1. Inserisci il cavo del sensore nella scheda adattatrice; collega VCC al pin 5V di Uno e GND a GND.
  2. Collega il pin TX del sensore a D2; questo pin sarà l'RX di SoftwareSerial.
  3. 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.
  4. Carica il codice qui sotto e apri il Monitor Seriale a 115200 baud.
  5. Ignora i valori dei primi 30 secondi; le misure si stabilizzano quando la velocità della ventola si assesta.
  6. Scuoti un panno impolverato a pochi centimetri dal sensore o soffia su una candela appena spenta e osserva i valori che salgono.
C++ (Arduino IDE)
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().

Poiché la porta seriale hardware di Uno (D0/D1) è condivisa con l'USB, se colleghi lì il sensore dovrai scollegare il cavo a ogni caricamento del codice; per questo usiamo SoftwareSerial. SoftwareSerial funziona senza problemi a 9600 baud, ma può ascoltare una sola porta software alla volta e disattiva brevemente gli interrupt durante la ricezione di un byte. Se insieme alle librerie Servo o NeoPixel noti sfarfallii o perdita di dati, la soluzione più pulita è spostare il sensore sulla porta Serial1 di un Arduino Mega o su un ESP32.

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.

OperazioneByte del comando (hex)
Sleep42 4D E4 00 00 01 73
Risveglio42 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à passiva42 4D E2 00 00 01 71

Indicatore LED della qualità dell'aria con ESP32

Scheda di sviluppo ESP32
Grazie ai suoi tre UART hardware, con ESP32 leggi il PMS5003 senza bisogno di SoftwareSerial.

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.

C++ (Arduino IDE)
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.

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 cycle

La 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

SintomoCausa probabileSoluzione
Non arriva nessun datoTX e RX non sono incrociatiCollega il TX del sensore all'RX della scheda e l'RX del sensore al TX della scheda
La ventola non gira, nessun valoreVCC alimentato a 3,3 V o pin SET a LOWCollega VCC a 5 V, porta SET a HIGH o lascialo libero
Numeri senza senso che saltanoBaud rate diverso da 9600 o checksum non verificatoUsa 9600 8N1 e verifica lunghezza e checksum
Valori sempre tra 0 e pochi puntiL'aria è davvero pulita o il foro di ingresso è ostruitoProva il sensore vicino a una fonte di polvere, lascia i fori liberi
Valori molto alti con nebbia e pioggiaUmidità oltre l'80%, le goccioline d'acqua sono contate come particelleMisura anche l'umidità e segna i valori come dubbi quando è alta
Prime misure incoerenti dopo il risveglioLa ventola non ha ancora raggiunto una velocità stabileDopo il risveglio aspetta almeno 30 secondi
ESP32 si riavvia a casoLa corrente di ventola e Wi-Fi mette in difficoltà un'alimentazione USB deboleUsa un buon cavo e un alimentatore potente, se serve alimenta il sensore da una fonte 5 V separata
Posiziona il sensore a circa 1–1,5 m da terra, con i fori di ingresso e uscita liberi; una scatola stretta che copre i fori falsa la misura. Se lo usi all'aperto, costruisci una protezione che ripari dalla pioggia ma lasci passare l'aria, e tienilo lontano dal sole diretto e dalle bocchette di ventilazione. Le misure singole sono rumorose: una media mobile rende il tuo indicatore molto più stabile e affidabile.

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.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

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…

4.7(47)
83
Allarme rilevatore di gas/fumo ESP32 MQ-2
ES-20Intermedio

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

4.7(29)
44
Utilizzo del sensore di gas
AR-51Principiante
Premium

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…

4.6(37)
50
ESP32 DHT22 Temperatura e umidità (con display LCD)
ES-15Intermedio

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.

4.8(38)
57
ESP32 HTTPClient + API meteo (con display OLED SSD1306)
ES-32Avanzato
Premium

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.

4.3(10)
22
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

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.

4.7(7)
12
ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
ES-33Avanzato
Premium

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.

4.3(10)
16
Orologio a matrice di punti, calendario e stazione meteo (MAX7219, DS1307)
AR-85Intermedio
Premium

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.

5.0(50)
66