Sensor de monóxido de carbono MQ-7: detecção de CO e alarme com Arduino
Como usar o sensor de CO MQ-7? O ciclo do aquecedor de 5 V / 1,4 V, pré-aquecimento, cálculo de ppm, calibração e um alarme de CO com buzzer usando Uno, ESP32 e Pico.
O sensor de monóxido de carbono MQ-7 é um sensor de gás semicondutor barato, à base de dióxido de estanho (SnO2), que detecta monóxido de carbono (CO) no ar. Segundo o datasheet do fabricante, ele responde ao CO na faixa de aproximadamente 20–2000 ppm, e você o lê como uma simples tensão analógica com um Arduino, ESP32 ou Raspberry Pi Pico. O que o diferencia dos outros sensores MQ é que o aquecedor não pode funcionar com tensão constante; ele precisa ser ciclado com 60 segundos em 5 V e 90 segundos em 1,4 V. Neste post você vai ver, passo a passo, como montar esse ciclo com um MOSFET e PWM, calcular ppm a partir da tensão medida, calibrar em ar limpo e montar um alarme de CO com buzzer para um cômodo com aquecedor a lenha ou caldeira em três plataformas.
O monóxido de carbono é um gás incolor, inodoro e insípido; ele se liga à hemoglobina do sangue com uma força cerca de 200 vezes maior que a do oxigênio. Por isso a intoxicação chega de forma silenciosa: primeiro dor de cabeça e sonolência, depois náusea e confusão mental. Todo inverno lemos notícias de intoxicações causadas por aquecedores com combustão ruim, caldeiras com chaminé entupida e aquecedores de água funcionando em ambientes fechados. Isso torna o MQ-7 um componente muito instrutivo, tanto para aprender como os sensores de gás funcionam quanto para entender um problema real.

O que é o MQ-7 e como ele funciona?
Sob a tampa de tela metálica do sensor há um pequeno tubo cerâmico revestido de dióxido de estanho e um fio fino que o aquece. A superfície de SnO2 aquecida adsorve o oxigênio do ar, e nesse estado sua resistência elétrica é alta. Se houver um gás redutor como o CO, ele reage com o oxigênio da superfície, e os elétrons liberados diminuem a resistência da camada. Ou seja, quanto mais CO, menor a resistência do sensor (Rs). Quando você liga essa resistência em série com um resistor de carga (RL) e mede a tensão no ponto do meio, na prática montou um divisor de tensão e lê o nível de CO como um valor analógico.
| Característica | Valor |
|---|---|
| Gás detectado | Monóxido de carbono (CO); também responde a hidrogênio e álcool |
| Faixa de medição | 20–2000 ppm de CO |
| Tensão do aquecedor | 5 V ± 0,1 V (fase alta), 1,4 V ± 0,1 V (fase baixa) |
| Duração das fases | 60 s alta, 90 s baixa (um ciclo dura 150 s) |
| Resistência do aquecedor | Cerca de 33 Ω |
| Corrente do aquecedor | Cerca de 150 mA em 5 V, cerca de 42 mA em 1,4 V |
| Potência do aquecedor | Média do ciclo de cerca de 350 mW (cerca de 0,76 W na fase de 5 V) |
| Rs (em 100 ppm de CO) | 2–20 kΩ (varia de sensor para sensor) |
| Tensão do circuito de medição (Vc) | 5 V no datasheet; 3,3 V também funciona |
| Pré-aquecimento inicial (burn-in) | Mais de 48 horas |
O ciclo do aquecedor: por que 5 V e 1,4 V?
Sensores como o MQ-2 mantêm o aquecedor em 5 V constantes. Já o MQ-7 detecta CO melhor em baixa temperatura, mas em baixa temperatura umidade e outros gases se acumulam na superfície. Por isso, a fase de 60 segundos em 5 V aquece e limpa a superfície; depois, durante a fase de 90 segundos em 1,4 V, a superfície esfria, o CO é adsorvido e a resistência muda. Você faz a medição nos últimos segundos dessa fase baixa. O Arduino não tem uma saída que produza 1,4 V; você chega a esse valor ligando e desligando os 5 V rapidamente com um MOSFET, ou seja, com PWM. O ponto-chave: o aquecedor é um resistor e o calor é determinado pela potência (P = V² / R). O ciclo de trabalho que fornece a potência de 1,4 V é D = (1,4 / 5)² ≈ 7,8%; a tensão efetiva é obtida com U = 5 · √D. Um erro comum é usar 28% (analogWrite 71); isso entrega cerca de 3,6 vezes a potência necessária, superaquece o sensor e reduz sua sensibilidade.
| Fase | Aquecedor | Duração | Comando no Uno | O que acontece? |
|---|---|---|---|---|
| Limpeza (alta) | 5 V | 60 s | digitalWrite(9, HIGH) (5 V contínuo) | A superfície esquenta e a umidade e os gases acumulados são eliminados; nenhuma medição é feita |
| Medição (baixa) | 1,4 V efetivo | 90 s | analogWrite(9, 20) ≈ 7,8% | A superfície esfria, o CO é adsorvido e a resistência cai; a leitura é feita no fim da fase |
| Um ciclo completo | - | 150 s | - | Um novo valor de ppm a cada 2,5 minutos |
Módulo ou sensor avulso?
Os módulos azuis de MQ-7 mais comuns têm o sensor, um comparador LM393, um trimpot para o limiar, um LED de alimentação e as saídas AO e DO. Na maioria dessas placas o aquecedor está ligado direto entre VCC e GND, então o sensor aquece em 5 V constantes. Nesse caso, a leitura não segue a curva do datasheet; o valor vira um indicador grosseiro que só diz “alguma coisa mudou”. Para um ciclo correto, use o MQ-7 avulso de 6 pinos ou corte o caminho de GND do aquecedor no módulo e ligue-o a um MOSFET. No sensor avulso, os dois pinos H são os terminais do aquecedor; os dois pinos A e os dois pinos B são ligados entre si internamente, e o sensor não tem polaridade. Se você usar um módulo, leia o valor do resistor de carga da placa pelo código SMD (102 = 1 kΩ, 103 = 10 kΩ); a calculadora de código SMD resolve isso. A constante RL no código precisa ter esse mesmo valor.
Esquema de ligação: Arduino Uno, ESP32 e Pico
O circuito tem duas partes. Na parte do aquecedor, um terminal H vai ao 5 V e o outro terminal H vai ao dreno de um MOSFET de canal N; a fonte (source) é ligada ao GND. O gate vai ao pino PWM através de 220 Ω, e um resistor de 100 kΩ entre gate e GND impede que o aquecedor funcione sem controle enquanto a placa inicializa. Um MOSFET de nível lógico como o IRLZ44N serve para o Uno, e um MOSFET de baixo limiar como o AO3400 serve para o ESP32 e o Pico de 3,3 V; se você não tiver um, pode usar um transistor NPN como o BC337 ou o 2N2222 com um resistor de base de 470 Ω. Para mais detalhes, veja Como usar MOSFET com Arduino e a ferramenta Transistores. Na parte de medição, o pino A vai à alimentação de medição (Vc), o pino B vai à entrada analógica, e um resistor RL de 10 kΩ vai do pino B ao GND. Como Rs é uma resistência, escolher Vc de 3,3 V no ESP32 e no Pico não atrapalha o cálculo; a potência dissipada na camada sensora é desprezível perto da do aquecedor.
| Ligação | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Aquecedor H (1º terminal) | 5V | VIN / 5V (USB) | VBUS (pino 40) |
| Aquecedor H (2º terminal) | Dreno do MOSFET | Dreno do MOSFET | Dreno do MOSFET |
| Gate do MOSFET (através de 220 Ω) | D9 | GPIO 25 | GP15 |
| Fonte do MOSFET e resistor de gate de 100 kΩ | GND | GND | GND |
| Sensor A (alimentação de medição Vc) | 5V | 3V3 | 3V3(OUT) (pino 36) |
| Sensor B (ao GND com RL de 10 kΩ) | A0 | GPIO 34 | GP26 (ADC0) |
| Buzzer ativo + | D8 | GPIO 26 | GP14 |
| LED de aviso (com 220 Ω) | D13 | GPIO 27 | GP13 |
Cálculo de ppm: Rs, R0 e a curva log-log
A partir da tensão Vout lida na entrada analógica, a resistência do sensor é obtida com esta fórmula: Rs = RL × (Vc − Vout) / Vout. Por exemplo, no Uno com Vc = 5 V, RL = 10 kΩ e Vout = 1,0 V, Rs = 10 kΩ × 4 / 1 = 40 kΩ; você também pode conferir isso com a ferramenta da lei de Ohm. O datasheet define o sensor em relação a uma referência chamada R0: R0 é a resistência do sensor em 100 ppm de CO. A relação entre a razão Rs/R0 e a concentração de CO é aproximadamente uma reta num gráfico log-log, então pode ser expressa com uma fórmula de potência. A aproximação tirada da curva do datasheet, usada também por bibliotecas MQ populares, é: ppm = 99,042 × (Rs/R0)^−1,518. Pela mesma curva, a razão Rs/R0 em ar limpo é de cerca de 27,5. Esses números vêm da leitura da curva e cada sensor é um pouco diferente; trate o resultado como uma boa estimativa, não como uma medição exata.
| Rs/R0 | CO calculado | Comentário |
|---|---|---|
| 27,5 | ≈ 0,7 ppm | Ar limpo (referência de calibração) |
| 5 | ≈ 9 ppm | Limite superior de um ambiente doméstico normal |
| 2 | ≈ 35 ppm | É preciso ventilar |
| 1,5 | ≈ 54 ppm | O limiar de aviso do código (50 ppm) foi ultrapassado |
| 1 | ≈ 99 ppm | Definição de R0 (100 ppm); o limiar de alarme do código |
| 0,5 | ≈ 284 ppm | Perigoso; ventile o ambiente imediatamente e saia |
| 0,25 | ≈ 813 ppm | Risco de morte |
Calibração passo a passo
Você não tem gás de teste de 100 ppm em casa, então não dá para medir R0 diretamente. Em vez disso, você mede a resistência em ar limpo e estima R0 dividindo-a por 27,5. Os códigos abaixo mostram tanto Rs quanto essa estimativa a cada ciclo, então você não precisa de um programa de calibração separado.
- Antes do primeiro uso, deixe um sensor novo funcionando no circuito, com o ciclo, por pelo menos 48 horas; sem esse pré-aquecimento (burn-in), os valores ficam variando por dias.
- Coloque o circuito ao ar livre ou num lugar bem ventilado, longe de aquecedores, do fogão da cozinha e de escapamento de veículos. As condições do datasheet são cerca de 20 °C e 65% de umidade relativa; quanto mais perto delas, melhor.
- Carregue o código e abra o Monitor Serial. Ignore os 2 primeiros ciclos após ligar (cerca de 5 minutos); o sensor ainda não se estabilizou.
- Anote os valores de “R0 estimate” (estimativa de R0) de pelo menos 10 ciclos seguidos (cerca de 25 minutos) e calcule a média.
- Escreva essa média na constante R0 do código e carregue de novo. Se quiser, você pode salvar o valor na EEPROM e recalibrar com um botão.
- Repita a calibração quando a estação mudar ou a cada poucos meses; R0 varia lentamente conforme o sensor envelhece.
Níveis de monóxido de carbono e limiares de alarme
Detectores domésticos certificados não trabalham com um limite instantâneo, e sim com limiares que dependem do tempo. Segundo a EN 50291, um detector deve disparar o alarme em 60–90 minutos a 50 ppm, em 10–40 minutos a 100 ppm e em 3 minutos a 300 ppm. Nosso circuito só gera um novo valor a cada 150 segundos e tem uma grande margem de erro; por isso, no código, agimos com mais cautela, com um bipe de aviso espaçado a 50 ppm e um alarme intermitente rápido a 100 ppm. A tabela abaixo mostra os efeitos aproximados em adultos saudáveis; crianças, idosos, gestantes e cardíacos são afetados em níveis bem mais baixos.
| Nível de CO | O que significa |
|---|---|
| Abaixo de 9 ppm | Ambiente interno normal; o valor de referência de 8 horas da OMS é de cerca de 9 ppm |
| 35 ppm | Em muitos países, o limite de 1 hora para o ar externo; risco de dor de cabeça com exposição prolongada |
| 50 ppm | Um detector certificado dispara o alarme em 60–90 minutos |
| 200 ppm | Dor de cabeça, cansaço e náusea em 2–3 horas |
| 400 ppm | Dor de cabeça forte em 1–2 horas; exposição acima de 3 horas traz risco de morte |
| 800 ppm | Tontura, vômito e perda de consciência em 45 minutos; risco de morte em 2–3 horas |
Alarme de CO com buzzer usando Arduino Uno
O código abaixo gerencia ao mesmo tempo o ciclo do aquecedor, a medição e o alarme. Como as fases duram 150 segundos, usa-se millis() em vez de delay; assim, o padrão do buzzer e o ciclo não travam um ao outro. O código corresponde exatamente aos pinos da tabela de ligação e também usa o LED integrado (D13) como luz de aviso. Escolha um buzzer ativo, com oscilador próprio; para mais detalhes, veja a diferença entre buzzer ativo e passivo.
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}| Parte do código | O que faz |
|---|---|
| HIGH_MS / LOW_MS (durações) | Duração das fases de 60 segundos em 5 V e de 90 segundos em 1,4 V |
| LOW_DUTY = 20 (ciclo de trabalho) | 1,4 V efetivo a partir de PWM de 5 V: 5 · √(20/255) ≈ 1,40 V |
| readRs() (leitura de Rs) | Faz a média de 20 amostras, limita Vout e calcula Rs |
| pow(rs / R0, -1.518) (fórmula) | Estimativa de ppm com a fórmula tirada da curva do datasheet |
| cycles / WARMUP_CYCLES (aquecimento) | Silencia o alarme durante os 2 primeiros ciclos após ligar |
| updateAlarm() (alarme) | Bipe espaçado e LED acima de 50 ppm, alarme intermitente rápido acima de 100 ppm |
| digitalWrite(HEATER_PIN, HIGH) (fase alta) | Desliga o PWM e coloca o aquecedor de volta em 5 V plenos |
Alarme de CO com o ESP32
No ESP32 a lógica é a mesma; só mudam as partes de PWM e ADC. O aquecedor é acionado pelo periférico LEDC com PWM de 1 kHz e 8 bits; como as funções LEDC são diferentes nas versões 2.x e 3.x do core Arduino ESP32, o código suporta as duas. O sensor é ligado ao GPIO 34, do grupo ADC1, que funciona também com o Wi-Fi ligado, e um valor calibrado em milivolts é lido com analogReadMilliVolts(). Como o circuito de medição é alimentado pelo 3V3, a saída se aproxima de 3 V em valores altos de CO; o ADC do ESP32 perde um pouco de linearidade nessa região, mas é suficiente para um alarme. O post sobre como funciona um ADC explica isso em detalhes.
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}Alarme de CO com Raspberry Pi Pico (MicroPython)
No Pico você monta o mesmo ciclo com MicroPython. A saída PWM fica no GP15, a 1 kHz; no MicroPython o ciclo de trabalho é definido com o duty_u16() de 16 bits, então um ciclo de 7,8% corresponde ao valor 5140. O sensor é ligado ao pino GP26 (ADC0), e read_u16() retorna um valor na faixa 0–65535. O aquecedor recebe 5 V do pino VBUS; o VBUS só fornece 5 V quando o Pico é alimentado pela USB, então, se for usar bateria pelo VSYS, você precisa ligar uma fonte de 5 V separada ao aquecedor. Como os GPIOs do Pico são de 3,3 V e baixa corrente, é mais seguro escolher um módulo de buzzer ativo com transistor. Se você é novo no MicroPython, pode começar pelo post 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)Ideias de projetos com o MQ-7
- Indicador para a sala da caldeira: mostre o valor de ppm medido e um gráfico das últimas 24 horas num display OLED de 0,96 polegada.
- Notificação no celular: com um ESP32, envie uma mensagem por um bot do Telegram quando passar de 50 ppm.
- Alarme duplo de gás: use o MQ-2 para vazamento de gás de botijão e o MQ-7 para o CO da combustão, e defina dois sons de alarme diferentes.
- Ventilação da garagem: acione um exaustor com um módulo relé quando o CO subir.
- Estação de qualidade do ar interno: combine o MQ-7 com o MQ-135 e o sensor de CO2 MH-Z19, e veja nos dados que CO e CO2 são gases diferentes.
- Datalogger: grave os valores num cartão SD e compare as subidas de CO com os horários em que o aquecedor é aceso.
Erros comuns e como resolver
| Sintoma | Causa provável | Solução |
|---|---|---|
| O valor quase não muda | O aquecedor do módulo está em 5 V constantes, sem ciclo | Use um sensor avulso ou ligue o aquecedor a um MOSFET |
| ppm infinito, zero ou NaN | Pino B ou RL desconectado, Vout em 0 V ou igual a Vc | Meça as ligações com um multímetro e mantenha a linha de limitação no código |
| Valor alto e alarme ao ligar | O sensor está frio e não se estabilizou | Ignore os 2 primeiros ciclos; deixe um sensor novo funcionando por 48 horas |
| O multímetro mostra 0,4 V na fase baixa | O multímetro mede a média do PWM | É normal; o valor efetivo é de cerca de 1,4 V |
| Os valores oscilam muito ao longo do dia | Variação de temperatura e umidade, ruído do ADC | Calibre em condições parecidas e aplique filtragem |
| O ESP32 ou o Pico fica reiniciando | A alimentação USB é fraca enquanto o aquecedor consome 150 mA | Use um cabo de qualidade, uma fonte de 5 V 1 A e um capacitor de 470 µF |
| Alarme depois de perfume ou álcool | O MQ-7 também responde a hidrogênio e álcool | É normal; o sensor não é seletivo para um único gás |
O MQ-7 é um ótimo sensor que ensina muitos conceitos fundamentais num único projeto, como o ciclo do aquecedor, a tensão efetiva com PWM, o divisor de tensão e a calibração logarítmica; só não o confunda com um dispositivo de segurança de verdade, e mantenha um detector certificado em casa. No app BlueGrays você pode explorar passo a passo, com esquemas do circuito e códigos, projetos de uso de sensor de gás, alarme de chama e gás, detector MQ-2 com ESP32 e buzzer, e combiná-los com o alarme de CO deste post.
Perguntas frequentes
Quantos ppm o MQ-7 consegue medir?
A faixa de medição do MQ-7 no datasheet é de 20–2000 ppm de monóxido de carbono. Valores abaixo de 20 ppm podem ser calculados com a fórmula, mas são menos precisos. Se o sensor não estiver calibrado, considere o valor mostrado uma estimativa aproximada, e não uma medição exata.
Qual é a diferença entre o MQ-7 e o MQ-2?
O MQ-2 foi projetado para gás de botijão, propano, metano e fumaça, e seu aquecedor funciona em 5 V constantes. O MQ-7 é focado em monóxido de carbono, e seu aquecedor precisa ser acionado com um ciclo de 60 segundos em 5 V e 90 segundos em 1,4 V. O MQ-2 é melhor para vazamentos de gás, e o MQ-7 para o CO de aquecedores e caldeiras.
Dá para usar o MQ-7 sem o ciclo do aquecedor?
Tecnicamente funciona e o valor muda, mas um sensor aquecido em 5 V constantes não segue a curva do datasheet para CO, e o cálculo de ppm perde o sentido. Assim você só obtém um indicador grosseiro de que “o ar mudou”. Se quiser medir CO, precisa colocar o aquecedor num ciclo com um MOSFET e PWM.
Quanto tempo o MQ-7 precisa para aquecer?
Segundo o datasheet, um sensor novo deve funcionar por mais de 48 horas antes do primeiro uso; durante esse tempo os valores variam. Mesmo depois desse pré-aquecimento, não confie nas leituras antes de esperar pelo menos 2–3 ciclos, ou seja, 5–8 minutos, a cada vez que ligar.
Um alarme de CO feito com Arduino é confiável?
Não, ele não é confiável para proteger vidas. O MQ-7 é afetado por temperatura, umidade e envelhecimento, sua margem de erro é grande, e um circuito caseiro não foi testado conforme nenhuma norma. Numa casa com aquecedor a lenha ou caldeira, use sempre um detector de CO certificado pela EN 50291 e trate o projeto com Arduino apenas como um indicador adicional.
O MQ-7 mede dióxido de carbono (CO2)?
Não, o MQ-7 foi projetado para monóxido de carbono e não responde de forma significativa ao dióxido de carbono. Para medir CO2 usam-se sensores infravermelhos (NDIR) como o MH-Z19. O CO é um gás tóxico da combustão, enquanto o CO2 indica falta de ventilação num cômodo fechado; os dois não devem ser confundidos.
Projetos para montar depois desta leitura
Ver todos os projetos
Uso do buzzer
Já se perguntou como uma campainha ou um alarme produz som? O Arduino faz um pequeno buzzer emitir bipes em intervalos curtos: bipe, pausa, bipe, pausa.

Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Uso de um sensor de gás
Um pequeno guardião que percebe um vazamento de gás na cozinha antes de você. O sensor de gás monitora o ar continuamente; enquanto está tudo bem, o LED verde fica aceso e, quando o gás no ar…

Alarme com sensores de chama e gás
Um pequeno guardião que avisa você imediatamente quando há um vazamento de gás ou surge uma chama.

Alarme detector de gás e fumaça com ESP32 e MQ-2
Neste projeto, um módulo sensor de gás MQ-2 detecta gases combustíveis (LPG, metano e propano) e fumaça, acionando um alarme tipo sirene em um buzzer passivo. A saída digital de limiar (DO) do sensor é conectada ao GPIO 4 do ESP32. Quando a concentração de gás ou fumaça ultrapassa o limiar, DO passa para LOW e o alarme é acionado. A sensibilidade é ajustada pelo potenciômetro do módulo. O buzzer passivo é acionado com tone() para criar um efeito de sirene que alterna entre duas frequências.

Uso de um sensor de chama
Um pequeno guardião que percebe o fogo antes de você, na cozinha ou na oficina. O sensor de chama capta a luz invisível emitida pelo fogo; enquanto está tudo bem, o LED verde fica aceso e, ao…

Voltímetro digital com display LCD
Descubra a tensão de uma pilha ou de um adaptador de alimentação com um medidor feito por você.

Alarme de movimento com ESP32 (PIR + buzzer + LED + Telegram)
Um sistema de alarme de segurança inteligente que aciona o buzzer e o LED quando o sensor PIR detecta movimento e, ao mesmo tempo, envia uma notificação instantânea ao proprietário pelo Telegram. Inclui um intervalo de espera de 30 segundos para limitar a frequência dos alarmes repetidos; esse mecanismo não valida as detecções do PIR nem elimina disparos falsos. Pode ser usado na segurança de casas, no monitoramento de garagens, depósitos ou salas de trabalho.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

