Componenten · 14 min leestijd

MQ135 Arduino-tutorial: luchtkwaliteitssensor, kalibratie en ppm

MQ135 Arduino-gids: welke gassen hij detecteert, 24–48 uur inbranden, R0-kalibratie en de ppm-formule, kan hij CO2 meten, ventilatorsturing, ESP32-logging vs CCS811.

MQ135 Arduino-projecten zijn de eerste stop voor iedereen die goedkoop en eenvoudig wil bijhouden hoe schoon de lucht in een ruimte is. De MQ-135 is een verwarmde metaaloxide-gassensor die reageert op gassen zoals ammoniak, stikstofoxiden, benzeen, alcohol en rook. In hobbysets zit hij meestal op een kleine module met een comparatorchip en een afstelpotmeter; hij wordt via de analoge uitgang op de Arduino aangesloten en uitgelezen met één analogRead(). Maar om het getal dat deze sensor geeft om te zetten in een zinvolle meting is wat meer kennis nodig dan de meeste tutorials uitleggen.

In deze gids leer je wat er in de sensor gebeurt, hoe gevoelig hij is voor welke gassen en waarom hij 24–48 uur verwarmd moet worden vóór het eerste echte gebruik. Daarna bouwen we stap voor stap de ppm-berekening op met de belastingsweerstand (RL), de sensorweerstand (Rs) en de referentieweerstand (R0), doen we een R0-kalibratie in schone lucht en geven we een eerlijk antwoord op de meestgestelde vraag: meet de MQ-135 echt CO2? Tot slot laten we een ventilator automatisch draaien, loggen we metingen met een ESP32 naar een bestand met tijdstempel, schrijven we MicroPython-code voor de Raspberry Pi Pico en vergelijken we de MQ-135 met de CCS811 en NDIR-CO2-sensoren.

MQ-135-luchtkwaliteitssensormodule
MQ-135-module: verwarmde metaaloxidesensor, LM393-comparator, gevoeligheidspotmeter en de pins VCC, GND, DO en AO.

Wat is de MQ-135 en hoe werkt hij?

Achter het roestvrijstalen gaas is het oppervlak van een klein keramisch buisje bedekt met tindioxide (SnO2), en een verwarmingsdraad erdoorheen verhit deze laag tot enkele honderden graden Celsius. In schone lucht hechten zuurstofmoleculen zich aan het SnO2-oppervlak, vangen ze vrije elektronen in het materiaal op en blijft de weerstand van de laag hoog. Komt er een reducerend gas zoals ammoniak, alcohol of benzeen in de lucht, dan reageert dat met de zuurstof op het oppervlak, komen de elektronen vrij en daalt de weerstand. Hoe hoger de gasconcentratie, hoe lager de weerstand. De module zet deze weerstand met een belastingsweerstand in een spanningsdeler, dus de spanning op de AO-pin stijgt naarmate er meer gas is.

EigenschapWaarde
Gevoelig materiaalTindioxide (SnO2), verwarmd keramisch buisje
Verwarmingsspanning5 V ± 0,1 V
Verwarmingsweerstand en -stroom33 Ω ± 5%, ongeveer 150 mA
VerwarmingsvermogenMaximaal 800 mW
DetectiebereikNH3 10–300 ppm, benzeen 10–1000 ppm, alcohol 10–300 ppm
Eerste voorverwarmingMeer dan 24 uur
Gebruiksomstandigheden−10 tot 45 °C, relatieve luchtvochtigheid onder 95%
Module-uitgangenAO (analoog) en DO (digitale drempel via LM393)

Welke gassen detecteert de MQ-135?

De MQ-135 is geen selectieve sensor die één gas meet; hij reageert tegelijk op veel gassen die reageren met het verwarmde SnO2-oppervlak en kan ze niet van elkaar onderscheiden. De fabrikant beschrijft hem als extra gevoelig voor ammoniak, zwavelverbindingen en dampen van het benzeentype; hij reageert ook duidelijk op alcohol, rook en stikstofoxiden. Zie de MQ-135 daarom het best als een "luchtvervuilingsindicator": als de waarde stijgt, weet je dat er iets in de lucht is veranderd, maar niet wat. Voor lekken van aardgas en LPG is de MQ-2-gassensor, die daarvoor is ontworpen, een veel betere keuze.

GasWaar komt het thuis vandaan?Reactie van de MQ-135
Ammoniak (NH3)Schoonmaakmiddelen, kattenbakvulling, kunstmestHoog
Benzeen, tolueen en oplosmiddelenVerf, thinner, lijm, sigarettenrookHoog
AlcoholdampHandgel, eau de cologne, parfumHoog
RookKoken, sigaretten, kaarsenGemiddeld
Stikstofoxiden (NOx)Gasfornuis, uitlaatgassenGemiddeld
Koolstofdioxide (CO2)Menselijke adem, gesloten en volle ruimtesZwak, indirect

Meet de MQ-135 CO2?

Het korte antwoord: nee, niet echt; hij schat het. Het datasheet van de MQ-135 bevat een CO2-curve en de meeste bibliotheken online berekenen daaruit een "CO2-ppm"-waarde. Maar CO2 is een chemisch stabiel gas dat maar heel zwak reageert met het SnO2-oppervlak. In een gesloten ruimte stijgen, naarmate mensen ademen, ook de luchtvochtigheid en de vluchtige organische stoffen die het lichaam afgeeft samen met CO2, en daar reageert de MQ-135 echt op. De "CO2" die de sensor toont is dus eigenlijk een schatting op basis van de algehele luchtvervuiling in de ruimte. Het eenvoudigste bewijs: open een flesje eau de cologne naast de sensor en zie de "CO2"-waarde omhoogschieten naar 5000 ppm.

Dat betekent niet dat de MQ-135 nutteloos is. Hij werkt heel goed voor relatieve beslissingen zoals "de ruimte wordt bedompt, doe het raam open" of "er is rook in de keuken, zet de afzuiging aan". Heb je de echte CO2-waarde nodig in een klaslokaal, kantoor of slaapkamer, gebruik dan een van de NDIR-CO2-sensoren uit de vergelijking aan het eind van deze gids. De tabel hieronder vat samen wat de waarden van een echte CO2-meter betekenen; je kunt de schattingen van de MQ-135 met dezelfde bereiken interpreteren.

CO2 (ppm)Wat betekent het?
400–450Schone buitenlucht
450–800Goed geventileerde binnenruimte
800–1000Acceptabel, denk aan ventileren
1000–1500Bedompte lucht, concentratie kan afnemen; ventileer
1500–2000Hoofdpijn en slaperigheid kunnen optreden
5000Grenswaarde voor 8 uur blootstelling op de werkplek

MQ-135 Arduino-bedrading

ModulepinArduino UnoESP32Raspberry Pi Pico
VCC (inclusief de verwarming)5VVIN (5 V van USB)VBUS (5 V van USB)
GNDGNDGNDGND
AO (analoge uitgang)A0GPIO 34, via een 10 kΩ / 20 kΩ-delerGP26 (ADC0), via een 10 kΩ / 20 kΩ-deler
DO (digitale drempel, optioneel)D2Elke GPIO via een delerElke GP-pin via een deler
De verwarming van de MQ-135 alleen al trekt ongeveer 150 mA en moet 5 V krijgen; als je hem voedt vanaf de 3V3-pin van een ESP32 of Pico, wordt de sensor niet heet genoeg en zijn de metingen betekenisloos. Als de module op 5 V draait, kan de AO-uitgang oplopen tot 5 V, wat de 3,3 V-ADC-ingang van de ESP32 en Pico beschadigt. Maak een spanningsdeler van 10 kΩ + 20 kΩ tussen AO en GND en sluit het middelpunt aan op de ADC-pin: 5 V × 20 / 30 = 3,33 V. Andere weerstandsparen kun je proberen met de spanningsdelerrekenmachine. Een draaiende sensor wordt te heet om vast te houden; raak het gaas niet aan.

Voorverwarmen: het inbranden van 24–48 uur en de dagelijkse opwarming

MQ-sensoren hebben twee aparte opwarmfases die vaak door elkaar worden gehaald. De eerste is de eerste voorverwarming (inbranden): op het oppervlak van een gloednieuwe sensor, of een die lang ongebruikt in opslag lag, zijn vocht en vervuiling opgebouwd. De fabrikant vraagt de sensor vóór standaardmetingen meer dan 24 uur onder spanning te zetten; in de praktijk kun je de waarden, als je hem 24–48 uur ononderbroken laat draaien, langzaam zien driften en uiteindelijk stabiliseren. Doe je de R0-kalibratie voordat deze periode voorbij is, dan driften al je metingen binnen een paar dagen. De tweede is de dagelijkse opwarming: een sensor die is ingebrand heeft bij elke keer aanzetten nog een paar minuten nodig om de verwarming in evenwicht te brengen; de waarden in de eerste minuut zijn duidelijk te hoog of te laag. Daarom bevat de code een wachttijd van minstens 2–3 minuten; voor nauwkeurige metingen is 10–20 minuten wachten beter.

Rs, RL en R0: hoe bereken je ppm met de MQ-135?

In de module staan de sensorweerstand Rs en de belastingsweerstand RL van het board in serie en delen ze de 5 V. De spanning op de AO-pin is Vout = 5 × RL / (Rs + RL). Draai je deze formule om, dan krijg je de actuele weerstand van de sensor uit de gemeten spanning: Rs = RL × (5 − Vout) / Vout. Op de Arduino Uno gebruikt de ADC dezelfde 5 V als referentie, dus je hoeft niet eens om te rekenen naar volt: Rs = RL × (1023 − raw) / raw. Rs op zichzelf zegt niets, want de weerstand verschilt sterk van sensor tot sensor. Wat telt is de verhouding van Rs tot de waarde in een bekende lucht, genaamd R0.

De curves in het datasheet leggen de verhouding Rs/R0 naar gasconcentratie vast en zijn op log-logschalen bijna rechte lijnen. Dat betekent dat ze met een machtsfunctie kunnen worden uitgedrukt: ppm = A × (Rs/R0)^−B. De coëfficiënten die populaire MQ-135-bibliotheken voor de CO2-curve gebruiken zijn A = 116.602 en B = 2.769. Om R0 te vinden zet je de sensor in schone buitenlucht; omdat de CO2 buiten tegenwoordig ongeveer 420 ppm is, draai je de formule om en bereken je R0 = Rs × (420 / A)^(1/B) ≈ Rs × 1,59. Houd er rekening mee dat deze coëfficiënten voor andere gassen anders zijn en dat het resultaat slechts een schatting is.

Een van de kleine SMD-weerstanden aan de achterkant van de module is RL, en de code erop vertelt je de waarde: 102 = 1 kΩ, 103 = 10 kΩ, 203 = 20 kΩ. Deze codes leggen we uit in SMD-weerstandscodes. Een verkeerde RL invoeren verandert het ppm-resultaat niet, omdat R0 met dezelfde RL wordt berekend en de verhouding gelijk blijft; alleen de Rs- en R0-getallen op het scherm schalen mee. Maar als RL erg klein is (1 kΩ), blijft de AO-spanning in schone lucht heel laag en lijdt de ADC-resolutie eronder; als je ziet dat de waarden jitteren, is middelen een goede oplossing.

MQ-135 R0-kalibratie stap voor stap

  1. Sluit VCC van de module aan op 5V, GND op GND en AO op A0, en voltooi de eerste voorverwarming door de sensor 24–48 uur non-stop te laten draaien.
  2. Lees de code op de belastingsweerstand aan de achterkant van het board af en stel RL_KOHM in de onderstaande code daarop in.
  3. Neem de schakeling mee naar schone buitenlucht, zoals een balkon of een open raam, uit de buurt van verkeer, sigaretten en de keuken.
  4. Upload de kalibratiecode, open de Serial Monitor op 9600 baud en wacht minstens 10 minuten.
  5. Zodra de gemiddelde R0 op het scherm enkele minuten nauwelijks verandert, schrijf je hem op; dat is de R0 van jouw sensor.
C++ (Arduino IDE)
1const byte MQ_PIN = A0;                 // MQ-135 AO
2const float RL_KOHM = 1.0;              // karttaki yük direnci: 102 = 1, 103 = 10 / load resistor on the board
3const float PARA = 116.6020682;         // CO2 eğrisi katsayıları / CO2 curve coefficients
4const float PARB = 2.769034857;
5const float CLEAN_AIR_PPM = 420.0;      // dış havadaki CO2 / CO2 in outdoor air
6
7float r0Average = 0;
8
9float readRs() {
10  long sum = 0;
11  for (int i = 0; i < 50; i++) {        // 50 ölçüm, yaklaşık 1 saniye / 50 readings, about 1 second
12    sum += analogRead(MQ_PIN);
13    delay(20);
14  }
15  float raw = sum / 50.0;
16  if (raw < 1) raw = 1;                 // sıfıra bölmeyi önle / avoid dividing by zero
17  return RL_KOHM * (1023.0 - raw) / raw;   // Rs = RL × (Vc − Vout) / Vout
18}
19
20void setup() {
21  Serial.begin(9600);
22  Serial.println(F("Temiz havada en az 10 dk bekle / wait at least 10 min in clean air"));
23}
24
25void loop() {
26  float rs = readRs();
27  float r0 = rs * pow(CLEAN_AIR_PPM / PARA, 1.0 / PARB);    // R0 = Rs × (420 / A)^(1/B)
28  if (r0Average == 0) r0Average = r0;
29  r0Average = r0Average * 0.95 + r0 * 0.05;                // yavaş ortalama / slow running average
30
31  Serial.print(F("Rs = "));
32  Serial.print(rs, 2);
33  Serial.print(F(" kOhm   R0 = "));
34  Serial.print(r0, 2);
35  Serial.print(F("   ortalama / average R0 = "));
36  Serial.println(r0Average, 2);
37}

De code middelt elke seconde 50 metingen, berekent daaruit Rs en de actuele R0 en voegt deze waarde toe aan een traag lopend gemiddelde. Het lopende gemiddelde voorkomt dat een korte vlaag uitlaatgas door de wind het resultaat verpest. De R0 die je vindt hoort alleen bij die sensor en die RL-waarde; vervang je de sensor, kalibreer dan opnieuw. Over maanden drift R0 langzaam doordat de sensor veroudert, dus bij projecten die lang draaien is het een goede gewoonte de kalibratie om de paar maanden te herhalen.

Meetcode: geschatte ppm en luchtkwaliteitsniveau

Als je R0 hebt gevonden, zet je hem in de meetcode. De code wacht eerst 3 minuten op de opwarming en print dan elke 2 seconden de verhouding Rs/R0, de geschatte ppm en een luchtkwaliteitslabel op basis van de tabel hierboven naar de Serial Monitor. In schone lucht is de verhouding ongeveer 0,6; hoe kleiner hij wordt, hoe meer gas er in de lucht zit. Om te testen leg je een paar druppels eau de cologne op een wattenbolletje bij de sensor: binnen enkele seconden daalt de verhouding en stijgt de ppm, en als je het watje weghaalt zijn de waarden binnen een paar minuten weer normaal.

C++ (Arduino IDE)
1const byte MQ_PIN = A0;
2const float RL_KOHM = 1.0;              // kalibrasyondaki RL ile aynı / same RL as in calibration
3const float R0_KOHM = 3.6;              // kendi kalibrasyon sonucunla değiştir / replace with your calibration result
4const float PARA = 116.6020682;
5const float PARB = 2.769034857;
6const unsigned long WARMUP_MS = 180000; // 3 dk ısınma / 3 min warm-up
7
8float readRs() {
9  long sum = 0;
10  for (int i = 0; i < 20; i++) {
11    sum += analogRead(MQ_PIN);
12    delay(10);
13  }
14  float raw = sum / 20.0;
15  if (raw < 1) raw = 1;
16  return RL_KOHM * (1023.0 - raw) / raw;
17}
18
19const __FlashStringHelper* airLabel(float ppm) {
20  if (ppm < 800)  return F("Iyi / good");
21  if (ppm < 1000) return F("Orta / moderate");
22  if (ppm < 1500) return F("Havalandir / ventilate");
23  return F("Kotu / poor");
24}
25
26void setup() {
27  Serial.begin(9600);
28  Serial.println(F("Isiniyor / warming up..."));
29  while (millis() < WARMUP_MS) delay(100);
30}
31
32void loop() {
33  float ratio = readRs() / R0_KOHM;           // gaz arttıkça küçülür / falls as gas rises
34  float ppm = PARA * pow(ratio, -PARB);       // tahmini CO2 eşdeğeri / estimated CO2 equivalent
35
36  Serial.print(F("Rs/R0 = "));
37  Serial.print(ratio, 2);
38  Serial.print(F("   ~"));
39  Serial.print(ppm, 0);
40  Serial.print(F(" ppm   "));
41  Serial.println(airLabel(ppm));
42  delay(2000);
43}

Hoe beïnvloeden temperatuur en luchtvochtigheid de MQ-135?

De weerstand van metaaloxidesensoren hangt niet alleen af van gas, maar ook van kamertemperatuur en luchtvochtigheid. Volgens de datasheetcurve daalt in dezelfde lucht de verhouding Rs/R0 merkbaar als de temperatuur stijgt van 20 °C naar 40 °C, en ze daalt ook als de luchtvochtigheid toeneemt; de sensor leest dit als "meer gas". Het gevolg zijn ppm-waarden die uit zichzelf oplopen in een kamer met middagzon of in een badkamer na het douchen. Je kunt dit op twee manieren verminderen: kalibreer bij een temperatuur en luchtvochtigheid die dicht bij die van je gebruiksplek liggen, of meet temperatuur en luchtvochtigheid met een DHT22 of DHT11 en pas de correctieformule uit de bibliotheken toe. Functies als getCorrectedPPM(temperature, humidity) in kant-en-klare MQ135-bibliotheken doen precies dat. Wil je temperatuur en luchtvochtigheid nauwkeuriger meten dan een DHT11, dan kun je een BME280-sensor gebruiken.

Een ventilator automatiseren

De nuttigste taak van de MQ-135 is vanzelf een ventilator of afzuiging aanzetten als de lucht bedompt wordt. Twee details doen ertoe. Het eerste is hysterese: de ventilator gaat aan boven 1000 ppm maar pas uit als de waarde onder 800 ppm zakt; met één drempel zou het relais elke seconde klikken terwijl de waarde eromheen schommelt. Het tweede is een minimale looptijd: als de ventilator aan is, draait hij minstens 2 minuten zodat de lucht in de ruimte echt wordt ververst. De code filtert de metingen ook, zodat kortstondige pieken de ventilator niet activeren.

C++ (Arduino IDE)
1const byte MQ_PIN = A0;
2const byte FAN_PIN = 7;                    // röle modülü IN / relay module IN
3const bool RELAY_ACTIVE_LOW = true;        // çoğu modül LOW ile çeker / most modules switch on with LOW
4const float RL_KOHM = 1.0;
5const float R0_KOHM = 3.6;                 // kendi kalibrasyon sonucun / your calibration result
6const float PARA = 116.6020682;
7const float PARB = 2.769034857;
8const float FAN_ON_PPM = 1000;             // bunun üstünde fanı aç / fan on above this
9const float FAN_OFF_PPM = 800;             // bunun altında fanı kapat / fan off below this
10const unsigned long MIN_RUN_MS = 120000;   // fan en az 2 dk çalışır / fan runs at least 2 min
11const unsigned long WARMUP_MS = 180000;    // 3 dk ısınma / 3 min warm-up
12
13bool fanOn = false;
14unsigned long fanStart = 0;
15float smoothPpm = 0;
16
17void setFan(bool on) {
18  fanOn = on;
19  if (on) fanStart = millis();
20  bool level = RELAY_ACTIVE_LOW ? !on : on;
21  digitalWrite(FAN_PIN, level ? HIGH : LOW);
22}
23
24float readPpm() {
25  long sum = 0;
26  for (int i = 0; i < 20; i++) {
27    sum += analogRead(MQ_PIN);
28    delay(10);
29  }
30  float raw = sum / 20.0;
31  if (raw < 1) raw = 1;
32  float rs = RL_KOHM * (1023.0 - raw) / raw;
33  return PARA * pow(rs / R0_KOHM, -PARB);
34}
35
36void setup() {
37  digitalWrite(FAN_PIN, RELAY_ACTIVE_LOW ? HIGH : LOW);   // önce kapalı seviye, sonra çıkış / off level first, then output
38  pinMode(FAN_PIN, OUTPUT);
39  Serial.begin(9600);
40  while (millis() < WARMUP_MS) delay(100);
41  smoothPpm = readPpm();
42}
43
44void loop() {
45  smoothPpm = smoothPpm * 0.8 + readPpm() * 0.2;          // ani sıçramaları yumuşat / smooth out spikes
46
47  if (!fanOn && smoothPpm > FAN_ON_PPM) {
48    setFan(true);
49  } else if (fanOn && smoothPpm < FAN_OFF_PPM && millis() - fanStart > MIN_RUN_MS) {
50    setFan(false);
51  }
52
53  Serial.print(F("~"));
54  Serial.print(smoothPpm, 0);
55  Serial.print(F(" ppm   fan: "));
56  Serial.println(fanOn ? F("ACIK / ON") : F("KAPALI / OFF"));
57  delay(1000);
58}

De IN-pin van de relaismodule gaat naar D7 en VCC en GND naar de Arduino; de ventilator wordt via de COM- en NO-aansluitingen van het relais op zijn eigen voeding aangesloten. Gebruik je een 12 V-computerventilator, dan is een MOSFET stiller en gaat hij langer mee dan een relais; de bedrading is hetzelfde als in de schakeling van de mini-waterpomp. Schakel je een 230 V-apparaat zoals een badkamerafzuiger, volg dan de veiligheidsregels in de gids over de relaismodule tot op de letter: plaats de netspanningskant in een gesloten kast en raak de schakeling nooit aan terwijl hij onder spanning staat. Door de pin in setup() eerst op het uit-niveau te zetten en hem pas daarna als uitgang in te stellen, voorkom je dat actief-LOW-relais bij het opstarten even klikken.

Luchtkwaliteit loggen met een ESP32

Zien hoe de luchtkwaliteit over de dag verandert leert je veel meer dan één meting: alleen een log laat de bedompte lucht in de slaapkamer tegen de ochtend zien, de piek in de keuken tijdens het koken of het effect van een open raam. De ESP32-code hieronder neemt elke minuut een meting, haalt de tijd van internet (NTP) om elke regel van datum en tijd te voorzien en slaat het resultaat als CSV op in het LittleFS-bestandssysteem in het eigen flashgeheugen van de ESP32. Open je het IP-adres van de ESP32 in een browser, dan zie je de laatste meting en kun je de hele log met één klik downloaden als CSV-bestand dat in Excel opent. Er is geen extra bibliotheek nodig.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <LittleFS.h>
4#include <time.h>
5
6const char* WIFI_SSID = "AgAdi";              // Wi-Fi adın / your Wi-Fi name
7const char* WIFI_PASS = "Sifre123";           // Wi-Fi şifren / your Wi-Fi password
8const int MQ_PIN = 34;                        // AO, 10k/20k bölücü üzerinden (ADC1) / through a 10k/20k divider (ADC1)
9const float DIVIDER = 1.5;                    // (10k + 20k) / 20k
10const float RL_KOHM = 1.0;
11const float R0_KOHM = 3.6;                    // ESP32 ile yeniden kalibre et / recalibrate with the ESP32
12const float PARA = 116.6020682;
13const float PARB = 2.769034857;
14const unsigned long LOG_INTERVAL = 60000;     // dakikada bir kayıt / one entry per minute
15
16WebServer server(80);
17unsigned long lastLog = 0;
18float lastPpm = 0;
19
20float readPpm() {
21  uint32_t mv = 0;
22  for (int i = 0; i < 20; i++) {
23    mv += analogReadMilliVolts(MQ_PIN);       // kalibre edilmiş mV / calibrated mV
24    delay(5);
25  }
26  float vout = (mv / 20.0) / 1000.0 * DIVIDER;   // sensör çıkışı (V) / sensor output (V)
27  if (vout < 0.05) vout = 0.05;
28  float rs = RL_KOHM * (5.0 - vout) / vout;
29  return PARA * pow(rs / R0_KOHM, -PARB);
30}
31
32void handleRoot() {
33  String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
34                "<meta name='viewport' content='width=device-width,initial-scale=1'></head>"
35                "<body style='font-family:sans-serif'><h2>MQ-135</h2><p>Son ölçüm / last reading: ~";
36  html += String(lastPpm, 0);
37  html += " ppm</p><p><a href='/log.csv'>CSV indir / download</a> | "
38          "<a href='/clear'>Kaydı sil / clear log</a></p></body></html>";
39  server.send(200, "text/html", html);
40}
41
42void handleCsv() {
43  File f = LittleFS.open("/log.csv", "r");
44  if (!f) {
45    server.send(404, "text/plain", "Kayit yok / no log yet");
46    return;
47  }
48  server.streamFile(f, "text/csv");
49  f.close();
50}
51
52void handleClear() {
53  LittleFS.remove("/log.csv");
54  server.sendHeader("Location", "/");
55  server.send(303);
56}
57
58void setup() {
59  Serial.begin(115200);
60  analogSetPinAttenuation(MQ_PIN, ADC_11db);  // yaklaşık 0-3,1 V ölçüm aralığı / about 0-3.1 V range
61  if (!LittleFS.begin(true)) {                // true: ilk açılışta biçimlendir / format on first use
62    Serial.println("LittleFS hatasi / error");
63  }
64  WiFi.mode(WIFI_STA);
65  WiFi.begin(WIFI_SSID, WIFI_PASS);
66  while (WiFi.status() != WL_CONNECTED) {
67    delay(500);
68    Serial.print(".");
69  }
70  Serial.println();
71  Serial.println(WiFi.localIP());
72  configTime(3 * 3600, 0, "pool.ntp.org");    // UTC+3; kendi saat dilimine göre değiştir / change to your time zone
73
74  server.on("/", handleRoot);
75  server.on("/log.csv", handleCsv);
76  server.on("/clear", handleClear);
77  server.begin();
78  lastLog = millis();                         // ilk kayıt 1 dk sonra, sensör ısınırken / first entry after 1 min
79}
80
81void loop() {
82  server.handleClient();
83  if (millis() - lastLog >= LOG_INTERVAL) {
84    lastLog = millis();
85    lastPpm = readPpm();
86    char stamp[20] = "saat-yok";
87    struct tm now;
88    if (getLocalTime(&now, 100)) {
89      strftime(stamp, sizeof(stamp), "%Y-%m-%d %H:%M", &now);
90    }
91    File f = LittleFS.open("/log.csv", "a");  // dosyanın sonuna ekle / append to the file
92    if (f) {
93      f.printf("%s,%.0f\n", stamp, lastPpm);
94      f.close();
95    }
96    Serial.printf("%s  ~%.0f ppm\n", stamp, lastPpm);
97  }
98}

Omdat de ADC van de ESP32 anders meet dan die van de Uno, is het het best de R0-kalibratie met deze schakeling opnieuw te doen; pas gewoon de functie readRs() in de kalibratiecode aan volgens de logica van readPpm() hier. Sluit de sensor aan op een van de ADC1-pins tussen GPIO 32 en 39: ADC2-pins kunnen niet worden gebruikt als Wi-Fi aan staat. Elke regel is ongeveer 22 bytes; met één meting per minuut bouwt zich per dag zo'n 32 KB aan data op, en het gebied van 1,5 MB in het standaardpartitieschema gaat ruwweg anderhalve maand mee. Voor langere logs kun je een SD-kaartmodule gebruiken, en wil je de gegevens rechtstreeks naar een spreadsheet sturen, kijk dan naar de methode ESP32 met Google Sheets.

MQ-135 met de Raspberry Pi Pico (MicroPython)

Op de Pico voed je de module met 5 V van de VBUS-pin en sluit je de AO-uitgang aan op GP26, weer via een 10 kΩ / 20 kΩ-deler. De ADC van de Pico levert een 16-bitswaarde (0–65535) met 3,3 V als referentie; de code zet die eerst om naar een spanning en daarna, met de deelverhouding, naar de sensoruitgang. De formule is dezelfde als op de Arduino. Omdat VBUS afhankelijk van de USB-bron tussen 4,8 en 5,1 V kan variëren, meet je voor nauwkeurige resultaten VBUS met een multimeter en corrigeer je de 5.0 in de code.

MicroPython
1from machine import ADC
2import time
3
4adc = ADC(26)                          # GP26 = ADC0, AO bölücü üzerinden / AO through a divider
5DIVIDER = 1.5                          # (10k + 20k) / 20k
6RL = 1.0                               # kΩ, karttaki yük direnci / load resistor on the board
7R0 = 3.6                               # kΩ, kendi kalibrasyon sonucun / your calibration result
8PARA, PARB = 116.6020682, 2.769034857
9VCC = 5.0                              # VBUS gerilimi / VBUS voltage
10
11def read_rs():
12    total = 0
13    for _ in range(20):
14        total += adc.read_u16()
15        time.sleep_ms(5)
16    v = total / 20 / 65535 * 3.3 * DIVIDER    # sensör çıkışı (V) / sensor output (V)
17    v = max(v, 0.05)                          # sıfıra bölmeyi önle / avoid dividing by zero
18    return RL * (VCC - v) / v
19
20print("Isiniyor / warming up...")
21time.sleep(180)                        # 3 dk ısınma / 3 min warm-up
22while True:
23    ratio = read_rs() / R0
24    ppm = PARA * ratio ** -PARB        # tahmini CO2 eşdeğeri / estimated CO2 equivalent
25    print("Rs/R0 = %.2f   ~%d ppm" % (ratio, ppm))
26    time.sleep(2)

MQ-135 vs CCS811 vs NDIR-CO2-sensoren

Er zijn drie klassen luchtkwaliteitssensoren en elke beantwoordt een andere vraag. De MQ-135 is goedkoop, analoog en eenvoudig; hij toont algemene veranderingen in de lucht. De CCS811 is ook een metaaloxidesensor, maar heeft zijn eigen microcontroller, beheert de verwarming zelf en geeft TVOC (totaal vluchtige organische stoffen) en eCO2 (equivalent CO2) rechtstreeks via I2C; we behandelen hem in de gids CCS811-luchtkwaliteitssensor. De enige groep die echte CO2 meet zijn NDIR-sensoren (non-dispersive infrared): modules als de MH-Z19B of SenseAir S8 meten hoeveel infrarood licht van 4,26 µm door CO2-moleculen wordt geabsorbeerd en worden nauwelijks beïnvloed door andere gassen.

EigenschapMQ-135CCS811NDIR (MH-Z19B, SenseAir S8)
MeetprincipeWeerstand van verwarmd SnO2Metaaloxide + ingebouwde microcontrollerAbsorptie van infraroodlicht
Meet echte CO2?Nee, hij schatNee, berekent eCO2 uit VOC'sJa
UitgangAnaloog (plus digitale drempel)I2CUART of PWM
Voeding5 V, ongeveer 150 mA3,3 V, gemiddeld ongeveer 30 mA5 V, gemiddeld onder 60 mA
Opwarmen24–48 uur als hij nieuw is, daarna een paar minuten48 uur als hij nieuw is, daarna 20 minutenOngeveer 3 minuten
NauwkeurigheidLaag, voor relatieve veranderingenGemiddeld, voor relatieve VOC-trackingOngeveer ±50 ppm + 3–5% van de meting
PrijsGoedkoopstGemiddeldDuurst

Kortom: om te leren, een alarm of ventilator te activeren en veranderingen in de lucht te volgen is de MQ-135 genoeg. Wil je dampen van verf, lijm of schoonmaakmiddelen volgen, dan geeft de CCS811 vloeiendere, stabielere data. Heb je een betrouwbaar getal nodig om "is het tijd om het raam open te doen?" te beantwoorden in een klaslokaal, kantoor of slaapkamer, dan moet je investeren in een NDIR-CO2-sensor. Veel mensen gebruiken beide: de NDIR-sensor volgt de CO2, terwijl de MQ-135 plotselinge gebeurtenissen zoals rook of oplosmiddelgeur in de keuken opvangt.

Projectideeën met de MQ-135

  • Luchtindicator voor in huis: Een RGB-led die groen, geel of rood oplicht afhankelijk van de luchtkwaliteit, of een live grafiek op een OLED-display.
  • Slimme keukenafzuiging: Een systeem dat de afzuiging aanzet als er tijdens het koken rook en stoom ontstaan en uitzet zodra de lucht schoon is.
  • Waarschuwing voor garage en verfwerkplaats: Een schakeling die een buzzer laat klinken en de ventilatie start als oplosmiddeldamp toeneemt.
  • Kattenbakmonitor: Een ESP32-project dat je telefoon waarschuwt als de ammoniak stijgt en het tijd is om de kattenbakvulling te verversen.
  • Luchtboard voor het klaslokaal: Een grafiek die metingen met een ESP32 logt en vergelijkt met lestijden om ventilatiegewoonten te tonen.
  • Domotica: Stuur de waarden via MQTT naar Home Assistant en zet met een slimme stekker een luchtreiniger aan als de lucht slechter wordt.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
Waarden blijven uren driftenEerste voorverwarming niet voltooidLaat de sensor 24–48 uur non-stop draaien en kalibreer daarna
Waarden veel te hoog of te laag bij het opstartenGeen dagelijkse opwarmtijd afgewachtWacht minstens 3 minuten, bij voorkeur 10–20, voordat je meet
Duizenden ppm, zelfs in schone luchtVerkeerde R0, of kalibratie binnenshuis gedaanHerhaal de kalibratie in schone buitenlucht
Op de ESP32 zijn de waarden altijd maximaalAO haalt 5 V, of de sensor draait op 3,3 VVoed de sensor met 5 V en voeg een 10k/20k-deler toe op AO
De Arduino wordt warm of USB valt wegDe verwarming van 150 mA plus andere belastingen zet de USB onder drukGebruik een externe 5 V-voeding en verbind de massa's
ppm stijgt in zonlicht of na het douchenEffect van temperatuur en luchtvochtigheidKalibreer onder vergelijkbare omstandigheden of pas DHT22-correctie toe
Interpreteer MQ-135-waarden niet als absolute meting, maar als een verandering ten opzichte van een basislijn. Neem nadat de sensor is opgewarmd de waarde die je op een schoon moment meet als basislijn en neem beslissingen met relatieve drempels zoals "30% boven de basislijn"; deze aanpak is veel robuuster tegen kalibratiefouten, veroudering van de sensor en seizoensinvloeden. Het voortschrijdend gemiddelde en de mediaanfilters waarmee je de metingen kunt afvlakken behandelen we in sensordata filteren.

Zolang je de grenzen kent, is de MQ-135 een uitstekende instapsensor om te leren over luchtkwaliteit en ventilatie te automatiseren: voed hem met 5 V, geef hem 24–48 uur voorverwarming, vind R0 in schone lucht, lees de resultaten relatief af en stap over op een NDIR-sensor als je echte CO2 nodig hebt. In de BlueGrays-app vind je de projecten Gassensor, Vlam- en gassensoralarm en ESP32 MQ-2-gasdetector, samen met DHT11- en DHT22-temperatuur-/vochtprojecten en het ESP32-temperatuurlogboek, met schakelschema's en code stap voor stap.

Veelgestelde vragen

Kan de MQ135 CO2 meten?

De MQ-135 meet CO2 niet echt; hij schat het. De sensor reageert maar zwak op CO2; zijn echte reactie is op gassen zoals alcohol, ammoniak en benzeen en op de vluchtige stoffen die mensen afgeven. De CO2-ppm-waarde die bibliotheken tonen wordt berekend uit deze algemene vervuiling; voor echte CO2 heb je een NDIR-sensor nodig zoals de MH-Z19B.

Hoe lang duurt het opwarmen van de MQ135?

Een nieuwe MQ-135 heeft een eerste voorverwarming van 24–48 uur nodig, en die moet klaar zijn vóór de kalibratie. Daarna is de sensor bij elke keer aanzetten binnen ongeveer 2–3 minuten bruikbaar; voor de stabielste waarden is 10–20 minuten wachten beter.

Hoe vind je de R0-waarde van de MQ135?

Neem een sensor die zijn voorverwarming heeft voltooid mee naar schone buitenlucht, bereken zijn weerstand met Rs = RL × (1023 − raw) / raw en bereken, uitgaande van ongeveer 420 ppm CO2 buiten, R0 = Rs × (420 / 116.6)^(1 / 2.769). Middel enkele minuten aan metingen. De R0 die je vindt hoort alleen bij die sensor en die belastingsweerstand.

Wat is het verschil tussen de MQ135 en de MQ2?

Beide zijn verwarmde metaaloxidesensoren, maar ze zijn afgestemd op verschillende gassen. De MQ-2 is geschikt voor LPG, propaan, methaan, waterstof en rook, dus hij is de keuze voor gaslekalarmen. De MQ-135 is gevoelig voor luchtverontreinigers zoals ammoniak, benzeen, alcohol, NOx en rook en wordt gebruikt om de luchtkwaliteit te bewaken.

Kun je de MQ135 met een ESP32 gebruiken?

Ja, maar let op twee dingen. De verwarming van de sensor heeft 5 V nodig, dus voed de module via de VIN-pin van de ESP32. De AO-uitgang kan ook 5 V halen, dus breng hem met een spanningsdeler van 10 kΩ en 20 kΩ terug naar 3,3 V en sluit hem aan op een ADC1-pin tussen GPIO 32 en 39.

Welke gassen detecteert de MQ135?

De MQ-135 is het gevoeligst voor ammoniak, zwavelverbindingen en aromatische dampen zoals benzeen. Hij reageert ook duidelijk op alcohol, rook en stikstofoxiden, en zwak op CO2 en koolmonoxide. Hij kan deze gassen niet van elkaar onderscheiden; hij toont alleen de algehele verandering in de lucht.

Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

Temperatuur en luchtvochtigheid met DHT11

Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

4.7(47)
83
Een gassensor gebruiken
AR-51Beginner
Premium

Een gassensor gebruiken

Een kleine bewaker die een gaslek in de keuken eerder opmerkt dan jij. De gassensor snuffelt voortdurend aan de lucht; zolang alles goed is blijft de groene led branden, en als het gas in de lucht…

4.6(37)
50
Alarm met vlam- en gassensor
AR-52Gevorderd
Premium

Alarm met vlam- en gassensor

Een kleine bewaker die je meteen waarschuwt als er gas lekt of ergens een vlam verschijnt.

4.8(52)
67
ESP32 MQ-2 gas-/rookmelderalarm
ES-20Gemiddeld

ESP32 MQ-2 gas-/rookmelderalarm

In dit project detecteer je brandbaar gas (LPG, methaan, propaan) en rook met een MQ-2-gassensormodule en speelt een passieve buzzer bij detectie een sirene-achtig alarm af. De digitale drempeluitgang (DO) van de sensor is verbonden met GPIO 4 van de ESP32. Overschrijdt gas of rook de drempel, dan wordt DO LOW en gaat het alarm af. De gevoeligheid stel je in met de potentiometer op de module. De passieve buzzer wordt met tone() aangestuurd voor een sireneffect met twee frequenties.

4.7(29)
44
ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
ES-15Gemiddeld

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)

Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

4.8(38)
57
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

4.7(7)
12
ESP32 I2C-LCD-display (16x2)
ES-17Gemiddeld
Premium

ESP32 I2C-LCD-display (16x2)

In dit project sluit je een 16x2-tekens-LCD via I2C aan op de ESP32 en toon je tekst. Met I2C bedien je het scherm met slechts 2 datapinnen (SDA en SCL), in plaats van de 6+ pinnen die een klassieke parallelle aansluiting verspilt. De code toont op de eerste regel een vaste tekst en op de tweede regel een teller die elke seconde oploopt. Bij het opstarten schrijft een I2C-scanner ook het adres van het display naar de Serial Monitor (meestal 0x27 of 0x3F).

4.9(23)
40
230V-lamp laten branden met een drukknop
AR-19Gevorderd
Premium

230V-lamp laten branden met een drukknop

Zolang je de knop vasthoudt, brandt een echte lamp op netspanning, en zodra je loslaat gaat hij uit.

4.4(30)
38