Componentes · 12 min de leitura

Sensor de poeira PMS5003 com Arduino: meça PM1.0, PM2.5 e PM10

Ligue o sensor de poeira PMS5003 ao Arduino, ESP32 e Pico: pinos UART, o quadro de dados de 32 bytes, modo de repouso e um indicador de qualidade do ar PM2.5 com LEDs.

Um sensor de poeira é a forma mais eficaz de transformar as partículas invisíveis do ar em números em projetos com Arduino, e o modelo mais usado é o sensor de poeira a laser PMS5003 da Plantower. Essa caixinha puxa o ar com uma ventoinha interna, ilumina-o com um feixe de laser e analisa a luz espalhada para informar as concentrações de PM1.0, PM2.5 e PM10 em microgramas por metro cúbico (µg/m³). Ele envia os resultados sozinho a cada poucos segundos por uma linha UART de 9600 baud, então um Arduino Uno, ESP32 ou Raspberry Pi Pico consegue lê-lo com apenas alguns fios.

No inverno, a fumaça de aquecedores a lenha e da calefação, o trânsito intenso e a neblina fazem os níveis de poeira fina subirem rapidamente nas cidades, e muitas vezes não dá para perceber a olho nu. Neste post você vai aprender como o PMS5003 funciona, como decodificar o quadro de dados de 32 bytes, como colocar o sensor em repouso para prolongar sua vida útil e como montar um indicador de qualidade do ar que acende verde, amarelo ou vermelho conforme as leituras. O código está pronto para o Uno com SoftwareSerial, para o ESP32 com UART de hardware e para o Pico com MicroPython.

O que é o sensor de poeira PMS5003 e como ele funciona?

O PMS5003 funciona pelo princípio do espalhamento de laser. Uma pequena ventoinha puxa o ar pela entrada do invólucro para a câmara de medição. Quando o feixe de laser que atravessa a câmara atinge partículas no ar, a luz se espalha em todas as direções e um fotodiodo capta esses breves pulsos de luz. A intensidade de um pulso está relacionada ao tamanho da partícula, e o número de pulsos à quantidade de partículas. O microcontrolador dentro do sensor separa os pulsos em classes de tamanho entre 0,3 µm e 10 µm, calcula a contagem de partículas em 0,1 litro de ar e converte isso em concentração de massa usando a calibração de fábrica. Você só precisa ler os resultados prontos pela porta serial.

PM significa “particulate matter” (material particulado); o número ao lado é o maior diâmetro da partícula em micrômetros. PM10 abrange todas as partículas menores que 10 µm (pólen, poeira de obra, poeira de rua) e fica retido principalmente no nariz e na garganta. PM2.5 abrange partículas menores que 2,5 µm, cerca de 30 vezes mais finas que um fio de cabelo; elas chegam ao fundo dos pulmões e são o valor mais acompanhado em termos de saúde. PM1.0 é a fração mais fina, principalmente fuligem e fumaça de combustão. Como o PM1.0 é contado dentro do PM2.5 e o PM2.5 dentro do PM10, sempre vale PM1.0 ≤ PM2.5 ≤ PM10.

CaracterísticaValor
Princípio de mediçãoEspalhamento de laser
Tamanhos medidos0,3–10 µm (PM1.0, PM2.5, PM10 e contagem de partículas em 6 classes de tamanho)
Faixa efetiva0–500 µg/m³ (máximo de 1000 µg/m³ ou mais)
Precisão±10 µg/m³ entre 0–100 µg/m³, ±10% entre 100–500 µg/m³
Resolução1 µg/m³
Alimentação5 V (4,5–5,5 V), necessária para a ventoinha
Corrente≤ 100 mA em funcionamento, ≤ 200 µA em repouso
ComunicaçãoUART, 9600 baud, 8N1, nível lógico de 3,3 V
Tempo de respostaMenos de 10 segundos (30 s para dados estáveis após acordar)
Ambiente de operação-10 a +60 °C, 0–99% de umidade relativa (sem condensação)
Tamanho50 × 38 × 21 mm
Vida útil média (MTTF)Pelo menos 3 anos

O que significam os valores de PM2.5 e PM10?

Para interpretar o número que o sensor fornece, usam-se escalas oficiais. A diretriz de 2021 da Organização Mundial da Saúde (OMS) recomenda limites máximos de 15 µg/m³ como média de 24 horas e 5 µg/m³ como média anual para PM2.5, e 45 µg/m³ (24 horas) e 15 µg/m³ (anual) para PM10. O índice de qualidade do ar (AQI) da Agência de Proteção Ambiental dos EUA (EPA) divide o PM2.5 em seis níveis com cores. Como essas escalas são definidas para médias de 24 horas, usar uma média de alguns minutos em vez de uma única leitura instantânea também dá resultados muito mais precisos no seu indicador caseiro.

PM2.5 (µg/m³, 24 h)Nível EPASignificado
0–9,0Bom (verde)O ar está limpo, sem risco
9,1–35,4Moderado (amarelo)Pequeno risco para pessoas muito sensíveis
35,5–55,4Insalubre para grupos sensíveis (laranja)Pessoas com asma ou doenças cardíacas, crianças e idosos devem ter cuidado
55,5–125,4Insalubre (vermelho)Todos começam a ser afetados
125,5–225,4Muito insalubre (roxo)Limite as atividades ao ar livre
225,5 ou maisPerigoso (bordô)Nível de emergência

Pinagem do PMS5003: Arduino Uno, ESP32 e Pico

Na parte de trás do PMS5003 há um pequeno conector de 8 pinos com passo de 1,25 mm, que não encaixa na protoboard. Se você usar o cabo que vem com o sensor e a pequena placa adaptadora que normalmente acompanha o pacote, os pinos viram uma barra de pinos padrão de 2,54 mm. Os pinos 7 e 8 não são usados. Os pinos SET e RESET têm pull-up dentro do sensor, então, se não for usá-los, pode deixá-los desconectados.

Pino do PMS5003FunçãoArduino UnoESP32Raspberry Pi Pico
1 VCCAlimentação de 5 V5V5V (VIN)VBUS (pino 40)
2 GNDTerraGNDGNDGND
3 SETHIGH ou aberto: funcionando, LOW: repousoD4 (opcional)GPIO 4GP2 (opcional)
4 RXEntrada de comandos para o sensor (3,3 V)D3 (com divisor de tensão)GPIO 17 (TX2)GP0 (UART0 TX)
5 TXSaída de dados do sensor (3,3 V)D2GPIO 16 (RX2)GP1 (UART0 RX)
6 RESETLOW: reiniciaAbertoAbertoAberto
7, 8Sem conexão---
O PMS5003 é alimentado com 5 V, mas seus pinos de dados usam lógica de 3,3 V. Não ligue os 5 V do pino D3 do Arduino Uno diretamente no pino RX do sensor; coloque no meio um divisor de tensão formado por um resistor de 10 kΩ em série e um resistor de 20 kΩ para o GND, ou um conversor de nível lógico. Esse divisor reduz 5 V para cerca de 3,33 V; você pode conferir os valores com a calculadora de divisor de tensão. Se não for enviar nenhum comando ao sensor, deixar o RX desconectado também é seguro. O sentido contrário não tem problema: o Uno lê a saída TX de 3,3 V do sensor como nível alto.

O quadro de dados: o que significam os 32 bytes

No modo ativo padrão, o sensor envia os resultados sozinho e continuamente em um quadro de 32 bytes. O quadro sempre começa com os bytes 0x42 e 0x4D (ASCII “BM”), seguidos do comprimento do quadro (28), 13 valores de dados de 16 bits e uma soma de verificação de 2 bytes. Cada valor de 16 bits é enviado com o byte alto primeiro e depois o byte baixo (big-endian). A soma de verificação é igual à soma dos primeiros 30 bytes, e conferi-la é a única forma confiável de descartar quadros corrompidos por ruído na fiação. Quando a qualidade do ar muda devagar, o sensor envia um quadro a cada 2,3 segundos aproximadamente, e quando muda rápido, a cada 200–800 ms. Se tiver curiosidade sobre o básico do protocolo, dê uma olhada no post sobre comunicação serial UART.

ByteConteúdoUnidade
0–1Início: 0x42 0x4D-
2–3Comprimento do quadro (28)bytes
4–5PM1.0 (CF=1, partícula padrão)µg/m³
6–7PM2.5 (CF=1)µg/m³
8–9PM10 (CF=1)µg/m³
10–11PM1.0 (ambiente atmosférico)µg/m³
12–13PM2.5 (ambiente atmosférico)µg/m³
14–15PM10 (ambiente atmosférico)µg/m³
16–27Contagem de partículas maiores que 0,3 / 0,5 / 1,0 / 2,5 / 5,0 / 10 µm (6 valores)contagem / 0,1 L
28–29Reservado-
30–31Soma de verificação (soma dos bytes 0–29)-
O quadro tem dois grupos de PM separados. Os valores CF=1 são calculados para o ambiente de calibração de fábrica, enquanto os valores de ambiente atmosférico são pensados para medições do ar interno e externo. Em concentrações baixas (abaixo de cerca de 30 µg/m³) os dois são iguais; à medida que a concentração sobe, o CF=1 fica maior. Para um indicador em casa ou na varanda, use os valores atmosféricos (bytes 10–15).

Lendo o PMS5003 com um Arduino Uno passo a passo

  1. Encaixe o cabo do sensor na placa adaptadora; ligue o VCC ao pino 5V do Uno e o GND ao GND.
  2. Ligue o pino TX do sensor ao D2; esse pino será o RX do SoftwareSerial.
  3. Se pretende enviar comandos, ligue o pino RX do sensor ao D3 através de um divisor de tensão de 10 kΩ / 20 kΩ; caso contrário, deixe-o desconectado.
  4. Carregue o código abaixo e abra o Monitor Serial em 115200 baud.
  5. Ignore as leituras dos primeiros 30 segundos; as medições ficam estáveis quando a velocidade da ventoinha se estabiliza.
  6. Sacuda um pano empoeirado a alguns centímetros do sensor, ou apague uma vela com um sopro, e observe os valores subirem.
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}

O coração do código é a função readPms(). Ela lê os bytes recebidos um a um, primeiro procura o par inicial 0x42 e 0x4D e depois grava no buffer até completar 32 bytes. Quando o quadro está completo, ela verifica se o campo de comprimento é 28 e se a soma dos primeiros 30 bytes é igual à soma de verificação dos dois últimos bytes; se ambos estiverem corretos, copia os valores para a struct. Como a função recebe um parâmetro do tipo Stream, o mesmo código funciona sem alterações com o SoftwareSerial, a Serial1 do Arduino Mega ou a HardwareSerial do ESP32. Como o loop() nunca fica esperando, você pode adicionar outras tarefas também; se precisar de temporização, o melhor é usar millis() em vez de delay().

A porta serial de hardware do Uno (D0/D1) é compartilhada com o USB, então, se você ligar o sensor ali, teria que desconectar o fio toda vez que carregasse o código; por isso usamos o SoftwareSerial. O SoftwareSerial funciona bem a 9600 baud, mas só consegue escutar uma porta de software por vez e desativa as interrupções brevemente enquanto recebe bytes. Se notar tremedeira ou perda de dados junto com as bibliotecas Servo ou NeoPixel, a solução mais limpa é mudar o sensor para a porta Serial1 de um Arduino Mega ou para um ESP32.

Modo de repouso: o pino SET e os comandos UART

Quando o laser e a ventoinha do PMS5003 funcionam sem parar, sua vida útil média é de cerca de 3 anos, e durante esse tempo o sensor consome perto de 100 mA constantemente. Só que a qualidade do ar muda devagar, ao longo de minutos, então medir uma vez a cada poucos minutos é suficiente. Você pode colocar o sensor em repouso de duas formas: colocar o pino SET em LOW ou enviar o comando de repouso de 7 bytes pela UART. Em repouso, a ventoinha e o laser param e a corrente cai para menos de 200 µA. Depois de acordá-lo, espere pelo menos 30 segundos para a velocidade da ventoinha se estabilizar antes de fazer leituras. Por exemplo, se funcionar a cada 5 minutos com 30 segundos de aquecimento e 20 segundos de medição, o sensor fica ativo só cerca de um sexto do tempo; tanto o consumo de energia quanto o desgaste do laser caem na mesma proporção.

AçãoBytes do comando (hex)
Repouso42 4D E4 00 00 01 73
Acordar42 4D E4 00 01 01 74
Modo passivo (envia só quando solicitado)42 4D E1 00 00 01 70
Modo ativo (envia continuamente, padrão)42 4D E1 00 01 01 71
Solicitar uma única leitura no modo passivo42 4D E2 00 00 01 71

Indicador de qualidade do ar com LEDs e ESP32

Placa de desenvolvimento ESP32
Graças às três UARTs de hardware do ESP32, você lê o PMS5003 sem precisar do SoftwareSerial.

O ESP32 tem três UARTs de hardware e você pode direcionar seus pinos para qualquer GPIO que quiser, então não precisa do SoftwareSerial. Como o ESP32 funciona com 3,3 V, você pode ligar as linhas RX e TX do sensor diretamente; só o VCC continua tendo que vir do pino 5V (VIN). O código abaixo acorda o sensor pelo pino SET, espera 30 segundos, calcula a média de PM2.5 e PM10 de 8 quadros e coloca o sensor em repouso de novo. Dependendo do resultado, acende um dos LEDs verde, amarelo e vermelho ligados aos GPIO 25, 26 e 27. Não esqueça um resistor de 220 Ω em série para cada LED; você pode conferir o valor com a calculadora de resistor para 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}

Em vez de uma única leitura, o código calcula a média de 8 quadros; como o sensor envia um quadro a cada 2,3 segundos aproximadamente no modo estável, uma janela de 25 segundos é suficiente para isso. O buffer é esvaziado depois de acordar, porque leituras antigas acumuladas durante o aquecimento distorceriam a média. A recomendação de 24 horas da OMS, de 15 µg/m³, é usada como limite do verde, e o limite da EPA de 35,4 µg/m³ como limite do vermelho; você pode alterá-los conforme sua necessidade. O sensor funciona no máximo 55 segundos do ciclo de cerca de 5 minutos. Para uma estação alimentada por bateria, você também pode colocar o ESP32 em deep sleep durante a espera; nesse caso, não esqueça de travar o estado do pino com gpio_hold_en() para que o pino SET continue em LOW. Mostrar o resultado como número em um display OLED também deixa o indicador muito mais informativo.

Código MicroPython com o Raspberry Pi Pico

O Raspberry Pi Pico tem duas UARTs de hardware; aqui escolhemos a UART0, que usa os pinos GP0 (TX) e GP1 (RX). Como o Pico funciona com lógica de 3,3 V, ele conversa diretamente com o sensor. Tire a alimentação de 5 V do sensor do pino VBUS (pino 40); esse pino só fornece 5 V quando o Pico está alimentado pelo USB. Para uso com bateria, você pode gerar 5 V com um conversor elevador como o MT3608 e alimentar tanto o sensor quanto o pino VSYS do Pico. Neste exemplo, o repouso e o despertar são feitos com comandos UART em vez do pino SET, então você liga um fio a menos. Se você é novo no MicroPython, dê uma olhada primeiro no post Fundamentos de 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

A função auxiliar read_exact() espera, com tempo limite, até chegar o número de bytes solicitado, para que o programa não trave para sempre se o fio se soltar. Em struct.unpack(">HHH", ...), o sinal “>” indica que os dados são big-endian e cada “H” representa um número sem sinal de 16 bits; os bytes 10–15 são os valores atmosféricos de PM1.0, PM2.5 e PM10. Os dois últimos bytes dos comandos também são uma soma de verificação: no comando de acordar, 0x42 + 0x4D + 0xE4 + 0x00 + 0x01 = 0x0174, então o comando termina com 01 74. O sensor responde a alguns comandos com um quadro de resposta curto; a verificação de comprimento descarta essas respostas automaticamente. Se você usa um Pico W, também pode enviar as leituras para um servidor via MQTT.

Ideias de projetos com o PMS5003

  • Estação de qualidade do ar em casa: mostre o PM2.5 em dígitos grandes em um display OLED, com temperatura, umidade e pressão de um BME280 ao lado.
  • Alarme para aquecedor a lenha e lareira: faça um buzzer tocar quando o PM2.5 subir rapidamente em pouco tempo; para monóxido de carbono, use sempre um MQ-7 separado ou um detector certificado.
  • Luminária AQI colorida: em vez de três LEDs, acenda um anel WS2812B nas cores da EPA.
  • Purificador de ar inteligente: ajuste a velocidade de uma ventoinha com PWM conforme a medição; os detalhes estão no post sobre controle de ventoinha.
  • Integração com o Home Assistant: envie os valores com um ESP32 via MQTT e acompanhe os gráficos pelo celular.
  • Registrador de poluição: grave os valores no Google Sheets ou em um cartão SD para traçar a curva diária de poluição durante todo o inverno.
  • Pacote completo para ambientes internos: meça partículas com o PMS5003, dióxido de carbono com o MH-Z19 e compostos orgânicos voláteis com o CCS811.

Erros comuns e como corrigi-los

SintomaCausa provávelSolução
Nenhum dado chegaTX e RX não estão cruzadosLigue o TX do sensor ao RX da placa e o RX do sensor ao TX da placa
A ventoinha não gira, sem dadosVCC alimentado com 3,3 V ou pino SET em LOWLigue o VCC em 5 V, coloque o SET em HIGH ou deixe-o aberto
Números sem sentido, pulandoBaud rate não é 9600 ou a soma de verificação não é conferidaUse 9600 8N1, verifique o comprimento e a soma de verificação
Valores sempre entre 0 e poucosO ar está realmente limpo ou a entrada está bloqueadaTeste o sensor perto de uma fonte de poeira, mantenha as aberturas livres
Valores muito altos com neblina e chuvaUmidade acima de 80%, gotículas de água contadas como partículasMeça também a umidade e marque as leituras como duvidosas com umidade alta
Primeiras leituras após acordar são inconsistentesA ventoinha ainda não atingiu velocidade estávelEspere pelo menos 30 segundos depois de acordar
O ESP32 reinicia aleatoriamenteA corrente da ventoinha e do Wi-Fi sobrecarrega uma alimentação USB fracaUse um bom cabo e um adaptador potente; se preciso, alimente o sensor com uma fonte de 5 V separada
Coloque o sensor a cerca de 1–1,5 m do chão, com as aberturas de entrada e saída livres; uma caixa apertada que bloqueie as aberturas estraga a medição. Se for usá-lo ao ar livre, faça uma proteção que o resguarde da chuva mas deixe o ar passar, e mantenha-o longe do sol direto e de saídas de ventilação. Leituras isoladas são ruidosas; usar uma média móvel deixa seu indicador muito mais estável e confiável.

Com o PMS5003, alguns fios e um quadro de 32 bytes decodificado corretamente, você consegue monitorar o ar da sua casa e da sua rua com baixo custo e de forma bastante consistente; ver com os próprios olhos como os valores sobem nos horários em que os aquecedores a lenha estão acesos no inverno também cria uma boa conscientização. Para medir gases, você pode combiná-lo com o MQ-135 e montar uma estação completa de qualidade do ar. No app BlueGrays você encontra projetos como um alarme de gás com ESP32, uma estação de medição com DHT22 e LCD e um registrador de clima e temperatura com OLED, passo a passo, com esquemas do circuito e código, e pode adicionar o PMS5003 a eles facilmente.

Perguntas frequentes

Qual é a diferença entre o PMS5003 e o PMS7003?

Ambos são sensores de poeira a laser da Plantower e usam o mesmo quadro de dados de 32 bytes e os mesmos comandos, então o código deste post funciona nos dois. O PMS7003 tem um corpo mais fino e um conector diferente, enquanto o PMS5003 é mais comum e geralmente mais barato. Na prática, a precisão de medição dos dois é muito parecida.

Como ligar um sensor de poeira a um Arduino Uno?

Ligue o VCC do PMS5003 ao 5V, o GND ao GND e o TX ao D2, e leia com o SoftwareSerial a 9600 baud. Se for enviar comandos ao sensor, reduza a saída TX de 5 V do Uno para 3,3 V com um divisor de tensão antes de ligá-la ao pino RX do sensor. Se for só ler dados, pode deixar o RX desconectado.

Qual é a precisão do PMS5003?

O fabricante especifica precisão de ±10 µg/m³ na faixa de 0–100 µg/m³ e de ±10% na faixa de 100–500 µg/m³. Sua consistência é boa entre os sensores de baixo custo, mas ele não substitui as estações de referência oficiais. Quando a umidade relativa passa de 80%, gotículas de água também são contadas, então as leituras podem sair mais altas que os valores reais.

Qual valor de PM2.5 é perigoso?

A OMS recomenda que a média de 24 horas de PM2.5 não ultrapasse 15 µg/m³. Na escala da EPA, acima de 35,5 µg/m³ é insalubre para grupos sensíveis, acima de 55,5 µg/m³ é insalubre para todos e acima de 225,5 µg/m³ é considerado perigoso. Esses limites valem para médias; durante uma rajada curta de fumaça, o valor instantâneo pode ser muito maior.

Dá para deixar o PMS5003 ligado o tempo todo?

Dá, mas a vida útil média do laser e da ventoinha é de cerca de 3 anos e o sensor consome perto de 100 mA em funcionamento. Como a qualidade do ar muda devagar, acordá-lo a cada poucos minutos e medir depois de 30 segundos de aquecimento melhora muito a vida útil e o consumo de energia. Para colocá-lo em repouso, basta colocar o pino SET em LOW ou enviar o comando de repouso pela UART.

Um sensor de poeira detecta fumaça ou monóxido de carbono?

O PMS5003 detecta muito bem as partículas finas da fumaça de cigarro e de aquecedores a lenha como PM1.0 e PM2.5, mas não mede gases. O monóxido de carbono é um gás incolor e sem partículas, então o sensor não consegue percebê-lo. Em cômodos com aquecedor a lenha, mantenha sempre um detector de monóxido de carbono separado e certificado.

Ver todos os projetos
Temperatura e umidade com DHT11
AR-55Intermediário

Temperatura e umidade com DHT11

Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

4.7(47)
83
Alarme detector de gás e fumaça com ESP32 e MQ-2
ES-20Intermediário

Alarme detector de gás e fumaça com ESP32 e MQ-2

Neste projeto, um módulo sensor de gás MQ-2 detecta gases combustíveis (LPG, metano e propano) e fumaça, acionando um alarme tipo sirene em um buzzer passivo. A saída digital de limiar (DO) do sensor é conectada ao GPIO 4 do ESP32. Quando a concentração de gás ou fumaça ultrapassa o limiar, DO passa para LOW e o alarme é acionado. A sensibilidade é ajustada pelo potenciômetro do módulo. O buzzer passivo é acionado com tone() para criar um efeito de sirene que alterna entre duas frequências.

4.7(29)
44
Uso de um sensor de gás
AR-51Iniciante
Premium

Uso de um sensor de gás

Um pequeno guardião que percebe um vazamento de gás na cozinha antes de você. O sensor de gás monitora o ar continuamente; enquanto está tudo bem, o LED verde fica aceso e, quando o gás no ar…

4.6(37)
50
Temperatura e umidade com ESP32 e DHT22 (com display LCD)
ES-15Intermediário

Temperatura e umidade com ESP32 e DHT22 (com display LCD)

Este projeto mede a temperatura e a umidade do ambiente com um sensor DHT22 e exibe os dados em tempo real em um LCD I2C 16x2. Os dados são lidos do sensor pelo protocolo de um fio (one-wire) com a biblioteca Adafruit DHT. Este projeto serve de base para estações meteorológicas IoT, automação residencial ou sistemas de monitoramento ambiental em estufas. A comunicação com o DHT22 é feita pelo pino GPIO 4 do ESP32.

4.8(38)
57
ESP32 HTTPClient + API de clima (com display OLED SSD1306)
ES-32Avançado
Premium

ESP32 HTTPClient + API de clima (com display OLED SSD1306)

Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Diferentemente da versão anterior com LCD I2C, aqui usamos um display OLED SSD1306 (128×64), que permite usar fontes grandes, ícones vetoriais e uma apresentação visual rica em uma única tela. Sete ícones vetoriais de condições do tempo (ensolarado, parcialmente nublado, nublado, chuvoso, com neve, com tempestade e com neblina) são desenhados durante a execução, sem arquivos bitmap.

4.3(10)
22
Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avançado
Premium

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.

4.7(7)
12
ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
ES-33Avançado
Premium

ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)

O modo de sono profundo do ESP32 reduz o consumo de corrente para ~10 µA ao desligar a CPU e a maioria dos periféricos, sendo essencial para dispositivos IoT alimentados por bateria. Neste projeto, usamos três fontes de despertar: um temporizador (15 segundos), um pino externo (EXT0 — botão no GPIO 33) e toque (T0/GPIO 4). As variáveis marcadas com RTC_DATA_ATTR são preservadas durante o sono profundo, mantendo os contadores de inicializações e de despertares por temporizador e botão.

4.3(10)
16
Relógio, calendário e estação meteorológica de matriz de pontos (MAX7219, DS1307)
AR-85Intermediário
Premium

Relógio, calendário e estação meteorológica de matriz de pontos (MAX7219, DS1307)

Um painel com texto em rolagem para sua mesa ou parede que mostra, em sequência, a hora, a data e as condições do ambiente.

5.0(50)
66