Sensor de polvo PMS5003 con Arduino: mide PM1.0, PM2.5 y PM10
Conecta el sensor de polvo PMS5003 a Arduino, ESP32 y Pico: pines UART, trama de 32 bytes, modo de reposo y un indicador LED de calidad del aire PM2.5.
El sensor de polvo es la herramienta más eficaz para convertir en números las partículas invisibles del aire en proyectos con Arduino, y el modelo más usado es el sensor láser PMS5003 de Plantower. Esta pequeña caja aspira aire con un ventilador, lo ilumina con un haz láser y analiza la luz dispersada para darte las concentraciones de PM1.0, PM2.5 y PM10 en microgramos por metro cúbico (µg/m³). Envía los resultados por sí solo cada pocos segundos por una línea UART a 9600 baudios, así que puedes leerlo con Arduino Uno, ESP32 o Raspberry Pi Pico con solo unos cables.
En invierno, el humo de estufas y calefacciones, el tráfico intenso y la niebla hacen que el polvo fino suba rápido en las ciudades, y muchas veces no lo notas a simple vista. En este artículo aprenderás cómo funciona el PMS5003, cómo decodificar su trama de 32 bytes, cómo ponerlo en modo de reposo para alargar su vida y cómo hacer un indicador de calidad del aire que se enciende en verde, amarillo o rojo según los valores. Tienes el código listo con SoftwareSerial para Uno, UART por hardware para ESP32 y MicroPython para Pico.
¿Qué es el sensor de polvo PMS5003 y cómo funciona?
El principio de funcionamiento del PMS5003 es la dispersión láser. Un pequeño ventilador introduce aire por el orificio de entrada hasta la cámara de medición. Cuando el haz láser que atraviesa la cámara choca con las partículas, la luz se dispersa en todas direcciones y un fotodiodo capta esos breves destellos. La intensidad del destello depende del tamaño de la partícula y el número de destellos, de la cantidad. El microcontrolador interno clasifica los destellos en tamaños entre 0,3 µm y 10 µm, calcula cuántas partículas hay en 0,1 litros de aire y las convierte en densidad de masa con su calibración de fábrica. Tú solo lees los resultados ya calculados por el puerto serie.
PM viene del inglés "particulate matter", es decir, material particulado; el número indica el diámetro máximo de la partícula en micrómetros. PM10 incluye todas las partículas de menos de 10 µm (polen, polvo de obra, polvo de carretera) y suele quedarse en la nariz y la garganta. PM2.5 son partículas de menos de 2,5 µm, unas 30 veces más finas que un cabello; llegan hasta el fondo de los pulmones y es el valor que más se vigila por la salud. PM1.0 es la fracción más fina, sobre todo hollín y humo de combustión. Como PM1.0 está contenido en PM2.5 y este en PM10, siempre se cumple PM1.0 ≤ PM2.5 ≤ PM10.
| Característica | Valor |
|---|---|
| Principio de medición | Dispersión láser |
| Tamaños medidos | 0,3–10 µm (PM1.0, PM2.5, PM10 y conteo de partículas en 6 clases de tamaño) |
| Rango efectivo | 0–500 µg/m³ (máximo 1000 µg/m³ o más) |
| Precisión | ±10 µg/m³ entre 0 y 100 µg/m³, ±10 % entre 100 y 500 µg/m³ |
| Resolución | 1 µg/m³ |
| Alimentación | 5 V (4,5–5,5 V), necesaria para el ventilador |
| Corriente | ≤ 100 mA en funcionamiento, ≤ 200 µA en reposo |
| Comunicación | UART, 9600 baudios, 8N1, nivel lógico de 3,3 V |
| Tiempo de respuesta | Menos de 10 segundos (30 s tras despertar para datos estables) |
| Entorno de trabajo | -10 a +60 °C, 0–99 % de humedad relativa (sin condensación) |
| Tamaño | 50 × 38 × 21 mm |
| Vida media (MTTF) | Al menos 3 años |
¿Qué significan los valores de PM2.5 y PM10?
Para interpretar el número que da el sensor se usan escalas oficiales. La guía de 2021 de la Organización Mundial de la Salud (OMS) recomienda como límite para PM2.5 15 µg/m³ de media en 24 horas y 5 µg/m³ de media anual; para PM10, 45 µg/m³ en 24 horas y 15 µg/m³ al año. El índice de calidad del aire (AQI) de la Agencia de Protección Ambiental de EE. UU. (EPA) divide PM2.5 en seis niveles de color. Como estas escalas se definen con medias de 24 horas, en tu indicador casero es mucho más correcto usar una media de unos minutos que una sola medición instantánea.
| PM2.5 (µg/m³, 24 horas) | Nivel EPA | Significado |
|---|---|---|
| 0–9,0 | Buena (verde) | Aire limpio, sin riesgo |
| 9,1–35,4 | Moderada (amarillo) | Riesgo pequeño para personas muy sensibles |
| 35,5–55,4 | Dañina para grupos sensibles (naranja) | Personas con asma o enfermedades del corazón, niños y mayores deben tener cuidado |
| 55,5–125,4 | Dañina (rojo) | Todo el mundo empieza a verse afectado |
| 125,5–225,4 | Muy dañina (morado) | Limita las actividades al aire libre |
| 225,5 o más | Peligrosa (granate) | Nivel de emergencia |
Conexión del PMS5003: Arduino Uno, ESP32 y Pico
En la parte trasera del PMS5003 hay un pequeño conector de 8 pines con paso de 1,25 mm que no encaja en una protoboard. Si usas el cable que viene con el sensor y la pequeña placa adaptadora que suele incluirse en el paquete, los pines pasan a una regleta estándar de 2,54 mm. Los pines 7 y 8 no están conectados. SET y RESET tienen una resistencia pull-up interna, así que si no los vas a usar puedes dejarlos sin conectar.
| Pin del PMS5003 | Función | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|
| 1 VCC | Alimentación de 5 V | 5V | 5V (VIN) | VBUS (pin 40) |
| 2 GND | Tierra | GND | GND | GND |
| 3 SET | HIGH o libre: funciona, LOW: reposo | D4 (opcional) | GPIO 4 | GP2 (opcional) |
| 4 RX | Entrada de comandos al sensor (3,3 V) | D3 (con divisor de tensión) | GPIO 17 (TX2) | GP0 (UART0 TX) |
| 5 TX | Salida de datos del sensor (3,3 V) | D2 | GPIO 16 (RX2) | GP1 (UART0 RX) |
| 6 RESET | LOW: reinicia | Libre | Libre | Libre |
| 7, 8 | Sin conexión | - | - | - |
Trama de datos: qué significan los 32 bytes
En el modo activo por defecto, el sensor envía el resultado de la medición por sí solo y de forma continua en una trama de 32 bytes. La trama siempre empieza con los bytes 0x42 y 0x4D (ASCII "BM"); después vienen la longitud de la trama (28), 13 datos de 16 bits y 2 bytes de suma de verificación. Cada valor de 16 bits se transmite primero el byte alto y luego el bajo (big-endian). La suma de verificación es igual a la suma de los primeros 30 bytes, y comprobarla es la única forma fiable de descartar tramas corrompidas por ruido en el cable. Cuando la calidad del aire cambia poco, el sensor envía una trama más o menos cada 2,3 segundos; cuando cambia rápido, cada 200–800 ms. Si te interesa la base del protocolo, echa un vistazo al artículo sobre la comunicación serie UART.
| Byte | Contenido | Unidad |
|---|---|---|
| 0–1 | Inicio: 0x42 0x4D | - |
| 2–3 | Longitud de la trama (28) | bytes |
| 4–5 | PM1.0 (CF=1, partícula estándar) | µg/m³ |
| 6–7 | PM2.5 (CF=1) | µg/m³ |
| 8–9 | PM10 (CF=1) | µg/m³ |
| 10–11 | PM1.0 (ambiente atmosférico) | µg/m³ |
| 12–13 | PM2.5 (ambiente atmosférico) | µg/m³ |
| 14–15 | PM10 (ambiente atmosférico) | µg/m³ |
| 16–27 | Número de partículas mayores de 0,3 / 0,5 / 1,0 / 2,5 / 5,0 / 10 µm (6 valores) | unidades / 0,1 L |
| 28–29 | Reservado | - |
| 30–31 | Suma de verificación (suma de los bytes 0–29) | - |
Cómo leer el PMS5003 con Arduino Uno paso a paso
- Conecta el cable del sensor a la placa adaptadora; une VCC al pin 5V del Uno y GND a GND.
- Conecta el pin TX del sensor a D2; este pin será el RX de SoftwareSerial.
- Si piensas enviar comandos, conecta el pin RX del sensor a D3 a través de un divisor de tensión de 10 kΩ / 20 kΩ; si no, déjalo libre.
- Carga el código siguiente y abre el Monitor Serie a 115200 baudios.
- Ignora los valores de los primeros 30 segundos; las mediciones se estabilizan cuando la velocidad del ventilador se asienta.
- Sacude un trapo polvoriento a unos centímetros del sensor o apaga una vela soplándola y observa cómo suben los valores.
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}El corazón del código es la función readPms(). Lee los bytes recibidos uno a uno, busca primero la pareja de inicio 0x42 y 0x4D y luego los guarda en un búfer hasta completar 32 bytes. Al terminar la trama, comprueba que el campo de longitud sea 28 y que la suma de los primeros 30 bytes coincida con la suma de verificación de los dos últimos; si ambas cosas son correctas, copia los valores en la estructura. Como la función recibe un parámetro de tipo Stream, el mismo código funciona sin cambios con SoftwareSerial, con el Serial1 de un Arduino Mega o con el HardwareSerial del ESP32. Como loop() no hace ninguna espera, puedes añadir otras tareas; si necesitas temporizar, lo mejor es usar millis() en lugar de delay().
Modo de reposo: pin SET y comandos UART
Si el láser y el ventilador del PMS5003 funcionan de forma continua, su vida media es de unos 3 años y durante ese tiempo el sensor consume casi 100 mA sin parar. Sin embargo, la calidad del aire cambia despacio a lo largo de minutos, así que basta con medir cada pocos minutos. Puedes dormir el sensor de dos formas: poniendo el pin SET en LOW o enviando por UART el comando de reposo de 7 bytes. En reposo el ventilador y el láser se paran y la corriente baja de 200 µA. Tras despertarlo, debes esperar al menos 30 segundos a que se estabilice la velocidad del ventilador antes de leer. Por ejemplo, si trabajas con un ciclo de 5 minutos, con 30 segundos de calentamiento y 20 de medición, el sensor está activo solo una sexta parte del tiempo; el consumo de energía y el desgaste del láser bajan en la misma proporción.
| Operación | Bytes del comando (hex) |
|---|---|
| Reposo | 42 4D E4 00 00 01 73 |
| Despertar | 42 4D E4 00 01 01 74 |
| Modo pasivo (solo envía cuando se pide) | 42 4D E1 00 00 01 70 |
| Modo activo (envío continuo, por defecto) | 42 4D E1 00 01 01 71 |
| Pedir una medición en modo pasivo | 42 4D E2 00 00 01 71 |
Indicador LED de calidad del aire con ESP32

El ESP32 tiene tres UART por hardware y puedes dirigir sus pines a cualquier GPIO que quieras, así que no hace falta SoftwareSerial. Como el ESP32 trabaja a 3,3 V, puedes conectar directamente las líneas RX y TX del sensor; solo VCC debe seguir viniendo del pin 5V (VIN). El código siguiente despierta el sensor con el pin SET, espera 30 segundos, calcula la media de PM2.5 y PM10 de 8 tramas y vuelve a dormir el sensor. Según el resultado se enciende uno de los LED verde, amarillo o rojo conectados a los GPIO 25, 26 y 27. No olvides poner una resistencia en serie de 220 Ω en cada LED; puedes comprobar el valor con la calculadora de resistencia para 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}En el código se toma la media de 8 tramas en lugar de una sola medición; como el sensor envía una trama cada 2,3 segundos aproximadamente en modo estable, una ventana de 25 segundos es suficiente. Tras despertar se vacía el búfer, porque las mediciones antiguas acumuladas durante el calentamiento estropean la media. Como umbral verde se usó la recomendación de 15 µg/m³ en 24 horas de la OMS y como umbral rojo el límite de 35,4 µg/m³ de la EPA; puedes cambiarlos según tus necesidades. El sensor funciona como máximo 55 segundos de cada ciclo de unos 5 minutos. Para una estación con batería, también puedes poner el ESP32 en sueño profundo durante la espera; en ese caso no olvides bloquear el estado del pin con gpio_hold_en() para que SET permanezca en LOW. Mostrar el resultado como cifra en una pantalla OLED hace el indicador mucho más informativo.
Código MicroPython con Raspberry Pi Pico
La Raspberry Pi Pico tiene dos UART por hardware; aquí elegimos UART0, que usa los pines GP0 (TX) y GP1 (RX). Como la Pico trabaja con lógica de 3,3 V, habla directamente con el sensor. Toma la alimentación de 5 V del sensor del pin VBUS (pin 40); este pin solo da 5 V cuando la Pico se alimenta por USB. Si la usas con batería, puedes generar 5 V con un elevador como el MT3608 y darlos tanto al sensor como al pin VSYS de la Pico. En este ejemplo el reposo y el despertar se hacen con comandos UART en lugar del pin SET, así que conectas un cable menos. Si eres nuevo en MicroPython, antes puedes echar un vistazo a los fundamentos 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 función auxiliar read_exact() espera con tiempo límite hasta recibir el número de bytes pedido; así el programa no se queda colgado para siempre si se desconecta el cable. En struct.unpack(">HHH", ...), el signo ">" indica que los datos son big-endian y cada "H" un entero sin signo de 16 bits; los bytes 10–15 son PM1.0, PM2.5 y PM10 atmosféricos. Los dos últimos bytes de los comandos también son una suma de verificación: en el comando de despertar, 0x42 + 0x4D + 0xE4 + 0x00 + 0x01 = 0x0174, por eso el comando termina en 01 74. El sensor responde a algunos comandos con una breve trama de respuesta; la comprobación de longitud descarta esas respuestas automáticamente. Si usas una Pico W, también puedes enviar las mediciones a un servidor con MQTT.
Ideas de proyectos con el PMS5003
- Estación de calidad del aire para casa: muestra PM2.5 en cifras grandes en una pantalla OLED y, a su lado, la temperatura, la humedad y la presión con un BME280.
- Aviso para estufas y chimeneas: que suene un zumbador cuando PM2.5 sube rápido en poco tiempo; para el monóxido de carbono usa siempre además un MQ-7 o un detector certificado.
- Lámpara AQI de colores: en lugar de tres LED, enciende un anillo WS2812B con los colores de la EPA.
- Purificador de aire inteligente: ajusta con PWM la velocidad de un ventilador según la medición; tienes los detalles en el artículo sobre el control de ventiladores.
- Integración con Home Assistant: envía los valores con el ESP32 por MQTT y mira las gráficas desde el móvil.
- Registrador de contaminación: guarda los valores en Google Sheets o en una tarjeta SD y saca la curva diaria de contaminación durante todo el invierno.
- Paquete completo de interior: mide las partículas con el PMS5003, el dióxido de carbono con el MH-Z19 y los compuestos orgánicos volátiles con el CCS811.
Errores comunes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| No llega ningún dato | TX y RX no están cruzados | Conecta el TX del sensor al RX de la placa y el RX del sensor al TX de la placa |
| El ventilador no gira y no llegan valores | VCC alimentado con 3,3 V o pin SET en LOW | Conecta VCC a 5 V y pon SET en HIGH o déjalo libre |
| Números sin sentido que saltan | La velocidad no es 9600 baudios o no se comprueba la suma de verificación | Usa 9600 8N1 y verifica la longitud y la suma de verificación |
| Los valores son siempre entre 0 y unos pocos | El aire está realmente limpio o el orificio de entrada está tapado | Prueba el sensor con una fuente de polvo cercana y deja los orificios libres |
| Valores demasiado altos con niebla y lluvia | La humedad supera el 80 % y las gotitas de agua se cuentan como partículas | Mide también la humedad y marca los valores como dudosos con humedad alta |
| Las primeras mediciones tras despertar son incoherentes | El ventilador aún no está a velocidad estable | Espera al menos 30 segundos tras despertarlo |
| El ESP32 se reinicia al azar | La corriente del ventilador y del Wi-Fi sobrecarga una fuente USB débil | Usa un cable de calidad y un adaptador potente; si hace falta, alimenta el sensor con una fuente de 5 V aparte |
Con el PMS5003, unos cuantos cables y una trama de 32 bytes bien decodificada puedes vigilar el aire de tu casa y de tu calle a bajo coste y con bastante coherencia; ver con tus propios ojos cómo suben los valores en las horas de estufa en invierno también crea mucha conciencia. Para medir gases, puedes combinarlo con el MQ-135 y montar una estación de calidad del aire completa. En la app de BlueGrays encontrarás proyectos como la alarma de gas con ESP32, la estación de medición con DHT22 y LCD o el registrador de clima y temperatura con OLED, con esquemas y código paso a paso, y podrás añadirles fácilmente el PMS5003.
Preguntas frecuentes
¿Cuál es la diferencia entre el PMS5003 y el PMS7003?
Ambos son sensores láser de polvo de Plantower y usan la misma trama de 32 bytes y los mismos comandos, así que el código de este artículo funciona en los dos. El PMS7003 tiene un cuerpo más delgado y otro conector; el PMS5003 es más común y suele ser más barato. Su precisión en la práctica es muy parecida.
¿Cómo se conecta un sensor de polvo a Arduino Uno?
Conecta VCC del PMS5003 a 5V, GND a GND y el pin TX a D2, y léelo con SoftwareSerial a 9600 baudios. Si vas a enviarle comandos, baja con un divisor de tensión los 5 V del TX del Uno a 3,3 V antes de darlos al pin RX del sensor. Si solo vas a leer datos, puedes dejar RX sin conectar.
¿Qué precisión tiene el PMS5003?
El fabricante indica una precisión de ±10 µg/m³ entre 0 y 100 µg/m³ y de ±10 % entre 100 y 500 µg/m³. Entre los sensores de bajo coste es consistente, pero no sustituye a las estaciones de referencia oficiales. Cuando la humedad relativa supera el 80 %, las gotitas de agua también se cuentan y los valores pueden salir más altos que los reales.
¿A partir de qué valor de PM2.5 es peligroso?
La OMS recomienda que la media de 24 horas de PM2.5 no supere 15 µg/m³. En la escala de la EPA, por encima de 35,5 µg/m³ es dañino para grupos sensibles, por encima de 55,5 µg/m³ para todo el mundo y por encima de 225,5 µg/m³ se considera peligroso. Estos límites son para medias; en un momento de humo breve, el valor instantáneo puede ser mucho mayor.
¿Se puede dejar el PMS5003 encendido todo el tiempo?
Se puede, pero la vida media del láser y del ventilador es de unos 3 años y el sensor consume casi 100 mA mientras funciona. Como la calidad del aire cambia despacio, despertarlo cada pocos minutos y medir tras 30 segundos de calentamiento mejora mucho su vida útil y el consumo de energía. Para dormirlo basta con poner el pin SET en LOW o enviar el comando de reposo por UART.
¿Un sensor de polvo detecta humo o monóxido de carbono?
El PMS5003 detecta muy bien las partículas finas del humo de cigarrillo y de estufa como PM1.0 y PM2.5, pero no mide gases. El monóxido de carbono es un gas incoloro y sin partículas, así que el sensor no lo percibe. En habitaciones con estufa, ten siempre un detector de monóxido de carbono aparte y certificado.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Temperatura y humedad con DHT11
¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

Alarma de detector de gas/humo ESP32 MQ-2
En este proyecto, la detección de gases combustibles (GLP, metano, propano) y humo se realiza mediante un módulo sensor de gas MQ-2; al detectarlos, se emite un sonido de alarma similar a una sirena a través de un zumbador pasivo. La salida digital de umbral (DO) del sensor se conecta al GPIO 4 del ESP32; cuando el gas o el humo superan el umbral, DO pasa a LOW y se activa la alarma. La sensibilidad se ajusta con el potenciómetro del módulo. El zumbador se controla con tone().

Uso del sensor de gas
Un pequeño vigilante que detecta un escape de gas en la cocina antes que tú. El sensor de gas olfatea el aire sin parar; mientras todo va bien se enciende el LED verde, y cuando el gas del aire…

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)
El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. A diferencia de la versión con LCD I2C, aquí usamos una pantalla OLED SSD1306 (128×64), con letra grande e iconos vectoriales para una vista más rica. Siete iconos del tiempo (soleado, lluvia, nieve y más) se dibujan al momento, sin archivos bitmap.

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.

Reloj matricial, calendario y estación meteorológica (MAX7219, DS1307)
Un panel de texto en movimiento para tu mesa o tu pared que muestra por turnos la hora, la fecha y el clima de la habitación.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

