Feinstaubsensor Arduino: PMS5003 für PM1.0, PM2.5 und PM10
Feinstaubsensor PMS5003 an Arduino, ESP32 und Pico anschließen: UART-Pins, 32-Byte-Datenframe, Schlafmodus und LED-Anzeige für die PM2.5-Luftqualität.
Ein Feinstaubsensor ist bei Arduino-Projekten das wirksamste Werkzeug, um unsichtbare Partikel in der Luft in Zahlen zu fassen. Das am häufigsten verwendete Modell ist der Laser-Partikelsensor PMS5003 von Plantower. Die kleine Box saugt die Luft mit einem Lüfter an, beleuchtet sie mit einem Laserstrahl und analysiert das gestreute Licht. Daraus liefert sie die Konzentrationen von PM1.0, PM2.5 und PM10 in Mikrogramm pro Kubikmeter (µg/m³). Die Ergebnisse sendet sie alle paar Sekunden von selbst über eine UART-Leitung mit 9600 Baud. Du kannst sie also mit Arduino Uno, ESP32 oder Raspberry Pi Pico mit nur wenigen Kabeln auslesen.
Im Winter steigt die Feinstaubbelastung in Städten durch Rauch von Öfen und Heizungen, viel Verkehr und Nebel schnell an, und mit bloßem Auge merkst du das oft nicht. In diesem Beitrag lernst du, wie der PMS5003 funktioniert, wie du den 32-Byte-Datenframe dekodierst, wie du den Sensor in den Schlafmodus schickst, um seine Lebensdauer zu verlängern, und wie du eine Luftqualitätsanzeige baust, die je nach Messwert grün, gelb oder rot leuchtet. Der Code für SoftwareSerial am Uno, die Hardware-UART am ESP32 und MicroPython am Pico ist fertig.
Was ist der Feinstaubsensor PMS5003 und wie funktioniert er?
Das Funktionsprinzip des PMS5003 ist die Laserstreuung. Ein kleiner Lüfter zieht die Luft durch die Einlassöffnung in die Messkammer. Trifft der Laserstrahl in der Kammer auf Partikel, wird das Licht in alle Richtungen gestreut, und eine Fotodiode fängt diese kurzen Lichtimpulse auf. Die Stärke des Impulses hängt von der Partikelgröße ab, die Anzahl der Impulse von der Partikelmenge. Der Mikrocontroller im Sensor sortiert die Impulse in Größenklassen zwischen 0,3 µm und 10 µm, berechnet die Partikelzahl in 0,1 Liter Luft und rechnet sie mit der Werkskalibrierung in eine Massenkonzentration um. Du liest nur noch die fertigen Ergebnisse über die serielle Schnittstelle.
PM steht für "particulate matter", also Feinstaub. Die Zahl dahinter gibt den größten Durchmesser der Partikel in Mikrometern an. PM10 umfasst alle Partikel unter 10 µm (Pollen, Baustaub, Straßenstaub) und bleibt meist in Nase und Rachen hängen. PM2.5 sind Partikel unter 2,5 µm, etwa 30-mal dünner als ein Haar. Sie dringen tief in die Lunge ein und sind der gesundheitlich am häufigsten beobachtete Wert. PM1.0 zeigt den feinsten Anteil, vor allem Ruß und Rauch aus Verbrennung. Da PM1.0 in PM2.5 und PM2.5 in PM10 mitgezählt wird, gilt immer PM1.0 ≤ PM2.5 ≤ PM10.
| Eigenschaft | Wert |
|---|---|
| Messprinzip | Laserstreuung |
| Gemessene Größen | 0,3–10 µm (PM1.0, PM2.5, PM10 und Partikelzahl in 6 Größenklassen) |
| Effektiver Messbereich | 0–500 µg/m³ (maximal 1000 µg/m³ und mehr) |
| Genauigkeit | ±10 µg/m³ bei 0–100 µg/m³, ±10 % bei 100–500 µg/m³ |
| Auflösung | 1 µg/m³ |
| Versorgung | 5 V (4,5–5,5 V), nötig für den Lüfter |
| Strom | Im Betrieb ≤ 100 mA, im Schlaf ≤ 200 µA |
| Kommunikation | UART, 9600 Baud, 8N1, 3,3-V-Logikpegel |
| Ansprechzeit | Unter 10 Sekunden (30 s für stabile Daten nach dem Aufwachen) |
| Betriebsumgebung | -10 bis +60 °C, 0–99 % relative Luftfeuchtigkeit (nicht kondensierend) |
| Abmessungen | 50 × 38 × 21 mm |
| Mittlere Lebensdauer (MTTF) | Mindestens 3 Jahre |
Was bedeuten die Werte für PM2.5 und PM10?
Um die Zahl des Sensors zu deuten, nutzt man offizielle Skalen. Die Leitlinie der Weltgesundheitsorganisation (WHO) von 2021 empfiehlt für PM2.5 einen Grenzwert von 15 µg/m³ im 24-Stunden-Mittel und 5 µg/m³ im Jahresmittel, für PM10 45 µg/m³ im 24-Stunden-Mittel und 15 µg/m³ im Jahresmittel. Der Air Quality Index (AQI) der US-Umweltbehörde EPA teilt PM2.5 in sechs farbige Stufen ein. Da diese Skalen auf 24-Stunden-Mittelwerten beruhen, liefert auch deine Heimanzeige deutlich bessere Ergebnisse, wenn du einen Mittelwert über einige Minuten statt einer einzelnen Momentanmessung verwendest.
| PM2.5 (µg/m³, 24 Std.) | EPA-Stufe | Bedeutung |
|---|---|---|
| 0–9,0 | Gut (grün) | Die Luft ist sauber, kein Risiko |
| 9,1–35,4 | Mäßig (gelb) | Geringes Risiko für sehr empfindliche Personen |
| 35,5–55,4 | Ungesund für empfindliche Gruppen (orange) | Menschen mit Asthma oder Herzleiden, Kinder und Ältere sollten aufpassen |
| 55,5–125,4 | Ungesund (rot) | Alle sind betroffen |
| 125,5–225,4 | Sehr ungesund (violett) | Aktivitäten im Freien einschränken |
| 225,5 und mehr | Gefährlich (weinrot) | Notfallniveau |
PMS5003 anschließen: Arduino Uno, ESP32 und Pico
Auf der Rückseite des PMS5003 sitzt ein kleiner 8-poliger Stecker mit 1,25 mm Raster, der nicht aufs Breadboard passt. Mit dem mitgelieferten Kabel und der kleinen Adapterplatine, die meist im Paket liegt, werden die Pins zur Standardleiste mit 2,54 mm. Pin 7 und 8 sind unbelegt. SET und RESET sind im Sensor per Pull-up nach oben gezogen, du kannst sie also unbeschaltet lassen, wenn du sie nicht brauchst.
| PMS5003-Pin | Funktion | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|
| 1 VCC | 5-V-Versorgung | 5V | 5V (VIN) | VBUS (Pin 40) |
| 2 GND | Masse | GND | GND | GND |
| 3 SET | HIGH oder offen: Betrieb, LOW: Schlaf | D4 (optional) | GPIO 4 | GP2 (optional) |
| 4 RX | Befehlseingang zum Sensor (3,3 V) | D3 (mit Spannungsteiler) | GPIO 17 (TX2) | GP0 (UART0 TX) |
| 5 TX | Datenausgang vom Sensor (3,3 V) | D2 | GPIO 16 (RX2) | GP1 (UART0 RX) |
| 6 RESET | LOW: zurücksetzen | Offen | Offen | Offen |
| 7, 8 | Nicht angeschlossen | - | - | - |
Der Datenframe: Was die 32 Bytes bedeuten
Im Standard-Aktivmodus sendet der Sensor das Messergebnis selbstständig und fortlaufend als 32-Byte-Frame. Der Frame beginnt immer mit den Bytes 0x42 und 0x4D (ASCII "BM"). Danach folgen die Framelänge (28), 13 Datenwerte mit je 16 Bit und eine 2-Byte-Prüfsumme. Jeder 16-Bit-Wert wird zuerst als High-Byte, dann als Low-Byte übertragen (Big-Endian). Die Prüfsumme entspricht der Summe der ersten 30 Bytes. Diese Kontrolle ist der einzig zuverlässige Weg, durch Kabelrauschen beschädigte Frames auszusortieren. Ändert sich die Luftqualität kaum, sendet der Sensor etwa alle 2,3 Sekunden einen Frame, bei schnellen Änderungen alle 200–800 ms. Wenn dich die Grundlagen des Protokolls interessieren, schau in den Beitrag UART-Kommunikation.
| Byte | Inhalt | Einheit |
|---|---|---|
| 0–1 | Start: 0x42 0x4D | - |
| 2–3 | Framelänge (28) | Byte |
| 4–5 | PM1.0 (CF=1, Standardpartikel) | µg/m³ |
| 6–7 | PM2.5 (CF=1) | µg/m³ |
| 8–9 | PM10 (CF=1) | µg/m³ |
| 10–11 | PM1.0 (atmosphärische Umgebung) | µg/m³ |
| 12–13 | PM2.5 (atmosphärische Umgebung) | µg/m³ |
| 14–15 | PM10 (atmosphärische Umgebung) | µg/m³ |
| 16–27 | Partikelzahl größer als 0,3 / 0,5 / 1,0 / 2,5 / 5,0 / 10 µm (6 Werte) | Anzahl / 0,1 L |
| 28–29 | Reserviert | - |
| 30–31 | Prüfsumme (Summe der Bytes 0–29) | - |
PMS5003 am Arduino Uno Schritt für Schritt auslesen
- Stecke das Sensorkabel in die Adapterplatine, verbinde VCC mit dem 5V-Pin des Uno und GND mit GND.
- Verbinde den TX-Pin des Sensors mit D2. Dieser Pin wird zum RX von SoftwareSerial.
- Wenn du Befehle senden willst, verbinde den RX-Pin des Sensors über einen 10-kΩ/20-kΩ-Spannungsteiler mit D3, sonst lass ihn offen.
- Lade den Code unten hoch und öffne den Serial Monitor mit 115200 Baud.
- Ignoriere die Werte der ersten 30 Sekunden. Erst wenn sich die Lüfterdrehzahl eingependelt hat, sind die Messwerte stabil.
- Schüttle ein staubiges Tuch wenige Zentimeter vom Sensor entfernt aus oder puste eine Kerze aus und beobachte, wie die Werte steigen.
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}Das Herzstück des Codes ist die Funktion readPms(). Sie liest die eingehenden Bytes einzeln, sucht zuerst das Startpaar 0x42 und 0x4D und schreibt dann in den Puffer, bis 32 Bytes voll sind. Ist der Frame komplett, prüft sie, ob das Längenfeld 28 ist und ob die Summe der ersten 30 Bytes dem Prüfwert in den letzten beiden Bytes entspricht. Stimmt beides, kopiert sie die Werte in die Struktur. Da die Funktion einen Parameter vom Typ Stream nimmt, läuft derselbe Code unverändert mit SoftwareSerial, dem Serial1 des Arduino Mega oder der HardwareSerial des ESP32. Weil loop() nie wartet, kannst du weitere Aufgaben ergänzen. Wenn du Zeitsteuerung brauchst, ist millis() statt delay() am besten.
Schlafmodus: SET-Pin und UART-Befehle
Wenn Laser und Lüfter des PMS5003 dauerhaft laufen, beträgt die mittlere Lebensdauer etwa 3 Jahre, und der Sensor zieht in dieser Zeit ständig fast 100 mA. Die Luftqualität ändert sich aber nur langsam innerhalb von Minuten, daher reicht es, alle paar Minuten zu messen. Du kannst den Sensor auf zwei Wegen schlafen legen: den SET-Pin auf LOW setzen oder den 7-Byte-Schlafbefehl über UART senden. Im Schlaf stehen Lüfter und Laser still, und der Strom sinkt unter 200 µA. Nach dem Aufwecken musst du mindestens 30 Sekunden warten, bis sich die Lüfterdrehzahl eingependelt hat, und erst dann auslesen. Arbeitest du zum Beispiel alle 5 Minuten mit 30 Sekunden Aufwärmen und 20 Sekunden Messen, ist der Sensor nur etwa ein Sechstel der Zeit aktiv. Stromverbrauch und Laserverschleiß sinken im gleichen Verhältnis.
| Aktion | Befehlsbytes (hex) |
|---|---|
| Schlafen | 42 4D E4 00 00 01 73 |
| Aufwecken | 42 4D E4 00 01 01 74 |
| Passivmodus (sendet nur auf Anfrage) | 42 4D E1 00 00 01 70 |
| Aktivmodus (sendet fortlaufend, Standard) | 42 4D E1 00 01 01 71 |
| Im Passivmodus eine Einzelmessung anfordern | 42 4D E2 00 00 01 71 |
Luftqualitätsanzeige mit LEDs am ESP32

Der ESP32 hat drei Hardware-UARTs, deren Pins du auf beliebige GPIOs legen kannst. SoftwareSerial wird also nicht gebraucht. Da der ESP32 mit 3,3 V arbeitet, kannst du die RX- und TX-Leitungen des Sensors direkt verbinden, nur VCC muss weiterhin vom 5V-Pin (VIN) kommen. Der Code unten weckt den Sensor über den SET-Pin, wartet 30 Sekunden, bildet dann den Mittelwert aus PM2.5 und PM10 von 8 Frames und schickt den Sensor wieder schlafen. Je nach Ergebnis leuchtet eine der LEDs (grün, gelb, rot) an GPIO 25, 26 und 27. Vergiss nicht, vor jede LED einen 220-Ω-Vorwiderstand zu setzen. Den Wert kannst du mit dem LED-Widerstandsrechner prüfen.
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}Im Code wird statt einer Einzelmessung der Mittelwert von 8 Frames gebildet. Da der Sensor im stabilen Modus etwa alle 2,3 Sekunden einen Frame sendet, reicht dafür ein Fenster von 25 Sekunden. Nach dem Aufwecken wird der Puffer geleert, weil alte Messwerte, die sich während des Aufwärmens angesammelt haben, den Mittelwert verfälschen würden. Als grüne Schwelle dient die 24-Stunden-Empfehlung der WHO von 15 µg/m³, als rote Schwelle die EPA-Grenze von 35,4 µg/m³. Du kannst beide an deinen Bedarf anpassen. Der Sensor läuft in einem Zyklus von etwa 5 Minuten höchstens 55 Sekunden. Für eine batteriebetriebene Station kannst du den ESP32 in der Wartezeit zusätzlich in den Deep Sleep schicken. Vergiss dann nicht, den Zustand des SET-Pins mit gpio_hold_en() festzuhalten, damit er auf LOW bleibt. Wenn du das Ergebnis als Zahl auf einem OLED-Display anzeigst, wird die Anzeige deutlich informativer.
MicroPython-Code für den Raspberry Pi Pico
Der Raspberry Pi Pico hat zwei Hardware-UARTs. Hier haben wir UART0 gewählt, der die Pins GP0 (TX) und GP1 (RX) nutzt. Da der Pico mit 3,3-V-Logik arbeitet, spricht er direkt mit dem Sensor. Hole die 5-V-Versorgung des Sensors vom Pin VBUS (Pin 40). Dieser Pin liefert nur dann 5 V, wenn der Pico über USB versorgt wird. Im Batteriebetrieb kannst du mit einem Step-up-Wandler wie dem MT3608 5 V erzeugen und damit sowohl den Sensor als auch den VSYS-Pin des Pico speisen. In diesem Beispiel erfolgen Schlafen und Aufwecken über UART-Befehle statt über den SET-Pin, du sparst dir also ein Kabel. Wenn du neu bei MicroPython bist, wirf zuerst einen Blick in den Beitrag MicroPython-Grundlagen.
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 cycleDie Hilfsfunktion read_exact() wartet mit Timeout, bis die gewünschte Anzahl Bytes eingetroffen ist. So bleibt das Programm nicht für immer hängen, wenn ein Kabel abfällt. Das ">" in struct.unpack(">HHH", ...) besagt, dass die Daten Big-Endian sind, und jedes "H" steht für eine vorzeichenlose 16-Bit-Zahl. Die Bytes 10–15 sind die atmosphärischen Werte für PM1.0, PM2.5 und PM10. Auch die letzten beiden Bytes der Befehle sind eine Prüfsumme: Beim Aufweckbefehl ist 0x42 + 0x4D + 0xE4 + 0x00 + 0x01 = 0x0174, deshalb endet der Befehl mit 01 74. Auf manche Befehle antwortet der Sensor mit einem kurzen Antwortframe, die Längenprüfung sortiert diese Antworten automatisch aus. Mit einem Pico W kannst du die Messwerte auch per MQTT an einen Server senden.
Projektideen mit dem PMS5003
- Luftqualitätsstation für zu Hause: Zeige PM2.5 groß als Zahl auf einem OLED-Display an, daneben Temperatur, Luftfeuchtigkeit und Druck mit dem BME280.
- Warner für Ofen und Kamin: Der Buzzer ertönt, wenn PM2.5 in kurzer Zeit stark steigt. Für Kohlenmonoxid verwende unbedingt zusätzlich einen MQ-7 oder einen zertifizierten Melder.
- Farbige AQI-Lampe: Lass statt dreier LEDs einen WS2812B-Ring in den EPA-Farben leuchten.
- Intelligenter Luftreiniger: Regle die Drehzahl eines Lüfters per PWM nach der Messung. Details findest du im Beitrag Lüftersteuerung.
- Home-Assistant-Integration: Sende die Werte mit dem ESP32 per MQTT und verfolge die Diagramme auf dem Handy.
- Feinstaub-Logger: Schreibe die Werte in Google Sheets oder auf eine SD-Karte und erstelle so den ganzen Winter über die tägliche Belastungskurve.
- Komplettpaket für Innenräume: Miss Partikel mit dem PMS5003, Kohlendioxid mit dem MH-Z19 und flüchtige organische Verbindungen mit dem CCS811.
Häufige Fehler und ihre Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Es kommen gar keine Daten | TX und RX nicht über Kreuz verbunden | Verbinde den TX des Sensors mit dem RX des Boards und den RX des Sensors mit dem TX des Boards |
| Lüfter dreht nicht, keine Werte | VCC mit 3,3 V versorgt oder SET-Pin auf LOW | Schließe VCC an 5 V an, setze SET auf HIGH oder lass ihn offen |
| Sinnlose, springende Zahlen | Baudrate nicht 9600 oder keine Prüfsummenkontrolle | Nutze 9600 8N1 und prüfe Länge und Prüfsumme |
| Werte stets zwischen 0 und wenigen µg/m³ | Die Luft ist wirklich sauber oder die Einlassöffnung ist verdeckt | Teste den Sensor mit einer nahen Staubquelle und lass die Öffnungen frei |
| Extrem hohe Werte bei Nebel und Regen | Luftfeuchtigkeit über 80 %, Wassertröpfchen werden als Partikel gezählt | Miss auch die Feuchtigkeit und markiere Werte bei hoher Feuchtigkeit als fragwürdig |
| Erste Messungen nach dem Aufwachen unstimmig | Der Lüfter läuft noch nicht mit stabiler Drehzahl | Warte nach dem Aufwecken mindestens 30 Sekunden |
| ESP32 startet zufällig neu | Lüfter- und WLAN-Strom überfordern eine schwache USB-Quelle | Nutze ein gutes Kabel und ein starkes Netzteil, versorge den Sensor notfalls aus einer separaten 5-V-Quelle |
Mit dem PMS5003, ein paar Kabeln und einem richtig dekodierten 32-Byte-Frame überwachst du die Luft in deinem Zuhause und auf deiner Straße günstig und ziemlich konsistent. Zu sehen, wie die Werte in den Ofenstunden im Winter klettern, schafft zudem ein gutes Bewusstsein. Zusammen mit dem MQ-135 für die Gasmessung kannst du eine komplette Luftqualitätsstation bauen. In der BlueGrays-App findest du Projekte wie einen ESP32-Gasalarm, eine LCD-Messstation mit DHT22 und einen Wetter- und Temperaturlogger mit OLED, Schritt für Schritt mit Schaltplan und Code, und kannst den PMS5003 leicht in diese Projekte einbauen.
Häufige Fragen
Was ist der Unterschied zwischen PMS5003 und PMS7003?
Beides sind Laser-Partikelsensoren von Plantower, die denselben 32-Byte-Datenframe und dieselben Befehle verwenden, daher funktioniert der Code aus dem Beitrag mit beiden. Der PMS7003 hat ein schlankeres Gehäuse und einen anderen Stecker, der PMS5003 ist verbreiteter und meist günstiger. Die Messgenauigkeit liegt in der Praxis sehr nah beieinander.
Wie schließe ich einen Feinstaubsensor an den Arduino Uno an?
Verbinde VCC des PMS5003 mit 5V, GND mit GND und den TX-Pin mit D2, und lies ihn mit SoftwareSerial bei 9600 Baud aus. Wenn du dem Sensor Befehle senden willst, musst du den 5-V-TX-Ausgang des Uno mit einem Spannungsteiler auf 3,3 V senken und an den RX-Pin des Sensors legen. Wenn du nur Daten liest, kannst du RX offen lassen.
Wie genau misst der PMS5003?
Der Hersteller gibt ±10 µg/m³ im Bereich 0–100 µg/m³ und ±10 % im Bereich 100–500 µg/m³ an. Unter den kostengünstigen Sensoren ist die Konsistenz gut, er ersetzt aber keine offiziellen Referenzstationen. Übersteigt die relative Luftfeuchtigkeit 80 %, werden auch Wassertröpfchen gezählt, sodass die Werte höher ausfallen können, als sie tatsächlich sind.
Ab welchem PM2.5-Wert wird es gefährlich?
Die WHO empfiehlt, dass das 24-Stunden-Mittel von PM2.5 15 µg/m³ nicht überschreitet. Auf der EPA-Skala gilt über 35,5 µg/m³ als ungesund für empfindliche Gruppen, über 55,5 µg/m³ für alle und über 225,5 µg/m³ als gefährlich. Diese Grenzen gelten für Mittelwerte. Bei kurzzeitigem Rauch kann der Momentanwert deutlich höher liegen.
Kann ich den PMS5003 dauerhaft eingeschaltet lassen?
Ja, aber die mittlere Lebensdauer von Laser und Lüfter beträgt etwa 3 Jahre, und der Sensor zieht im Betrieb fast 100 mA. Da sich die Luftqualität nur langsam ändert, verbessert es Lebensdauer und Stromverbrauch deutlich, ihn alle paar Minuten aufzuwecken, 30 Sekunden aufzuwärmen und dann zu messen. Zum Schlafenlegen genügt es, den SET-Pin auf LOW zu setzen oder den UART-Schlafbefehl zu senden.
Erkennt der Feinstaubsensor Rauch oder Kohlenmonoxid?
Der PMS5003 erkennt die feinen Partikel in Zigaretten- und Ofenrauch sehr gut als PM1.0 und PM2.5, misst aber keine Gase. Kohlenmonoxid ist ein farbloses Gas ohne Partikel, der Sensor kann es also nicht bemerken. Halte in Räumen mit Ofen unbedingt einen separaten, zertifizierten Kohlenmonoxidmelder bereit.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

ESP32 MQ-2 Gas-/Rauchmelder-Alarm
In diesem Projekt wird die Erkennung brennbarer Gase (LPG, Methan, Propan) und Rauch mit einem MQ-2-Gassensormodul durchgeführt; bei Erkennung ertönt über einen passiven Summer ein sirenenähnlicher Alarmton. Der digitale Schwellenausgang (DO) des Sensors wird an GPIO 4 des ESP32 angeschlossen; überschreiten Gas oder Rauch den Schwellenwert, geht DO auf LOW und der Alarm wird ausgelöst. Die Empfindlichkeit wird über das Potentiometer eingestellt. Der passive Summer wird mit tone() angesteuert.

Verwendung von Gassensoren
Ein kleiner Wächter, der ein Gasleck in der Küche bemerkt, bevor du es tust. Der Gassensor schnuppert ständig an der Luft; solange alles in Ordnung ist, leuchtet die grüne LED, übersteigt das Gas in…

ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
Bei diesem Projekt werden die Umgebungstemperatur und die Luftfeuchtigkeit mit einem DHT22-Sensor gemessen und in Echtzeit auf einem 16x2 I2C-LCD angezeigt. Mithilfe der Adafruit-DHT-Bibliothek werden die Daten über das One-Wire-Protokoll vom Sensor ausgelesen. Dieses Projekt bildet die Grundlage für IoT-Wetterstationen, Smart-Home-Automatisierung oder Umgebungsüberwachungssysteme in Gewächshäusern. Die Kommunikation mit dem DHT22 erfolgt über den GPIO-4-Pin des ESP32.

ESP32 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)
Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Anders als die I2C-LCD-Version nutzt dieses Projekt ein SSD1306-OLED (128×64) mit großer Schrift und Vektor-Icons für eine reichere Darstellung. Sieben Wetter-Icons (sonnig, Regen, Schnee und mehr) werden ohne Bitmap-Dateien direkt gezeichnet.

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

Punktmatrix-Uhr, Kalender und Wetterstation (MAX7219, DS1307)
Eine Laufschrift-Tafel für Tisch oder Wand, die abwechselnd Uhrzeit, Datum und das Raumklima zeigt.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

