Sensor de monóxido de carbono MQ-7 con Arduino: medir CO y alarma
Cómo usar el sensor MQ-7: ciclo del calefactor de 5 V y 1,4 V, precalentamiento, cálculo de ppm, calibración y alarma de CO con zumbador en Uno, ESP32 y Pico.
El sensor de monóxido de carbono MQ-7 es un sensor de gas semiconductor barato, basado en dióxido de estaño (SnO2), que detecta el monóxido de carbono (CO) del aire. Según la hoja de datos del fabricante, es sensible a CO en un rango aproximado de 20–2000 ppm y se lee como una simple tensión analógica con Arduino, ESP32 o Raspberry Pi Pico. Lo que lo distingue de otros sensores MQ es que su calefactor no debe funcionar con una tensión constante, sino en ciclos de 60 segundos a 5 V y 90 segundos a 1,4 V. En este artículo verás paso a paso cómo montar ese ciclo con un MOSFET y PWM, cómo calcular las ppm a partir de la tensión leída, cómo calibrar en aire limpio y cómo hacer una alarma de CO con zumbador para una habitación con estufa o caldera en tres plataformas.
El monóxido de carbono es un gas incoloro, inodoro e insípido; se une a la hemoglobina de la sangre unas 200 veces más fuerte que el oxígeno. Por eso la intoxicación avanza de forma silenciosa: primero dolor de cabeza y somnolencia, después náuseas y confusión. Cada invierno leemos noticias de intoxicaciones por estufas que queman mal, calderas con la chimenea obstruida o calentadores que funcionan en espacios cerrados. Por eso el MQ-7 es un componente muy didáctico, tanto para aprender cómo funcionan los sensores de gas como para entender un problema real.

¿Qué es el MQ-7 y cómo funciona?
Bajo la tapa de malla metálica del sensor hay un pequeño tubo cerámico recubierto de dióxido de estaño y un hilo fino que lo calienta. La superficie caliente de SnO2 atrapa el oxígeno del aire y en ese estado su resistencia eléctrica es alta. Si en el ambiente hay un gas reductor como el CO, reacciona con el oxígeno de la superficie y los electrones liberados reducen la resistencia de la capa. Es decir, cuanto más CO, menor es la resistencia del sensor (Rs). Si la pones en serie con una resistencia de carga (RL) y mides la tensión intermedia, en realidad has montado un divisor de tensión y lees la cantidad de CO como un valor analógico.
| Característica | Valor |
|---|---|
| Gas detectado | Monóxido de carbono (CO); también reacciona al hidrógeno y al alcohol |
| Rango de medida | 20–2000 ppm de CO |
| Tensión del calefactor | 5 V ± 0,1 V (fase alta), 1,4 V ± 0,1 V (fase baja) |
| Duración de las fases | 60 s alta, 90 s baja (un ciclo son 150 s) |
| Resistencia del calefactor | Unos 33 Ω |
| Corriente del calefactor | Unos 150 mA a 5 V, unos 42 mA a 1,4 V |
| Potencia del calefactor | Media del ciclo de unos 350 mW (unos 0,76 W en la fase de 5 V) |
| Rs (en 100 ppm de CO) | 2–20 kΩ (varía de un sensor a otro) |
| Tensión del circuito de medida (Vc) | 5 V en la hoja de datos; también se puede usar con 3,3 V |
| Precalentamiento en el primer uso | Más de 48 horas |
Ciclo del calefactor: ¿por qué 5 V y 1,4 V?
Sensores como el MQ-2 mantienen el calefactor siempre a 5 V. El MQ-7, en cambio, detecta mejor el CO a baja temperatura, pero a baja temperatura se acumulan humedad y otros gases en la superficie. Por eso en la fase de 60 segundos a 5 V la superficie se calienta y se limpia; después, en la fase de 90 segundos a 1,4 V, la superficie se enfría, el CO se adhiere y la resistencia cambia. La medida se toma en los últimos segundos de esa fase baja. Arduino no tiene una salida de 1,4 V; la consigues encendiendo y apagando rápidamente los 5 V con un MOSFET, es decir, con PWM. Aquí está el punto clave: el calefactor es una resistencia y el calor lo determina la potencia (P = V² / R). El ciclo de trabajo que da la potencia de 1,4 V es D = (1,4 / 5)² ≈ 7,8 %; la tensión efectiva se calcula con U = 5 · √D. Un error frecuente es usar el 28 % (analogWrite 71): eso aporta unas 3,6 veces la potencia necesaria, sobrecalienta el sensor y reduce su sensibilidad.
| Fase | Calefactor | Duración | Comando en Uno | ¿Qué ocurre? |
|---|---|---|---|---|
| Limpieza (alta) | 5 V | 60 s | digitalWrite(9, HIGH) | La superficie se calienta y se eliminan la humedad y los gases acumulados; no se mide |
| Medida (baja) | 1,4 V efectivos | 90 s | analogWrite(9, 20) ≈ 7,8 % | La superficie se enfría, el CO se adhiere y la resistencia baja; la lectura se toma al final de la fase |
| Un ciclo completo | - | 150 s | - | Un nuevo valor de ppm cada 2,5 minutos |
¿Módulo o sensor suelto?
En los módulos azules de MQ-7 del mercado hay un comparador LM393, un potenciómetro para ajustar el umbral, un LED de alimentación y las salidas AO y DO. En la mayoría de estas placas el calefactor está conectado directamente entre VCC y GND, es decir, el sensor se calienta siempre a 5 V. En ese caso la lectura no sigue la curva de la hoja de datos y el valor se convierte en un indicador tosco que solo dice "algo ha cambiado". Para tener el ciclo correcto, usa el MQ-7 suelto de 6 patillas o corta en el módulo la pista de GND del calefactor y conéctala a un MOSFET. En el sensor suelto, las dos patillas H son los extremos del calefactor; las dos patillas A y las dos B están unidas entre sí internamente y el sensor no tiene polaridad. Si usas un módulo, lee el valor de la resistencia de carga de la placa por su código SMD (102 = 1 kΩ, 103 = 10 kΩ); la calculadora de códigos SMD te sirve para eso. La constante RL del código debe coincidir con ese valor.
Esquema de conexión: Arduino Uno, ESP32 y Pico
El circuito tiene dos partes. En la parte del calefactor, un extremo H va a 5 V y el otro al drenador de un MOSFET de canal N; la fuente va a GND. La puerta va al pin PWM a través de 220 Ω, y una resistencia de 100 kΩ entre la puerta y GND evita que el calefactor funcione sin control al arrancar la placa. Para el Uno sirve un MOSFET de nivel lógico como el IRLZ44N; para el ESP32 y la Pico, que trabajan a 3,3 V, uno de umbral bajo como el AO3400; si no tienes ninguno, puedes usar un transistor NPN como el BC337 o el 2N2222 con una resistencia de base de 470 Ω. Para más detalles consulta el artículo Cómo usar un MOSFET con Arduino y la herramienta de transistores. En la parte de medida, el extremo A va a la alimentación de medida (Vc), el extremo B va a la entrada analógica y entre B y GND se pone la resistencia RL de 10 kΩ. Como Rs es una resistencia, elegir Vc = 3,3 V en el ESP32 y la Pico no estropea el cálculo; la potencia que se disipa en la capa del sensor es despreciable frente a la del calefactor.
| Conexión | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Calefactor H (1.er extremo) | 5V | VIN / 5V (USB) | VBUS (pin 40) |
| Calefactor H (2.º extremo) | Drenador del MOSFET | Drenador del MOSFET | Drenador del MOSFET |
| Puerta del MOSFET (con 220 Ω) | D9 | GPIO 25 | GP15 |
| Fuente del MOSFET y resistencia de puerta de 100 kΩ | GND | GND | GND |
| Sensor A (alimentación de medida Vc) | 5V | 3V3 | 3V3(OUT) (pin 36) |
| Sensor B (a GND con RL de 10 kΩ) | A0 | GPIO 34 | GP26 (ADC0) |
| Zumbador activo + | D8 | GPIO 26 | GP14 |
| LED de aviso (con 220 Ω) | D13 | GPIO 27 | GP13 |
Cálculo de ppm: Rs, R0 y la curva log-log
Con la tensión Vout leída en la entrada analógica, la resistencia del sensor se obtiene con esta fórmula: Rs = RL × (Vc − Vout) / Vout. Por ejemplo, en el Uno con Vc = 5 V, RL = 10 kΩ y Vout = 1,0 V, Rs = 10 kΩ × 4 / 1 = 40 kΩ; también puedes comprobar este cálculo con la herramienta de la ley de Ohm. La hoja de datos define el sensor respecto a una referencia llamada R0: R0 es la resistencia del sensor en 100 ppm de CO. La relación entre Rs/R0 y la concentración de CO es aproximadamente una recta en una gráfica log-log, por lo que se puede expresar con una fórmula exponencial. La aproximación sacada de la curva de la hoja de datos, que también usan las bibliotecas MQ más populares, es: ppm = 99,042 × (Rs/R0)^−1,518. Según la misma curva, en aire limpio Rs/R0 es de unos 27,5. Estas cifras salen de leer la curva y cada sensor es un poco distinto; considera el resultado una buena estimación, no una medida exacta.
| Rs/R0 | CO calculado | Comentario |
|---|---|---|
| 27,5 | ≈ 0,7 ppm | Aire limpio (referencia de calibración) |
| 5 | ≈ 9 ppm | Límite superior de un ambiente doméstico normal |
| 2 | ≈ 35 ppm | Hace falta ventilar |
| 1,5 | ≈ 54 ppm | Se supera el umbral de aviso del código (50 ppm) |
| 1 | ≈ 99 ppm | Definición de R0 (100 ppm); umbral de alarma del código |
| 0,5 | ≈ 284 ppm | Peligroso; ventila el lugar de inmediato y sal |
| 0,25 | ≈ 813 ppm | Peligro de muerte |
Calibración paso a paso
Como en casa no tienes un gas de prueba de 100 ppm, no puedes medir R0 directamente. En su lugar mides la resistencia en aire limpio y la divides entre 27,5 para estimar R0. Los códigos de abajo imprimen en cada ciclo tanto Rs como esta estimación, así que no necesitas un programa de calibración aparte.
- Antes del primer uso, deja funcionar un sensor nuevo en el circuito, con el ciclo, al menos 48 horas; sin este precalentamiento (burn-in) los valores se desvían durante días.
- Coloca el circuito al aire libre o en un lugar bien ventilado, lejos de estufas, la cocina y el escape de vehículos. Las condiciones de la hoja de datos son unos 20 °C y 65 % de humedad relativa; cuanto más te acerques, mejor.
- Carga el código y abre el Monitor Serie. Ignora los 2 primeros ciclos tras el arranque (unos 5 minutos); el sensor aún no se ha estabilizado.
- Anota los valores de "R0 estimado" de al menos 10 ciclos consecutivos (unos 25 minutos) y calcula su media.
- Escribe esa media en la constante R0 del código y vuelve a cargarlo. Si quieres, puedes guardar el valor en la EEPROM y recalibrar con un botón.
- Repite la calibración al cambiar de estación o cada pocos meses; a medida que el sensor envejece, R0 se desplaza lentamente.
Niveles de monóxido de carbono y umbrales de alarma
Los detectores domésticos certificados no funcionan con un límite instantáneo, sino con umbrales que dependen del tiempo. Según la EN 50291, un detector debe dar alarma en 60–90 minutos a 50 ppm, en 10–40 minutos a 100 ppm y en 3 minutos a 300 ppm. Nuestro circuito solo produce un valor nuevo cada 150 segundos y su margen de error es grande; por eso en el código somos más prudentes y damos un pitido de aviso espaciado a 50 ppm y una alarma rápida e intermitente a 100 ppm. La tabla siguiente muestra los efectos aproximados en adultos sanos; niños, mayores, embarazadas y personas con enfermedades del corazón se ven afectados con niveles mucho más bajos.
| Nivel de CO | ¿Qué significa? |
|---|---|
| Menos de 9 ppm | Ambiente interior normal; el valor guía de la OMS para 8 horas es de unos 9 ppm |
| 35 ppm | En muchos países, valor límite de 1 hora para el aire exterior; riesgo de dolor de cabeza con exposición prolongada |
| 50 ppm | Un detector certificado da alarma en 60–90 minutos |
| 200 ppm | Dolor de cabeza, cansancio y náuseas en 2–3 horas |
| 400 ppm | Dolor de cabeza intenso en 1–2 horas; una exposición de más de 3 horas pone en peligro la vida |
| 800 ppm | Mareo, vómitos y pérdida de conciencia en 45 minutos; riesgo de muerte en 2–3 horas |
Alarma de CO con zumbador y Arduino Uno
El código siguiente gestiona a la vez el ciclo del calefactor, la medida y la alarma. Como las fases duran 150 segundos, se usa millis() en lugar de delay; así el patrón del zumbador y el ciclo no se bloquean entre sí. El código coincide exactamente con los pines de la tabla de conexiones y usa además el LED integrado (D13) como luz de aviso. Como zumbador elige uno activo, con oscilador propio; para más detalles consulta la diferencia entre zumbador activo y pasivo.
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}| Sección del código | ¿Qué hace? |
|---|---|
| HIGH_MS / LOW_MS | Duración de las fases de 60 s a 5 V y de 90 s a 1,4 V |
| LOW_DUTY = 20 | 1,4 V efectivos con PWM de 5 V: 5 · √(20/255) ≈ 1,40 V |
| readRs() | Promedia 20 muestras, limita Vout y calcula Rs |
| pow(rs / R0, -1.518) | Estimación de ppm con la fórmula sacada de la curva de la hoja de datos |
| cycles / WARMUP_CYCLES | Silencia la alarma durante los 2 primeros ciclos tras el arranque |
| updateAlarm() | Pitido espaciado y LED por encima de 50 ppm, alarma rápida e intermitente por encima de 100 ppm |
| digitalWrite(HEATER_PIN, HIGH) | Desactiva el PWM y vuelve a poner el calefactor a 5 V completos |
Alarma de CO con ESP32
En el ESP32 la lógica es la misma; solo cambian las partes de PWM y ADC. El calefactor se controla con la unidad LEDC a 1 kHz y 8 bits de PWM; como las funciones LEDC son distintas en las versiones 2.x y 3.x del núcleo Arduino para ESP32, el código admite ambas. El sensor se conecta al GPIO 34, del grupo ADC1, que también funciona con el Wi-Fi activado, y se lee el valor calibrado en milivoltios con analogReadMilliVolts(). Como el circuito de medida se alimenta de 3V3, con valores altos de CO la salida se acerca a 3 V; en esa zona el ADC del ESP32 pierde algo de linealidad, pero es suficiente para una alarma. El artículo Cómo funciona el ADC explica este tema en detalle.
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}Alarma de CO con Raspberry Pi Pico (MicroPython)
En la Pico montas el mismo ciclo con MicroPython. La salida PWM sale por GP15 a 1 kHz; en MicroPython el ciclo de trabajo se ajusta con el duty_u16() de 16 bits, así que el 7,8 % corresponde al valor 5140. El sensor se conecta al pin GP26 (ADC0) y read_u16() devuelve un valor entre 0 y 65535. El calefactor toma los 5 V del pin VBUS; VBUS solo da 5 V cuando la Pico se alimenta por USB, y si la vas a alimentar con pilas por VSYS tendrás que conectar al calefactor una fuente de 5 V aparte. Como los GPIO de la Pico son de 3,3 V y de baja corriente, es más seguro elegir como zumbador un módulo de zumbador activo con transistor. Si eres nuevo en MicroPython, puedes empezar con el artículo Fundamentos de MicroPython.
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)Ideas de proyectos con el MQ-7
- Indicador para la habitación de la caldera: muestra el valor en ppm y la gráfica de las últimas 24 horas en una pantalla OLED.
- Notificación al móvil: con un ESP32, envía un mensaje por un bot de Telegram cuando se superen los 50 ppm.
- Alarma de doble gas: usa el MQ-2 para fugas de gas de bombona y el MQ-7 para el CO de combustión, y define dos sonidos de alarma distintos.
- Ventilación de garaje: cuando suba el CO, enciende el extractor con un módulo de relé.
- Estación de calidad del aire interior: combina el MQ-7 con el MQ-135 y el sensor de CO2 MH-Z19 y comprueba con datos que el CO y el CO2 son gases distintos.
- Registrador de datos: guarda los valores en una tarjeta SD y compara la subida de CO con las horas en que se enciende la estufa.
Errores frecuentes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| El valor casi no cambia | En el módulo el calefactor está siempre a 5 V, sin ciclo | Usa el sensor suelto o conecta el calefactor a un MOSFET |
| Las ppm salen infinitas, cero o NaN | El extremo B o RL está cortado, Vout es 0 V o igual a Vc | Mide las conexiones con el polímetro y conserva la línea de limitación del código |
| Valor alto y alarma al arrancar | El sensor está frío y no se ha estabilizado | Ignora los 2 primeros ciclos; deja funcionar 48 horas un sensor nuevo |
| En la fase baja el polímetro marca 0,4 V | El polímetro mide el promedio del PWM | Es normal; el valor efectivo es de unos 1,4 V |
| Los valores varían mucho durante el día | Cambios de temperatura y humedad, ruido del ADC | Calibra en condiciones parecidas y aplica un filtrado |
| El ESP32 o la Pico se reinicia | La alimentación USB es débil con el calefactor consumiendo 150 mA | Usa un buen cable, un adaptador de 5 V y 1 A y un condensador de 470 µF |
| Alarma tras perfume o alcohol | El MQ-7 también reacciona al hidrógeno y al alcohol | Es normal; el sensor no es selectivo a un solo gas |
El MQ-7 es un sensor estupendo que enseña en un solo proyecto muchos conceptos básicos, como el ciclo del calefactor, la tensión efectiva con PWM, el divisor de tensión y la calibración logarítmica; solo que no hay que tomarlo por un dispositivo de seguridad real, y en tu casa debe haber un detector certificado. En la app de BlueGrays puedes consultar paso a paso, con esquemas y código, el uso de sensores de gas, la alarma de llama y gas, el detector MQ-2 con ESP32 y proyectos con zumbador, y combinarlos con la alarma de CO de este artículo.
Preguntas frecuentes
¿Cuántas ppm mide el sensor MQ-7?
El rango de medida del MQ-7 en la hoja de datos es de 20–2000 ppm de monóxido de carbono. Los valores por debajo de 20 ppm se pueden calcular con la fórmula, pero su precisión es baja. Si el sensor no está calibrado, debes considerar el valor que muestra una estimación aproximada y no una medida exacta.
¿Qué diferencia hay entre el MQ-7 y el MQ-2?
El MQ-2 está pensado para gas de bombona, propano, metano y humo, y su calefactor funciona siempre a 5 V. El MQ-7, en cambio, se centra en el monóxido de carbono y su calefactor debe alimentarse con un ciclo de 60 segundos a 5 V y 90 segundos a 1,4 V. Para fugas de gas es más adecuado el MQ-2; para el CO de estufas y calderas, el MQ-7.
¿Se puede usar el MQ-7 sin el ciclo del calefactor?
Técnicamente funciona y el valor cambia, pero un sensor que se calienta siempre a 5 V no sigue la curva de la hoja de datos para el CO y el cálculo de ppm pierde sentido. Así solo obtienes un indicador tosco de que "el aire ha cambiado". Si quieres medir CO, tienes que poner el calefactor en ciclo con un MOSFET y PWM.
¿Cuánto tiempo hay que precalentar el MQ-7?
Según la hoja de datos, un sensor nuevo debe funcionar más de 48 horas antes del primer uso; durante ese tiempo sus valores se desvían. Incluso después de este precalentamiento, no te fíes de los valores leídos sin esperar al menos 2–3 ciclos en cada arranque, es decir, de 5 a 8 minutos.
¿Es fiable una alarma de CO hecha con Arduino?
No, no es fiable para la seguridad de las personas. El MQ-7 se ve afectado por la temperatura, la humedad y el envejecimiento, su margen de error es grande y un circuito casero no se ha probado según ninguna norma. En una casa con estufa o caldera usa siempre un detector de CO certificado según la EN 50291 y considera el proyecto de Arduino solo como indicador adicional.
¿Mide el MQ-7 el dióxido de carbono (CO2)?
No, el MQ-7 está diseñado para el monóxido de carbono y no responde de forma significativa al dióxido de carbono. Para medir CO2 se usan sensores de infrarrojos (NDIR) como el MH-Z19. El CO es un gas de combustión tóxico, mientras que el CO2 indica falta de ventilación en una habitación cerrada; no hay que confundirlos.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Uso del zumbador
¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio.

Temperatura y humedad con DHT11
¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

Uso del sensor de gas
Un pequeño vigilante que detecta un escape de gas en la cocina antes que tú. El sensor de gas olfatea el aire sin parar; mientras todo va bien se enciende el LED verde, y cuando el gas del aire…

Alarma con sensor de llama y gas
Un pequeño vigilante que te avisa enseguida si hay una fuga de gas o aparece una llama en algún sitio.

Alarma de detector de gas/humo ESP32 MQ-2
En este proyecto, la detección de gases combustibles (GLP, metano, propano) y humo se realiza mediante un módulo sensor de gas MQ-2; al detectarlos, se emite un sonido de alarma similar a una sirena a través de un zumbador pasivo. La salida digital de umbral (DO) del sensor se conecta al GPIO 4 del ESP32; cuando el gas o el humo superan el umbral, DO pasa a LOW y se activa la alarma. La sensibilidad se ajusta con el potenciómetro del módulo. El zumbador se controla con tone().

Uso del sensor de llama
Un pequeño vigilante que detecta el fuego antes que tú, en la cocina o en el taller.

Voltímetro digital con pantalla LCD
Descubre cuánto voltaje da una pila o un adaptador con un medidor hecho por ti. Un divisor de dos resistencias baja la tensión alta a un nivel que la placa puede leer, y el Arduino calcula el valor…

Sistema de Alarma de Movimiento ESP32 (PIR + Buzzer + LED + Telegram)
Una alarma de seguridad inteligente: cuando el sensor PIR detecta movimiento, suena el zumbador, se enciende el LED y el dueño recibe al instante una notificación por Telegram. Una espera de 30 segundos (cooldown) limita cada cuánto se repite la alarma; no elimina las falsas detecciones del sensor PIR. Sirve para casa, garaje, almacén o estudio.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

