Komponen · 10 mnt baca

Sensor Debu PMS5003 dengan Arduino: Mengukur PM1.0, PM2.5, dan PM10

Hubungkan sensor debu PMS5003 ke Arduino, ESP32, dan Pico: pin UART, frame data 32 byte, mode sleep, dan indikator kualitas udara PM2.5 dengan LED.

Sensor debu adalah cara paling efektif untuk mengubah partikel tak kasatmata di udara menjadi angka dalam proyek Arduino, dan model yang paling banyak dipakai adalah sensor debu laser PMS5003 buatan Plantower. Kotak kecil ini menyedot udara dengan kipas bawaan, menyinarinya dengan berkas laser, lalu menganalisis cahaya yang terhambur untuk melaporkan konsentrasi PM1.0, PM2.5, dan PM10 dalam mikrogram per meter kubik (µg/m³). Sensor ini mengirim hasilnya sendiri setiap beberapa detik lewat jalur UART 9600 baud, jadi Arduino Uno, ESP32, atau Raspberry Pi Pico bisa membacanya hanya dengan beberapa kabel.

Di musim dingin, asap dari tungku dan pemanas, lalu lintas padat, dan kabut membuat kadar debu halus di kota naik dengan cepat, dan sering kali kamu tidak bisa melihatnya dengan mata. Di artikel ini kamu akan belajar cara kerja PMS5003, cara mengurai frame data 32 byte-nya, cara menidurkan sensor agar lebih awet, dan cara membuat indikator kualitas udara yang menyala hijau, kuning, atau merah sesuai hasil pembacaan. Kodenya sudah siap untuk Uno dengan SoftwareSerial, ESP32 dengan UART hardware, dan Pico dengan MicroPython.

Apa itu sensor debu PMS5003 dan bagaimana cara kerjanya?

PMS5003 bekerja dengan prinsip hamburan laser. Sebuah kipas kecil menarik udara dari lubang masuk di casing ke ruang pengukuran. Ketika berkas laser yang melewati ruang itu mengenai partikel di udara, cahaya terhambur ke segala arah dan sebuah fotodioda menangkap pulsa cahaya singkat ini. Kuat pulsa berkaitan dengan ukuran partikel, sedangkan jumlah pulsa berkaitan dengan banyaknya partikel. Mikrokontroler di dalam sensor memilah pulsa ke dalam kelas ukuran antara 0,3 µm dan 10 µm, menghitung jumlah partikel dalam 0,1 liter udara, lalu mengubahnya menjadi konsentrasi massa dengan kalibrasi pabrik. Kamu tinggal membaca hasil jadinya dari port serial.

PM adalah singkatan dari “particulate matter” (materi partikulat); angka di sebelahnya adalah diameter terbesar partikel dalam mikrometer. PM10 mencakup semua partikel yang lebih kecil dari 10 µm (serbuk sari, debu konstruksi, debu jalan) dan sebagian besar tertahan di hidung dan tenggorokan. PM2.5 mencakup partikel yang lebih kecil dari 2,5 µm, sekitar 30 kali lebih tipis dari rambut manusia; partikel ini bisa masuk jauh ke dalam paru-paru dan merupakan nilai yang paling diawasi untuk kesehatan. PM1.0 adalah fraksi paling halus, terutama jelaga dan asap dari pembakaran. Karena PM1.0 dihitung di dalam PM2.5 dan PM2.5 di dalam PM10, selalu berlaku PM1.0 ≤ PM2.5 ≤ PM10.

FiturNilai
Prinsip pengukuranHamburan laser
Ukuran yang diukur0,3–10 µm (PM1.0, PM2.5, PM10, dan jumlah partikel dalam 6 kelas ukuran)
Rentang efektif0–500 µg/m³ (maksimum hingga 1000 µg/m³ ke atas)
Akurasi±10 µg/m³ pada 0–100 µg/m³, ±10% pada 100–500 µg/m³
Resolusi1 µg/m³
Catu daya5 V (4,5–5,5 V), dibutuhkan untuk kipas
Arus≤ 100 mA ketika bekerja, ≤ 200 µA ketika sleep
KomunikasiUART, 9600 baud, 8N1, level logika 3,3 V
Waktu responsDi bawah 10 detik (30 dtk untuk data stabil setelah bangun)
Lingkungan kerja-10 sampai +60 °C, kelembapan relatif 0–99% (tanpa pengembunan)
Ukuran50 × 38 × 21 mm
Umur rata-rata (MTTF)Minimal 3 tahun

Apa arti nilai PM2.5 dan PM10?

Untuk menafsirkan angka dari sensor, dipakai skala resmi. Pedoman Organisasi Kesehatan Dunia (WHO) 2021 merekomendasikan batas atas 15 µg/m³ sebagai rata-rata 24 jam dan 5 µg/m³ sebagai rata-rata tahunan untuk PM2.5, serta 45 µg/m³ (24 jam) dan 15 µg/m³ (tahunan) untuk PM10. Indeks kualitas udara (AQI) dari Badan Perlindungan Lingkungan Amerika Serikat (EPA) membagi PM2.5 menjadi enam tingkat berkode warna. Karena skala ini didefinisikan untuk rata-rata 24 jam, memakai rata-rata beberapa menit alih-alih satu pembacaan instan juga memberi hasil yang jauh lebih akurat pada indikator di rumahmu.

PM2.5 (µg/m³, 24 jam)Tingkat EPAArtinya
0–9,0Baik (hijau)Udara bersih, tidak ada risiko
9,1–35,4Sedang (kuning)Risiko kecil bagi orang yang sangat sensitif
35,5–55,4Tidak sehat bagi kelompok sensitif (oranye)Penderita asma atau penyakit jantung, anak-anak, dan lansia perlu berhati-hati
55,5–125,4Tidak sehat (merah)Semua orang mulai terdampak
125,5–225,4Sangat tidak sehat (ungu)Batasi aktivitas di luar ruangan
225,5 ke atasBerbahaya (merah marun)Level darurat

Pinout PMS5003: Arduino Uno, ESP32, dan Pico

Di bagian belakang PMS5003 ada konektor kecil 8 pin dengan jarak 1,25 mm, yang tidak muat di breadboard. Kalau kamu memakai kabel bawaan sensor dan board adaptor kecil yang biasanya ikut dalam paket, pin-pinnya berubah menjadi header standar 2,54 mm. Pin 7 dan 8 tidak dipakai. Pin SET dan RESET sudah di-pull-up di dalam sensor, jadi kalau tidak dipakai, kamu bisa membiarkannya tidak terhubung.

Pin PMS5003FungsiArduino UnoESP32Raspberry Pi Pico
1 VCCCatu daya 5 V5V5V (VIN)VBUS (pin 40)
2 GNDGroundGNDGNDGND
3 SETHIGH atau dibiarkan: bekerja, LOW: sleepD4 (opsional)GPIO 4GP2 (opsional)
4 RXInput perintah ke sensor (3,3 V)D3 (dengan pembagi tegangan)GPIO 17 (TX2)GP0 (UART0 TX)
5 TXOutput data dari sensor (3,3 V)D2GPIO 16 (RX2)GP1 (UART0 RX)
6 RESETLOW: resetTidak dihubungkanTidak dihubungkanTidak dihubungkan
7, 8Tidak terhubung---
PMS5003 diberi daya 5 V, tetapi pin datanya memakai logika 3,3 V. Jangan sambungkan 5 V dari pin D3 Arduino Uno langsung ke pin RX sensor; pasang di antaranya pembagi tegangan dari resistor seri 10 kΩ dan resistor 20 kΩ ke GND, atau konverter level logika. Pembagi ini menurunkan 5 V menjadi sekitar 3,33 V; kamu bisa mengecek nilainya dengan kalkulator pembagi tegangan. Kalau kamu tidak akan mengirim perintah apa pun ke sensor, membiarkan RX tidak terhubung juga aman. Arah sebaliknya tidak masalah: Uno membaca output TX 3,3 V dari sensor sebagai level HIGH.

Frame data: arti 32 byte

Dalam mode aktif bawaan, sensor terus-menerus mengirim hasilnya sendiri sebagai frame 32 byte. Frame selalu diawali byte 0x42 dan 0x4D (ASCII “BM”), diikuti panjang frame (28), 13 nilai data 16-bit, dan checksum 2 byte. Setiap nilai 16-bit dikirim dengan byte tinggi dulu, lalu byte rendah (big-endian). Checksum sama dengan jumlah 30 byte pertama, dan memeriksanya adalah satu-satunya cara andal untuk menyaring frame yang rusak akibat derau kabel. Ketika kualitas udara berubah pelan, sensor mengirim frame sekitar setiap 2,3 detik, dan ketika berubah cepat setiap 200–800 ms. Kalau kamu penasaran dengan dasar protokolnya, lihat artikel Komunikasi Serial UART.

ByteIsiSatuan
0–1Awal: 0x42 0x4D-
2–3Panjang frame (28)byte
4–5PM1.0 (CF=1, partikel standar)µg/m³
6–7PM2.5 (CF=1)µg/m³
8–9PM10 (CF=1)µg/m³
10–11PM1.0 (lingkungan atmosfer)µg/m³
12–13PM2.5 (lingkungan atmosfer)µg/m³
14–15PM10 (lingkungan atmosfer)µg/m³
16–27Jumlah partikel yang lebih besar dari 0,3 / 0,5 / 1,0 / 2,5 / 5,0 / 10 µm (6 nilai)jumlah / 0,1 L
28–29Dicadangkan-
30–31Checksum (jumlah byte 0–29)-
Frame ini berisi dua kelompok PM terpisah. Nilai CF=1 dihitung untuk lingkungan kalibrasi pabrik, sedangkan nilai lingkungan atmosfer ditujukan untuk pengukuran udara di dalam dan di luar ruangan. Pada konsentrasi rendah (di bawah sekitar 30 µg/m³) keduanya sama; makin tinggi konsentrasi, CF=1 makin besar. Untuk indikator di rumah atau balkon, pakai nilai atmosfer (byte 10–15).

Membaca PMS5003 dengan Arduino Uno langkah demi langkah

  1. Colokkan kabel sensor ke board adaptor; hubungkan VCC ke pin 5V Uno dan GND ke GND.
  2. Hubungkan pin TX sensor ke D2; pin ini akan menjadi RX untuk SoftwareSerial.
  3. Kalau kamu berencana mengirim perintah, hubungkan pin RX sensor ke D3 lewat pembagi tegangan 10 kΩ / 20 kΩ; kalau tidak, biarkan tidak terhubung.
  4. Upload kode di bawah dan buka Serial Monitor di 115200 baud.
  5. Abaikan pembacaan selama 30 detik pertama; pengukuran menjadi stabil begitu kecepatan kipas sudah mantap.
  6. Kibaskan kain berdebu beberapa sentimeter dari sensor, atau tiup lilin sampai padam, lalu lihat nilainya naik.
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}

Inti kode ini adalah fungsi readPms(). Fungsi ini membaca byte yang masuk satu per satu, mencari pasangan awal 0x42 dan 0x4D lebih dulu, lalu menulis ke buffer sampai terisi 32 byte. Begitu frame lengkap, fungsi ini memeriksa bahwa kolom panjang bernilai 28 dan jumlah 30 byte pertama sama dengan checksum di dua byte terakhir; kalau keduanya benar, nilai-nilainya disalin ke struct. Karena fungsi ini menerima parameter bertipe Stream, kode yang sama bisa langsung dipakai dengan SoftwareSerial, Serial1 pada Arduino Mega, atau HardwareSerial pada ESP32. Karena loop() tidak pernah menunggu, kamu bisa menambahkan tugas lain juga; kalau butuh pengaturan waktu, sebaiknya pakai millis() alih-alih delay().

Port serial hardware Uno (D0/D1) dipakai bersama dengan USB, jadi kalau sensor dihubungkan ke sana, kamu harus mencabut kabelnya setiap kali meng-upload kode; karena itulah kita memakai SoftwareSerial. SoftwareSerial bekerja dengan baik di 9600 baud, tetapi hanya bisa mendengarkan satu port software dalam satu waktu dan mematikan interrupt sebentar selama menerima byte. Kalau kamu melihat gerakan bergetar (jitter) atau data hilang ketika memakai library Servo atau NeoPixel, solusi paling rapi adalah memindahkan sensor ke port Serial1 pada Arduino Mega atau ke ESP32.

Mode sleep: pin SET dan perintah UART

Jika laser dan kipas PMS5003 bekerja terus-menerus, umur rata-ratanya sekitar 3 tahun, dan selama itu sensor terus menarik arus mendekati 100 mA. Padahal kualitas udara berubah pelan dalam hitungan menit, jadi mengukur sekali setiap beberapa menit sudah cukup. Kamu bisa menidurkan sensor dengan dua cara: tarik pin SET ke LOW atau kirim perintah sleep 7 byte lewat UART. Selama sleep, kipas dan laser berhenti dan arus turun di bawah 200 µA. Setelah membangunkannya, kamu harus menunggu minimal 30 detik sampai kecepatan kipas mantap sebelum membaca. Misalnya, kalau sensor dijalankan setiap 5 menit dengan pemanasan 30 detik dan pengukuran 20 detik, sensor hanya aktif sekitar seperenam waktu; pemakaian energi dan keausan laser sama-sama berkurang dengan proporsi yang sama.

AksiByte perintah (hex)
Sleep42 4D E4 00 00 01 73
Bangun42 4D E4 00 01 01 74
Mode pasif (kirim hanya jika diminta)42 4D E1 00 00 01 70
Mode aktif (kirim terus-menerus, bawaan)42 4D E1 00 01 01 71
Minta satu pembacaan dalam mode pasif42 4D E2 00 00 01 71

Indikator kualitas udara dengan LED dan ESP32

Board pengembangan ESP32
Berkat tiga UART hardware di ESP32, kamu bisa membaca PMS5003 tanpa perlu SoftwareSerial.

ESP32 punya tiga UART hardware dan pin-pinnya bisa kamu arahkan ke GPIO mana pun, jadi kamu tidak perlu SoftwareSerial. Karena ESP32 bekerja di 3,3 V, jalur RX dan TX sensor bisa dihubungkan langsung; hanya VCC yang tetap harus diambil dari pin 5V (VIN). Kode di bawah membangunkan sensor lewat pin SET, menunggu 30 detik, mengambil rata-rata PM2.5 dan PM10 dari 8 frame, lalu menidurkan sensor lagi. Tergantung hasilnya, salah satu LED hijau, kuning, atau merah yang terhubung ke GPIO 25, 26, dan 27 akan menyala. Jangan lupa resistor seri 220 Ω untuk setiap LED; kamu bisa mengecek nilainya dengan kalkulator resistor 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}

Alih-alih satu pembacaan, kode ini mengambil rata-rata 8 frame; karena dalam kondisi stabil sensor mengirim frame sekitar setiap 2,3 detik, jendela 25 detik sudah cukup untuk itu. Buffer dikosongkan setelah sensor bangun karena pembacaan lama yang menumpuk selama pemanasan akan merusak rata-rata. Rekomendasi WHO 24 jam sebesar 15 µg/m³ dipakai sebagai ambang hijau dan batas EPA 35,4 µg/m³ sebagai ambang merah; kamu bisa mengubahnya sesuai kebutuhan. Sensor bekerja paling lama 55 detik dari siklus sekitar 5 menit. Untuk stasiun bertenaga baterai, kamu juga bisa memasukkan ESP32 ke mode deep sleep selama menunggu; dalam hal ini, jangan lupa mengunci status pin dengan gpio_hold_en() supaya pin SET tetap LOW. Menampilkan hasilnya sebagai angka di layar OLED juga membuat indikatornya jauh lebih informatif.

Kode MicroPython dengan Raspberry Pi Pico

Raspberry Pi Pico punya dua UART hardware; di sini kita memilih UART0 yang memakai pin GP0 (TX) dan GP1 (RX). Karena Pico memakai logika 3,3 V, ia bisa berkomunikasi langsung dengan sensor. Ambil catu daya 5 V untuk sensor dari pin VBUS (pin 40); pin ini hanya memberi 5 V ketika Pico diberi daya lewat USB. Untuk pemakaian dengan baterai, kamu bisa membangkitkan 5 V dengan konverter boost seperti MT3608 dan memberikannya ke sensor sekaligus ke pin VSYS Pico. Di contoh ini sleep dan bangun dilakukan dengan perintah UART, bukan pin SET, jadi kabel yang perlu disambung berkurang satu. Kalau kamu baru mengenal MicroPython, lihat dulu artikel dasar-dasar 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

Fungsi bantu read_exact() menunggu dengan batas waktu (timeout) sampai jumlah byte yang diminta tiba, jadi program tidak macet selamanya kalau kabelnya lepas. Pada struct.unpack(">HHH", ...), tanda “>” berarti data bersifat big-endian dan setiap “H” mewakili bilangan unsigned 16-bit; byte 10–15 adalah nilai atmosfer PM1.0, PM2.5, dan PM10. Dua byte terakhir dari setiap perintah juga merupakan checksum: untuk perintah bangun, 0x42 + 0x4D + 0xE4 + 0x00 + 0x01 = 0x0174, jadi perintahnya diakhiri dengan 01 74. Sensor menjawab beberapa perintah dengan frame respons pendek; pengecekan panjang otomatis menyaring respons ini. Kalau kamu memakai Pico W, kamu juga bisa mengirim hasil pembacaan ke server lewat MQTT.

Ide proyek dengan PMS5003

  • Stasiun kualitas udara rumah: tampilkan PM2.5 dengan angka besar di layar OLED, dengan suhu, kelembapan, dan tekanan dari BME280 di sebelahnya.
  • Alarm tungku dan perapian: bunyikan buzzer ketika PM2.5 naik cepat dalam waktu singkat; untuk karbon monoksida, selalu pakai MQ-7 terpisah atau detektor bersertifikat.
  • Lampu AQI berwarna: alih-alih tiga LED, nyalakan ring WS2812B dengan warna-warna EPA.
  • Pemurni udara pintar: atur kecepatan kipas dengan PWM sesuai hasil pengukuran; detailnya ada di artikel kendali kipas.
  • Integrasi Home Assistant: kirim nilainya dengan ESP32 lewat MQTT dan pantau grafiknya dari ponselmu.
  • Pencatat polusi: tulis nilainya ke Google Sheets atau kartu SD untuk membuat kurva polusi harian sepanjang musim dingin.
  • Paket lengkap dalam ruangan: ukur partikel dengan PMS5003, karbon dioksida dengan MH-Z19, dan senyawa organik volatil dengan CCS811.

Kesalahan umum dan cara mengatasinya

GejalaKemungkinan penyebabSolusi
Tidak ada data sama sekaliTX dan RX tidak disilangkanHubungkan TX sensor ke RX board dan RX sensor ke TX board
Kipas tidak berputar, tidak ada dataVCC diberi daya dari 3,3 V atau pin SET dalam kondisi LOWHubungkan VCC ke 5 V, buat SET menjadi HIGH atau biarkan tidak terhubung
Angka tidak masuk akal dan melompat-lompatBaud rate bukan 9600 atau checksum tidak diverifikasiPakai 9600 8N1, verifikasi panjang dan checksum
Nilai selalu antara 0 dan beberapa sajaUdaranya memang bersih atau lubang masuk tertutupUji sensor di dekat sumber debu, biarkan lubang-lubangnya terbuka
Nilai sangat tinggi ketika berkabut dan hujanKelembapan di atas 80%, tetesan air ikut dihitung sebagai partikelUkur juga kelembapan dan tandai pembacaan sebagai meragukan pada kelembapan tinggi
Pembacaan pertama setelah bangun tidak konsistenKipas belum mencapai kecepatan stabilTunggu minimal 30 detik setelah membangunkan sensor
ESP32 restart secara acakArus kipas dan Wi-Fi membebani catu USB yang lemahPakai kabel bagus dan adaptor yang kuat, beri daya sensor dari sumber 5 V terpisah jika perlu
Letakkan sensor sekitar 1–1,5 m di atas lantai dengan lubang masuk dan keluar tetap terbuka; kotak rapat yang menutupi lubang akan merusak pengukuran. Kalau akan dipakai di luar ruangan, buat pelindung yang menahan hujan tetapi tetap meloloskan udara, dan jauhkan dari sinar matahari langsung serta lubang ventilasi. Pembacaan tunggal penuh derau; memakai rata-rata bergerak membuat indikatormu jauh lebih tenang dan andal.

Dengan PMS5003, beberapa kabel, dan frame 32 byte yang diurai dengan benar, kamu bisa memantau udara di rumah dan jalanmu dengan biaya murah dan hasil yang cukup konsisten; melihat sendiri bagaimana nilainya naik pada jam-jam tungku menyala di musim dingin juga menumbuhkan kesadaran yang baik. Untuk pengukuran gas, kamu bisa menggabungkannya dengan MQ-135 untuk membangun stasiun kualitas udara yang lengkap. Di aplikasi BlueGrays kamu akan menemukan proyek seperti alarm gas ESP32, stasiun pengukur DHT22 dengan LCD, dan pencatat cuaca serta suhu dengan OLED, lengkap langkah demi langkah dengan skema rangkaian dan kodenya, dan kamu bisa dengan mudah menambahkan PMS5003 ke proyek-proyek itu.

Pertanyaan umum

Apa bedanya PMS5003 dan PMS7003?

Keduanya sensor debu laser buatan Plantower dan memakai frame data 32 byte serta perintah yang sama, jadi kode di artikel ini bisa dipakai di keduanya. PMS7003 punya bodi lebih tipis dan konektor berbeda, sedangkan PMS5003 lebih umum dan biasanya lebih murah. Dalam praktik, akurasi pengukuran keduanya sangat mirip.

Bagaimana cara menghubungkan sensor debu ke Arduino Uno?

Hubungkan VCC PMS5003 ke 5V, GND ke GND, dan TX ke D2, lalu baca dengan SoftwareSerial di 9600 baud. Kalau kamu akan mengirim perintah ke sensor, turunkan output TX 5 V dari Uno menjadi 3,3 V dengan pembagi tegangan sebelum masuk ke pin RX sensor. Kalau hanya membaca data, RX boleh dibiarkan tidak terhubung.

Seberapa akurat PMS5003?

Produsen menyebutkan akurasi ±10 µg/m³ pada rentang 0–100 µg/m³ dan ±10% pada rentang 100–500 µg/m³. Konsistensinya bagus di antara sensor berbiaya rendah, tetapi tidak bisa menggantikan stasiun referensi resmi. Ketika kelembapan relatif melebihi 80%, tetesan air ikut terhitung, sehingga hasil pembacaan bisa lebih tinggi dari nilai sebenarnya.

Berapa nilai PM2.5 yang berbahaya?

WHO merekomendasikan rata-rata 24 jam PM2.5 tidak melebihi 15 µg/m³. Pada skala EPA, di atas 35,5 µg/m³ tidak sehat bagi kelompok sensitif, di atas 55,5 µg/m³ tidak sehat bagi semua orang, dan di atas 225,5 µg/m³ dianggap berbahaya. Batas ini berlaku untuk rata-rata; ketika ada kepulan asap singkat, nilai instannya bisa jauh lebih tinggi.

Apakah PMS5003 boleh dinyalakan terus?

Boleh, tetapi umur rata-rata laser dan kipasnya sekitar 3 tahun dan sensor menarik arus mendekati 100 mA selama bekerja. Karena kualitas udara berubah pelan, membangunkannya setiap beberapa menit dan mengukur setelah pemanasan 30 detik sangat memperpanjang umur dan menghemat energi. Untuk menidurkannya, cukup tarik pin SET ke LOW atau kirim perintah sleep lewat UART.

Apakah sensor debu bisa mendeteksi asap atau karbon monoksida?

PMS5003 sangat baik mendeteksi partikel halus dalam asap rokok dan tungku sebagai PM1.0 dan PM2.5, tetapi tidak mengukur gas. Karbon monoksida adalah gas tak berwarna tanpa partikel, jadi sensor ini tidak bisa mendeteksinya. Di ruangan yang memakai tungku, selalu sediakan detektor karbon monoksida terpisah yang bersertifikat.

Lihat semua proyek
Suhu dan Kelembapan dengan DHT11
AR-55Menengah

Suhu dan Kelembapan dengan DHT11

Seberapa hangat kamarmu, dan apakah udaranya lembap atau kering? Sensor DHT11 mengukur suhu dan kelembapan, dan Arduino menulis nilainya di layar LCD dua baris, diperbarui setiap beberapa detik.

4.7(47)
83
Alarm Detektor Gas/Asap MQ-2 ESP32
ES-20Menengah

Alarm Detektor Gas/Asap MQ-2 ESP32

Di proyek ini, gas mudah terbakar (LPG, metana, propana) dan asap dideteksi memakai modul sensor gas MQ-2, dan alarm mirip sirene diputar lewat buzzer pasif ketika terdeteksi. Output ambang digital (DO) sensor disambung ke GPIO 4 ESP32; ketika gas atau asap melewati ambang, DO menjadi LOW dan alarm terpicu. Kepekaan diatur lewat potensiometer modul. Buzzer pasif digerakkan dengan tone() untuk menghasilkan efek sirene dua frekuensi.

4.7(29)
44
Menggunakan Sensor Gas
AR-51Pemula
Premium

Menggunakan Sensor Gas

Penjaga kecil yang menyadari kebocoran gas di dapur lebih dulu darimu. Sensor gas terus mengendus udara; selama semuanya aman LED hijau tetap menyala, dan ketika gas di udara melewati tingkat…

4.6(37)
50
Suhu dan Kelembapan DHT22 ESP32 (dengan Layar LCD)
ES-15Menengah

Suhu dan Kelembapan DHT22 ESP32 (dengan Layar LCD)

Proyek ini mengukur suhu dan kelembapan sekitar dengan sensor DHT22 dan menampilkan datanya secara real-time di LCD I2C 16x2. Data dibaca dari sensor dengan protokol satu kabel lewat library Adafruit DHT. Proyek ini menjadi dasar untuk stasiun cuaca IoT, otomasi rumah pintar, atau sistem pemantauan lingkungan di rumah kaca. Komunikasi dengan DHT22 dilakukan lewat pin GPIO 4 ESP32.

4.8(38)
57
HTTPClient + API Cuaca ESP32 (dengan Layar OLED SSD1306)
ES-32Mahir
Premium

HTTPClient + API Cuaca ESP32 (dengan Layar OLED SSD1306)

Di proyek ini, kita memakai ESP32 untuk melakukan panggilan REST API ke API cuaca (wttr.in) lewat internet dengan HTTPClient.h. Berbeda dengan versi LCD I2C sebelumnya, di sini kita memakai layar OLED SSD1306 (128×64), yang memungkinkan font besar, ikon vektor, dan tampilan visual yang kaya di satu layar. Tujuh ikon vektor untuk kondisi cuaca (cerah, berawan sebagian, berawan, hujan, salju, badai, berkabut) digambar ketika program berjalan (tanpa file bitmap).

4.3(10)
22
Pencatat Data Suhu ESP32 (DHT22 + RTC DS1307 + microSD + OLED)
ES-40Mahir
Premium

Pencatat Data Suhu ESP32 (DHT22 + RTC DS1307 + microSD + OLED)

Buat pencatat suhu bercap waktu dengan ESP32! Baca suhu/kelembapan DHT22 setiap menit, ambil waktu sebenarnya dari RTC DS1307, dan catat ke kartu microSD sebagai CSV. OLED menampilkan suhu langsung (font besar), kelembapan, cap waktu, dan penghitung catatan. File /temp_log.csv bisa dibuka di Excel, Google Sheets, atau Python pandas; cocok untuk rumah kaca, suhu kamar, data laboratorium, penyimpanan makanan, atau sarang lebah.

4.7(7)
12
Deep Sleep ESP32: Hemat Baterai (OLED + Penghitung RTC RAM)
ES-33Mahir
Premium

Deep Sleep ESP32: Hemat Baterai (OLED + Penghitung RTC RAM)

Mode Deep Sleep ESP32 menurunkan konsumsi arus hingga ~10 µA dengan mematikan CPU dan sebagian besar periferal, sehingga sangat penting untuk perangkat IoT bertenaga baterai. Di proyek ini, kita memakai tiga sumber bangun yang berbeda: timer (15 detik), pin eksternal (EXT0, tombol GPIO 33), dan sentuhan (T0/GPIO 4). Variabel yang ditandai RTC_DATA_ATTR dipertahankan selama deep sleep; penghitung boot, penghitung bangun karena timer, dan penghitung bangun karena tombol terus dilacak.

4.3(10)
16
Jam, Kalender, dan Stasiun Cuaca Dot Matrix (MAX7219, DS1307)
AR-85Menengah
Premium

Jam, Kalender, dan Stasiun Cuaca Dot Matrix (MAX7219, DS1307)

Papan teks berjalan untuk meja atau dinding yang menampilkan waktu, tanggal, dan cuaca ruangan secara bergantian.

5.0(50)
66