MQ-7 koolmonoxidesensor: CO-detectie en alarm met Arduino
Hoe gebruik je de MQ-7 CO-sensor? De verwarmingscyclus van 5 V / 1,4 V, opwarmen, ppm berekenen, kalibreren en een CO-alarm met buzzer op Uno, ESP32 en Pico.
De MQ-7 koolmonoxidesensor is een goedkope halfgeleidergassensor op basis van tindioxide (SnO2) die koolmonoxide (CO) in de lucht detecteert. Volgens de datasheet van de fabrikant reageert hij op CO in het bereik van ongeveer 20–2000 ppm, en je leest hem als een eenvoudige analoge spanning uit met een Arduino, ESP32 of Raspberry Pi Pico. Wat hem onderscheidt van andere MQ-sensoren is dat de verwarming niet op een constante spanning mag draaien; hij moet in een cyclus worden aangestuurd met 60 seconden op 5 V en 90 seconden op 1,4 V. In dit bericht zie je stap voor stap hoe je die cyclus bouwt met een MOSFET en PWM, hoe je ppm berekent uit de gemeten spanning, hoe je in schone lucht kalibreert en hoe je op drie platformen een CO-alarm met buzzer bouwt voor een ruimte met kachel of cv-ketel.
Koolmonoxide is een kleurloos, reukloos en smaakloos gas; het bindt ongeveer 200 keer sterker aan hemoglobine in het bloed dan zuurstof. Daarom sluipt een vergiftiging langzaam op je af: eerst hoofdpijn en slaperigheid, daarna misselijkheid en verwardheid. Elke winter lezen we nieuws over vergiftigingen door slecht brandende kachels, cv-ketels met een verstopt rookkanaal en geisers die in afgesloten ruimtes draaien. Dat maakt de MQ-7 een zeer leerzaam onderdeel, zowel om te leren hoe gassensoren werken als om een echt probleem te begrijpen.

Wat is de MQ-7 en hoe werkt hij?
Onder het metalen gaasdopje van de sensor zit een klein keramisch buisje met een laagje tindioxide en een dun draadje dat het verwarmt. Het verwarmde SnO2-oppervlak adsorbeert zuurstof uit de lucht en in die toestand is de elektrische weerstand hoog. Is er een reducerend gas zoals CO aanwezig, dan reageert dat met de zuurstof op het oppervlak en de vrijgekomen elektronen verlagen de weerstand van de laag. Met andere woorden: naarmate er meer CO is, daalt de sensorweerstand (Rs). Als je deze weerstand in serie zet met een belastingsweerstand (RL) en de spanning in het midden meet, heb je eigenlijk een spanningsdeler gebouwd en lees je het CO-niveau als analoge waarde uit.
| Eigenschap | Waarde |
|---|---|
| Gedetecteerd gas | Koolmonoxide (CO); reageert ook op waterstof en alcohol |
| Meetbereik | 20–2000 ppm CO |
| Verwarmingsspanning | 5 V ± 0,1 V (hoge fase), 1,4 V ± 0,1 V (lage fase) |
| Duur van de fasen | 60 s hoog, 90 s laag (één cyclus is 150 s) |
| Weerstand van de verwarming | Ongeveer 33 Ω |
| Verwarmingsstroom | Ongeveer 150 mA bij 5 V, ongeveer 42 mA bij 1,4 V |
| Vermogen van de verwarming | Gemiddeld over de cyclus ongeveer 350 mW (ongeveer 0,76 W in de 5V-fase) |
| Rs (in 100 ppm CO) | 2–20 kΩ (verschilt per sensor) |
| Spanning van de meetschakeling (Vc) | 5 V in de datasheet; 3,3 V werkt ook |
| Eerste inbrandperiode | Meer dan 48 uur |
De verwarmingscyclus: waarom 5 V en 1,4 V?
Sensoren zoals de MQ-2 houden de verwarming op een constante 5 V. De MQ-7 detecteert CO daarentegen het best bij een lage temperatuur, maar bij lage temperatuur hopen vocht en andere gassen zich op het oppervlak op. Daarom verwarmt en reinigt de fase van 60 seconden op 5 V het oppervlak; tijdens de fase van 90 seconden op 1,4 V koelt het oppervlak af, adsorbeert CO en verandert de weerstand. Je meet in de laatste seconden van deze lage fase. Een Arduino heeft geen uitgang die 1,4 V levert; die krijg je door 5 V snel aan en uit te schakelen met een MOSFET, dus met PWM. Het belangrijkste punt hierbij: de verwarming is een weerstand en warmte wordt bepaald door vermogen (P = V² / R). De duty cycle die het vermogen van 1,4 V geeft is D = (1,4 / 5)² ≈ 7,8%; de effectieve spanning vind je met U = 5 · √D. Een veelgemaakte fout is 28% gebruiken (analogWrite 71); dat levert ongeveer 3,6 keer het vereiste vermogen en oververhit de sensor, waardoor de gevoeligheid daalt.
| Fase | Verwarming | Duur | Uno-opdracht | Wat gebeurt er? |
|---|---|---|---|---|
| Reinigen (hoog) | 5 V | 60 s | digitalWrite(9, HIGH) | Het oppervlak warmt op en opgehoopt vocht en gassen worden verdreven; er wordt niet gemeten |
| Meten (laag) | 1,4 V effectief | 90 s | analogWrite(9, 20) ≈ 7,8% | Het oppervlak koelt af, CO adsorbeert en de weerstand daalt; de meting gebeurt aan het einde van de fase |
| Eén volledige cyclus | - | 150 s | - | Elke 2,5 minuut een nieuwe ppm-waarde |
Module of kale sensor?
De gangbare blauwe MQ-7-modules hebben de sensor, een LM393-comparator, een trimpotmeter voor de drempel, een voedingsled en AO- en DO-uitgangen. Op de meeste van deze boards zit de verwarming direct tussen VCC en GND, dus de sensor wordt op een constante 5 V verwarmd. In dat geval volgt de meting de datasheetcurve niet; de waarde wordt een grove indicator die alleen zegt dat er "iets veranderd is". Voor een goede cyclus gebruik je de kale MQ-7 met 6 pinnen, of je knipt het GND-pad van de verwarming op de module door en sluit het aan op een MOSFET. Bij de kale sensor zijn de twee H-pinnen de aansluitingen van de verwarming; de twee A-pinnen en de twee B-pinnen zijn intern met elkaar verbonden en de sensor heeft geen polariteit. Gebruik je een module, lees dan de waarde van de belastingsweerstand op het board af aan de SMD-code (102 = 1 kΩ, 103 = 10 kΩ); de SMD-codecalculator doet dat voor je. De constante RL in de code moet met deze waarde overeenkomen.
Bedradingsschema: Arduino Uno, ESP32 en Pico
De schakeling heeft twee delen. In het verwarmingsdeel gaat de ene H-aansluiting naar 5 V en de andere H-aansluiting naar de drain van een N-kanaal-MOSFET; de source gaat naar GND. De gate gaat via 220 Ω naar de PWM-pin en een weerstand van 100 kΩ tussen gate en GND voorkomt dat de verwarming ongecontroleerd draait terwijl het board opstart. Een logic-level-MOSFET zoals de IRLZ44N past bij de Uno, en een MOSFET met lage drempelspanning zoals de AO3400 past bij de ESP32 en Pico op 3,3 V; heb je die niet, dan kun je een NPN-transistor zoals de BC337 of 2N2222 gebruiken met een basisweerstand van 470 Ω. Voor details zie Een MOSFET gebruiken met Arduino en de transistortool. In het meetdeel gaat pin A naar de meetvoeding (Vc), pin B naar de analoge ingang en gaat een RL-weerstand van 10 kΩ van pin B naar GND. Omdat Rs een weerstand is, verpest het kiezen van 3,3 V voor Vc op de ESP32 en Pico de berekening niet; het vermogen dat in de meetlaag wordt omgezet is verwaarloosbaar klein vergeleken met de verwarming.
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Verwarming H (1e aansluiting) | 5V | VIN / 5V (USB) | VBUS (pin 40) |
| Verwarming H (2e aansluiting) | MOSFET drain | MOSFET drain | MOSFET drain |
| MOSFET-gate (via 220 Ω) | D9 | GPIO 25 | GP15 |
| MOSFET-source en gateweerstand van 100 kΩ | GND | GND | GND |
| Sensor A (meetvoeding Vc) | 5V | 3V3 | 3V3(OUT) (pin 36) |
| Sensor B (naar GND met RL van 10 kΩ) | A0 | GPIO 34 | GP26 (ADC0) |
| Actieve buzzer + | D8 | GPIO 26 | GP14 |
| Waarschuwingsled (met 220 Ω) | D13 | GPIO 27 | GP13 |
ppm berekenen: Rs, R0 en de log-logcurve
Uit de spanning Vout die je op de analoge ingang uitleest, vind je de sensorweerstand met deze formule: Rs = RL × (Vc − Vout) / Vout. Bijvoorbeeld: op de Uno met Vc = 5 V, RL = 10 kΩ en Vout = 1,0 V is Rs = 10 kΩ × 4 / 1 = 40 kΩ; dit kun je ook controleren met de tool voor de wet van Ohm. De datasheet definieert de sensor ten opzichte van een referentie die R0 heet: R0 is de weerstand van de sensor in 100 ppm CO. Het verband tussen de verhouding Rs/R0 en de CO-concentratie is op een log-logdiagram bij benadering een rechte lijn, dus het kan met een machtsformule worden uitgedrukt. De benadering uit de datasheetcurve, die ook populaire MQ-bibliotheken gebruiken, is: ppm = 99.042 × (Rs/R0)^−1.518. Volgens dezelfde curve is de verhouding Rs/R0 in schone lucht ongeveer 27,5. Deze getallen komen uit het aflezen van de curve en elke sensor is iets anders; zie het resultaat als een goede schatting, niet als een exacte meting.
| Rs/R0 | Berekende CO | Opmerking |
|---|---|---|
| 27.5 | ≈ 0,7 ppm | Schone lucht (kalibratiereferentie) |
| 5 | ≈ 9 ppm | Bovengrens van een normale woonomgeving |
| 2 | ≈ 35 ppm | Ventilatie nodig |
| 1.5 | ≈ 54 ppm | De waarschuwingsdrempel in de code (50 ppm) wordt overschreden |
| 1 | ≈ 99 ppm | Definitie van R0 (100 ppm); de alarmdrempel in de code |
| 0.5 | ≈ 284 ppm | Gevaarlijk; ventileer de ruimte onmiddellijk en verlaat haar |
| 0.25 | ≈ 813 ppm | Levensbedreigend |
Kalibreren stap voor stap
Je hebt thuis geen testgas van 100 ppm, dus je kunt R0 niet rechtstreeks meten. In plaats daarvan meet je de weerstand in schone lucht en schat je R0 door die te delen door 27,5. De onderstaande code print bij elke cyclus zowel Rs als deze schatting, dus je hebt geen apart kalibratieprogramma nodig.
- Laat een nieuwe sensor vóór het eerste gebruik minstens 48 uur met de cyclus in de schakeling draaien; zonder deze inbrandperiode driften de waarden dagenlang.
- Zet de schakeling buiten of op een goed geventileerde plek, uit de buurt van kachels, de kookplaat en uitlaatgassen van voertuigen. De omstandigheden in de datasheet zijn ongeveer 20 °C en 65% relatieve luchtvochtigheid; hoe dichter je daarbij zit, hoe beter.
- Upload de code en open de Serial Monitor. Negeer de eerste 2 cycli na het opstarten (ongeveer 5 minuten); de sensor is dan nog niet gestabiliseerd.
- Noteer de waarden van de "R0-schatting" van minstens 10 opeenvolgende cycli (ongeveer 25 minuten) en bereken hun gemiddelde.
- Schrijf dit gemiddelde in de constante R0 in de code en upload opnieuw. Als je wilt, kun je de waarde opslaan in EEPROM en met een knop opnieuw kalibreren.
- Herhaal de kalibratie als het seizoen wisselt of om de paar maanden; R0 driftt langzaam naarmate de sensor veroudert.
Koolmonoxideniveaus en alarmdrempels
Gecertificeerde melders voor thuis werken niet met een momentane limiet, maar met tijdsafhankelijke drempels. Volgens EN 50291 moet een melder bij 50 ppm binnen 60–90 minuten alarm slaan, bij 100 ppm binnen 10–40 minuten en bij 300 ppm binnen 3 minuten. Onze schakeling levert maar elke 150 seconden een nieuwe waarde en heeft een grote foutmarge; daarom gedragen we ons in de code voorzichtiger, met een schaarse waarschuwingspiep bij 50 ppm en een snel onderbroken alarm bij 100 ppm. De onderstaande tabel toont bij benadering de effecten op gezonde volwassenen; kinderen, ouderen, zwangere vrouwen en mensen met hartziekten worden al bij veel lagere niveaus getroffen.
| CO-niveau | Wat het betekent |
|---|---|
| Onder 9 ppm | Normale binnenomgeving; de 8-uursrichtwaarde van de WHO is ongeveer 9 ppm |
| 35 ppm | In veel landen de 1-uurslimiet voor buitenlucht; risico op hoofdpijn bij langdurige blootstelling |
| 50 ppm | Een gecertificeerde melder slaat binnen 60–90 minuten alarm |
| 200 ppm | Hoofdpijn, vermoeidheid en misselijkheid binnen 2–3 uur |
| 400 ppm | Ernstige hoofdpijn binnen 1–2 uur; blootstelling langer dan 3 uur is levensbedreigend |
| 800 ppm | Duizeligheid, braken en bewusteloosheid binnen 45 minuten; kans op overlijden binnen 2–3 uur |
CO-alarm met buzzer met Arduino Uno
De onderstaande code beheert tegelijk de verwarmingscyclus, de meting en het alarm. Omdat de fasen 150 seconden duren, wordt millis() gebruikt in plaats van delay; zo blokkeren het buzzerpatroon en de cyclus elkaar niet. De code komt precies overeen met de pinnen in de bedradingstabel en gebruikt ook de ingebouwde led (D13) als waarschuwingslicht. Kies een actieve buzzer met een eigen oscillator; voor details zie het verschil tussen actieve en passieve buzzers.
1// MQ-7 karbonmonoksit alarmı - Arduino Uno / MQ-7 carbon monoxide alarm - Arduino Uno
2const int HEATER_PIN = 9; // MOSFET kapısı (PWM) / MOSFET gate (PWM)
3const int SENSOR_PIN = A0; // sensör B ucu + RL / sensor B pin + RL
4const int BUZZER_PIN = 8; // aktif buzzer / active buzzer
5const int LED_PIN = 13; // uyarı LED'i / warning LED
6
7const float VC = 5.0; // ölçüm devresi gerilimi / sensing circuit voltage
8const float RL = 10000.0; // yük direnci (ohm) / load resistor (ohm)
9float R0 = 5000.0; // kalibrasyonla bulduğun değer / value from calibration
10
11const unsigned long HIGH_MS = 60000UL; // 5 V fazı / 5 V phase
12const unsigned long LOW_MS = 90000UL; // 1,4 V fazı / 1.4 V phase
13const int LOW_DUTY = 20; // 5*sqrt(20/255) = 1,40 V etkin / 1.40 V effective
14const float WARN_PPM = 50.0; // uyarı eşiği / warning threshold
15const float ALARM_PPM = 100.0; // alarm eşiği / alarm threshold
16const int WARMUP_CYCLES = 2; // ilk 2 döngü yok sayılır / first 2 cycles ignored
17
18bool highPhase = true;
19unsigned long phaseStart = 0;
20int cycles = 0;
21float ppm = 0.0;
22
23float readRs() {
24 long sum = 0;
25 for (int i = 0; i < 20; i++) { // 20 örnek ortalaması / average of 20 samples
26 sum += analogRead(SENSOR_PIN);
27 delay(5);
28 }
29 float vout = (sum / 20.0) * VC / 1023.0;
30 vout = constrain(vout, 0.01, VC - 0.01); // sıfıra bölmeyi önle / avoid division by zero
31 return RL * (VC - vout) / vout;
32}
33
34void updateAlarm(unsigned long now) {
35 bool ready = cycles >= WARMUP_CYCLES;
36 bool on = false;
37 if (ready && ppm >= ALARM_PPM) {
38 on = (now / 250) % 2; // hızlı kesik alarm / fast intermittent alarm
39 } else if (ready && ppm >= WARN_PPM) {
40 on = (now % 2000) < 150; // 2 saniyede bir kısa bip / short beep every 2 s
41 }
42 digitalWrite(BUZZER_PIN, on ? HIGH : LOW);
43 digitalWrite(LED_PIN, (ready && ppm >= WARN_PPM) ? HIGH : LOW);
44}
45
46void setup() {
47 Serial.begin(9600);
48 pinMode(HEATER_PIN, OUTPUT);
49 pinMode(BUZZER_PIN, OUTPUT);
50 pinMode(LED_PIN, OUTPUT);
51 digitalWrite(HEATER_PIN, HIGH); // 5 V fazıyla başla / start with the 5 V phase
52 phaseStart = millis();
53 Serial.println(F("MQ-7 isiniyor... / MQ-7 warming up..."));
54}
55
56void loop() {
57 unsigned long now = millis();
58
59 if (highPhase && now - phaseStart >= HIGH_MS) {
60 analogWrite(HEATER_PIN, LOW_DUTY); // 1,4 V fazına geç / switch to the 1.4 V phase
61 highPhase = false;
62 phaseStart = now;
63 } else if (!highPhase && now - phaseStart >= LOW_MS) {
64 float rs = readRs(); // düşük fazın sonunda ölç / measure at the end of the low phase
65 ppm = 99.042 * pow(rs / R0, -1.518);
66 cycles++;
67 Serial.print(F("Rs: "));
68 Serial.print(rs, 0);
69 Serial.print(F(" ohm R0 tahmini / estimate: "));
70 Serial.print(rs / 27.5, 0);
71 Serial.print(F(" CO: "));
72 Serial.print(ppm, 1);
73 Serial.println(F(" ppm"));
74 digitalWrite(HEATER_PIN, HIGH); // yeniden 5 V / back to 5 V
75 highPhase = true;
76 phaseStart = now;
77 }
78
79 updateAlarm(now);
80}| Codegedeelte | Wat het doet |
|---|---|
| HIGH_MS / LOW_MS | Duur van de fasen van 60 seconden op 5 V en 90 seconden op 1,4 V |
| LOW_DUTY = 20 | Effectief 1,4 V uit 5V-PWM: 5 · √(20/255) ≈ 1,40 V |
| readRs() | Middelt 20 metingen, begrenst Vout en berekent Rs |
| pow(rs / R0, -1.518) | ppm-schatting met de formule die uit de datasheetcurve is afgeleid |
| cycles / WARMUP_CYCLES | Dempt het alarm tijdens de eerste 2 cycli na het opstarten |
| updateAlarm() | Schaarse piep en led boven 50 ppm, snel onderbroken alarm boven 100 ppm |
| digitalWrite(HEATER_PIN, HIGH) | Zet PWM uit en zet de verwarming terug op volle 5 V |
CO-alarm met de ESP32
De logica is op de ESP32 dezelfde; alleen de PWM- en ADC-onderdelen veranderen. De verwarming wordt aangestuurd met de LEDC-peripheral op 1 kHz en 8-bits PWM; omdat de LEDC-functies verschillen tussen versie 2.x en 3.x van de Arduino ESP32-core, ondersteunt de code beide. De sensor is aangesloten op GPIO 34 in de ADC1-groep, die ook werkt terwijl Wi-Fi aanstaat, en een gekalibreerde millivoltwaarde wordt uitgelezen met analogReadMilliVolts(). Omdat de meetschakeling op 3V3 wordt gevoed, komt de uitgang bij hoge CO-waarden dicht bij 3 V; de ADC van de ESP32 verliest in dit gebied wat lineariteit, maar voor een alarm is het goed genoeg. Het bericht over hoe een ADC werkt legt dit uitgebreid uit.
1// MQ-7 CO alarmı - ESP32 / MQ-7 CO alarm - ESP32
2const int HEATER_PIN = 25; // MOSFET kapısı / MOSFET gate
3const int SENSOR_PIN = 34; // ADC1, Wi-Fi ile çalışır / ADC1, works with Wi-Fi
4const int BUZZER_PIN = 26; // aktif buzzer / active buzzer
5const int LED_PIN = 27; // uyarı LED'i / warning LED
6
7const float VC = 3.3; // ölçüm devresi 3V3 / sensing circuit on 3V3
8const float RL = 10000.0; // yük direnci (ohm) / load resistor (ohm)
9float R0 = 5000.0; // kalibrasyon değeri / calibration value
10
11const unsigned long HIGH_MS = 60000UL;
12const unsigned long LOW_MS = 90000UL;
13const int PWM_FREQ = 1000; // 1 kHz
14const int PWM_RES = 8; // 8 bit (0-255)
15const int DUTY_HIGH = 255; // ~5 V
16const int DUTY_LOW = 20; // ~%7,8 -> 1,40 V etkin / 1.40 V effective
17const float WARN_PPM = 50.0;
18const float ALARM_PPM = 100.0;
19const int WARMUP_CYCLES = 2;
20
21#if defined(ESP_ARDUINO_VERSION_MAJOR) && ESP_ARDUINO_VERSION_MAJOR >= 3
22void heaterBegin() { ledcAttach(HEATER_PIN, PWM_FREQ, PWM_RES); } // çekirdek 3.x / core 3.x
23void heaterSet(int duty) { ledcWrite(HEATER_PIN, duty); }
24#else
25const int PWM_CH = 0;
26void heaterBegin() { // çekirdek 2.x / core 2.x
27 ledcSetup(PWM_CH, PWM_FREQ, PWM_RES);
28 ledcAttachPin(HEATER_PIN, PWM_CH);
29}
30void heaterSet(int duty) { ledcWrite(PWM_CH, duty); }
31#endif
32
33bool highPhase = true;
34unsigned long phaseStart = 0;
35int cycles = 0;
36float ppm = 0.0;
37
38float readRs() {
39 uint32_t sum = 0;
40 for (int i = 0; i < 20; i++) {
41 sum += analogReadMilliVolts(SENSOR_PIN); // kalibre mV / calibrated mV
42 delay(5);
43 }
44 float vout = (sum / 20.0) / 1000.0;
45 vout = constrain(vout, 0.01, VC - 0.01); // sıfıra bölmeyi önle / avoid division by zero
46 return RL * (VC - vout) / vout;
47}
48
49void updateAlarm(unsigned long now) {
50 bool ready = cycles >= WARMUP_CYCLES;
51 bool on = false;
52 if (ready && ppm >= ALARM_PPM) {
53 on = (now / 250) % 2; // hızlı kesik alarm / fast intermittent alarm
54 } else if (ready && ppm >= WARN_PPM) {
55 on = (now % 2000) < 150; // seyrek bip / sparse beep
56 }
57 digitalWrite(BUZZER_PIN, on ? HIGH : LOW);
58 digitalWrite(LED_PIN, (ready && ppm >= WARN_PPM) ? HIGH : LOW);
59}
60
61void setup() {
62 Serial.begin(115200);
63 pinMode(BUZZER_PIN, OUTPUT);
64 pinMode(LED_PIN, OUTPUT);
65 heaterBegin();
66 heaterSet(DUTY_HIGH); // 5 V fazıyla başla / start with the 5 V phase
67 phaseStart = millis();
68 Serial.println("MQ-7 isiniyor... / MQ-7 warming up...");
69}
70
71void loop() {
72 unsigned long now = millis();
73
74 if (highPhase && now - phaseStart >= HIGH_MS) {
75 heaterSet(DUTY_LOW); // 1,4 V fazı / 1.4 V phase
76 highPhase = false;
77 phaseStart = now;
78 } else if (!highPhase && now - phaseStart >= LOW_MS) {
79 float rs = readRs(); // düşük fazın sonunda ölç / measure at the end of the low phase
80 ppm = 99.042 * pow(rs / R0, -1.518);
81 cycles++;
82 Serial.printf("Rs: %.0f ohm R0 tahmini / estimate: %.0f CO: %.1f ppm\n", rs, rs / 27.5, ppm);
83 heaterSet(DUTY_HIGH); // yeniden 5 V / back to 5 V
84 highPhase = true;
85 phaseStart = now;
86 }
87
88 updateAlarm(now);
89}CO-alarm met Raspberry Pi Pico (MicroPython)
Op de Pico bouw je dezelfde cyclus met MicroPython. De PWM-uitgang zit op GP15 op 1 kHz; in MicroPython stel je de duty in met de 16-bits duty_u16(), dus een duty van 7,8% komt overeen met de waarde 5140. De sensor sluit aan op de pin GP26 (ADC0) en read_u16() geeft een waarde in het bereik 0–65535. De verwarming krijgt 5 V van de VBUS-pin; VBUS geeft alleen 5 V als de Pico via USB wordt gevoed, dus als je hem via VSYS op een batterij laat draaien, moet je een aparte 5V-voeding op de verwarming aansluiten. Omdat de GPIO's van de Pico 3,3 V en laagstroom zijn, is het veiliger om een actieve buzzermodule met een transistor te kiezen. Ben je nieuw met MicroPython, begin dan met het bericht MicroPython-basis.
1from machine import Pin, PWM, ADC
2import time
3
4# MQ-7 CO alarmı - Raspberry Pi Pico / MQ-7 CO alarm - Raspberry Pi Pico
5heater = PWM(Pin(15)) # MOSFET kapısı / MOSFET gate
6heater.freq(1000)
7sensor = ADC(26) # GP26 = ADC0, sensör B ucu / sensor B pin
8buzzer = Pin(14, Pin.OUT) # aktif buzzer / active buzzer
9led = Pin(13, Pin.OUT) # uyarı LED'i / warning LED
10
11VC = 3.3 # ölçüm devresi 3V3 / sensing circuit on 3V3
12RL = 10000 # yük direnci (ohm) / load resistor (ohm)
13R0 = 5000.0 # kalibrasyon değeri / calibration value
14HIGH_MS = 60000 # 5 V fazı / 5 V phase
15LOW_MS = 90000 # 1,4 V fazı / 1.4 V phase
16DUTY_HIGH = 65535 # tam açık / fully on
17DUTY_LOW = 5140 # %7,8 -> 1,40 V etkin / 7.8% -> 1.40 V effective
18WARN_PPM = 50
19ALARM_PPM = 100
20WARMUP_CYCLES = 2
21
22def read_rs():
23 total = 0
24 for _ in range(20): # 20 örnek ortalaması / average of 20 samples
25 total += sensor.read_u16()
26 time.sleep_ms(5)
27 vout = (total / 20) * VC / 65535
28 vout = min(max(vout, 0.01), VC - 0.01) # sıfıra bölmeyi önle / avoid division by zero
29 return RL * (VC - vout) / vout
30
31heater.duty_u16(DUTY_HIGH) # 5 V fazıyla başla / start with the 5 V phase
32high_phase = True
33phase_start = time.ticks_ms()
34cycles = 0
35ppm = 0.0
36print("MQ-7 isiniyor... / warming up...")
37
38while True:
39 now = time.ticks_ms()
40 elapsed = time.ticks_diff(now, phase_start)
41 if high_phase and elapsed >= HIGH_MS:
42 heater.duty_u16(DUTY_LOW) # 1,4 V fazı / 1.4 V phase
43 high_phase = False
44 phase_start = now
45 elif not high_phase and elapsed >= LOW_MS:
46 rs = read_rs() # düşük fazın sonunda ölç / measure at the end of the low phase
47 ppm = 99.042 * (rs / R0) ** -1.518
48 cycles += 1
49 print("Rs:", int(rs), "R0 tahmini/estimate:", int(rs / 27.5), "CO ppm:", round(ppm, 1))
50 heater.duty_u16(DUTY_HIGH) # yeniden 5 V / back to 5 V
51 high_phase = True
52 phase_start = now
53
54 ready = cycles >= WARMUP_CYCLES
55 if ready and ppm >= ALARM_PPM:
56 buzzer.value((now // 250) % 2) # hızlı kesik alarm / fast intermittent alarm
57 led.value(1)
58 elif ready and ppm >= WARN_PPM:
59 buzzer.value(1 if (now % 2000) < 150 else 0) # seyrek bip / sparse beep
60 led.value(1)
61 else:
62 buzzer.value(0)
63 led.value(0)
64 time.sleep_ms(20)Projectideeën met de MQ-7
- Display voor de ketelruimte: Toon de gemeten ppm-waarde en een grafiek van 24 uur op een OLED-display.
- Melding op je telefoon: Stuur met een ESP32 een bericht via een Telegram-bot als 50 ppm wordt overschreden.
- Dubbel gasalarm: Gebruik de MQ-2 voor lekkage van gas uit flessen en de MQ-7 voor CO van verbranding, en stel twee verschillende alarmgeluiden in.
- Garageventilatie: Laat een afzuigventilator draaien met een relaismodule als CO stijgt.
- Binnenluchtkwaliteitsstation: Combineer de MQ-7 met de MQ-135 en de MH-Z19 CO2-sensor en zie met data dat CO en CO2 verschillende gassen zijn.
- Datalogger: Schrijf de waarden naar een SD-kaart en vergelijk CO-stijgingen met de uren dat de kachel brandt.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De waarde verandert nauwelijks | De verwarming op de module zit op een constante 5 V, geen cyclus | Gebruik een kale sensor of sluit de verwarming aan op een MOSFET |
| ppm is oneindig, nul of NaN | Pin B of RL is losgekoppeld, Vout is 0 V of gelijk aan Vc | Meet de aansluitingen door met een multimeter en laat de begrenzingsregel in de code staan |
| Hoge waarde en alarm bij het opstarten | De sensor is koud en nog niet gestabiliseerd | Negeer de eerste 2 cycli; laat een nieuwe sensor 48 uur draaien |
| De multimeter toont 0,4 V in de lage fase | Een multimeter meet het gemiddelde van de PWM | Normaal; de effectieve waarde is ongeveer 1,4 V |
| Waarden schommelen overdag sterk | Veranderingen in temperatuur en luchtvochtigheid, ADC-ruis | Kalibreer onder vergelijkbare omstandigheden en pas filtering toe |
| De ESP32 of Pico blijft herstarten | De USB-voeding is zwak terwijl de verwarming 150 mA neemt | Gebruik een goede kabel, een 5V-1A-adapter en een condensator van 470 µF |
| Alarm na parfum of alcohol | De MQ-7 reageert ook op waterstof en alcohol | Normaal; de sensor is niet selectief voor één gas |
De MQ-7 is een geweldige sensor die in één project veel kernbegrippen leert, zoals de verwarmingscyclus, effectieve spanning met PWM, de spanningsdeler en logaritmische kalibratie; verwar hem alleen niet met een echt veiligheidsapparaat en houd een gecertificeerde melder in huis. In de BlueGrays-app kun je het gebruik van gassensoren, vlam- en gasalarmen, een ESP32 MQ-2-detector en buzzerprojecten stap voor stap verkennen met schakelschema's en code, en ze combineren met het CO-alarm uit dit bericht.
Veelgestelde vragen
Hoeveel ppm kan de MQ-7 meten?
Het meetbereik van de MQ-7 volgens de datasheet is 20–2000 ppm koolmonoxide. Waarden onder 20 ppm kunnen met de formule worden berekend, maar zijn minder nauwkeurig. Is de sensor niet gekalibreerd, zie de getoonde waarde dan als een grove schatting, niet als een exacte meting.
Wat is het verschil tussen de MQ-7 en de MQ-2?
De MQ-2 is ontworpen voor gas uit flessen, propaan, methaan en rook, en zijn verwarming draait op een constante 5 V. De MQ-7 richt zich op koolmonoxide en zijn verwarming moet worden aangestuurd met een cyclus van 60 seconden op 5 V en 90 seconden op 1,4 V. De MQ-2 is beter voor gaslekkage en de MQ-7 voor CO van kachels en cv-ketels.
Kan de MQ-7 zonder verwarmingscyclus worden gebruikt?
Technisch werkt hij en verandert de waarde, maar een sensor die op een constante 5 V wordt verwarmd, volgt de datasheetcurve voor CO niet en de ppm-berekening wordt zinloos. Zo krijg je alleen een grove indicator dat "de lucht is veranderd". Wil je CO meten, dan moet je de verwarming met een MOSFET en PWM in een cyclus zetten.
Hoe lang moet de MQ-7 opwarmen?
Volgens de datasheet moet een nieuwe sensor vóór het eerste gebruik meer dan 48 uur draaien; in die tijd driften de waarden. Ook na deze inbrandperiode moet je de metingen pas vertrouwen als je na elke inschakeling minstens 2–3 cycli hebt gewacht, dus 5–8 minuten.
Is een met Arduino gebouwd CO-alarm betrouwbaar?
Nee, voor veiligheid van mensenlevens is het niet betrouwbaar. De MQ-7 wordt beïnvloed door temperatuur, luchtvochtigheid en veroudering, de foutmarge is groot en een zelfgebouwde schakeling is niet volgens enige norm getest. Gebruik in een woning met een kachel of cv-ketel altijd een CO-melder met EN 50291-certificering en zie het Arduino-project alleen als extra indicator.
Meet de MQ-7 koolstofdioxide (CO2)?
Nee, de MQ-7 is ontworpen voor koolmonoxide en reageert niet zinvol op koolstofdioxide. Om CO2 te meten gebruik je infraroodsensoren (NDIR) zoals de MH-Z19. CO is een giftig verbrandingsgas, terwijl CO2 een indicator is van slechte ventilatie in een afgesloten ruimte; verwar de twee niet.
Projecten om hierna te bouwen
Alle projecten bekijken
Een buzzer gebruiken
Heb je je ooit afgevraagd hoe een deurbel of alarm geluid maakt? De Arduino laat een kleine buzzer met korte tussenpozen piepen: piep, pauze, piep, pauze.

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…

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…

Alarm met vlam- en gassensor
Een kleine bewaker die je meteen waarschuwt als er gas lekt of ergens een vlam verschijnt.

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.

Een vlamsensor gebruiken
Een kleine bewaker die vuur eerder opmerkt dan jij, in de keuken of de werkplaats.

Digitale voltmeter met lcd-scherm
Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

