Sensor de chama com Arduino: ligação, código e alarme de incêndio

Um sensor de chama é um módulo barato que detecta a luz infravermelha emitida por um isqueiro, uma vela ou um papel queimando, e você pode usá-lo com um Arduino em poucas linhas de código. Usar um sensor de chama com Arduino não exige biblioteca: o pino DO do módulo muda de estado quando ele vê uma chama, e o pino AO, nas versões de 4 pinos, fornece uma tensão que varia com a intensidade da chama. É um dos sensores mais populares para alarmes de incêndio, robôs bombeiros, sistemas de segurança na cozinha e projetos escolares.

Neste guia você vai aprender o que há dentro de um sensor de chama e por que ele só responde à luz entre 760 e 1100 nm, como as saídas digital e analógica se diferenciam, como ajustar corretamente o potenciômetro de sensibilidade e quais são o alcance e o ângulo de detecção. Depois vai montar um alarme de incêndio com buzzer e LED, combinar o sensor com um sensor de gás MQ-2, reduzir no software os alarmes falsos causados por fontes como a luz do sol e controles remotos, enviar uma notificação pelo Telegram ao celular com um ESP32 e rodar o mesmo circuito em um Raspberry Pi Pico com MicroPython.

O que é um sensor de chama e como ele funciona?

A peça preta, parecida com um LED, na ponta do módulo é na verdade um fototransistor infravermelho (em algumas placas, um fotodiodo); um exemplo comum é o YG1006. Seu corpo de epóxi preto filtra a maior parte da luz visível e só deixa passar o infravermelho próximo, entre cerca de 760 e 1100 nm, com sensibilidade máxima em torno de 940 nm. O limite superior vem do próprio silício: com uma banda proibida de 1,12 eV, o silício não consegue absorver fótons com comprimento de onda maior que cerca de 1100 nm. Como as partículas quentes de fuligem de uma chama também irradiam nessa faixa, a corrente no fototransistor aumenta conforme a chama se aproxima. Um divisor de tensão na placa transforma essa corrente em tensão, e o comparador LM393 a compara com o limite que você ajustou no potenciômetro para decidir o estado do pino DO.

Várias placas de sensor de chama diferentes fazem o mesmo trabalho. Módulos de 3 pinos, como o da foto acima, só têm saída digital; módulos de 4 pinos acrescentam uma saída analógica. O KY-026, que você talvez conheça dos kits de sensores, funciona do mesmo jeito, mas a saída DO dele costuma ser invertida. Robôs bombeiros usam placas multicanal com cinco receptores dispostos em leque. O sensor de chama é passivo, ou seja, não emite luz própria; isso o diferencia do sensor infravermelho TCRT5000, que tem emissor e receptor.

Saída digital (DO) vs analógica (AO)

O pino DO é uma resposta de sim ou não: ele muda de estado quando a luz infravermelha passa do limite ajustado no potenciômetro. Nas placas azuis comuns, esse pino fica normalmente em HIGH, vai para LOW quando vê uma chama, e o LED do DO acende; em algumas placas, como o KY-026, é o contrário. Por isso, a primeira coisa a fazer é testar o seu módulo com um isqueiro e ver o que o Monitor Serial mostra. O pino AO fornece o sinal bruto. Na maioria dos módulos esse valor cai conforme a chama se aproxima: um valor de analogRead de 900–1020 em uma sala sem chama pode cair para algumas centenas com um isqueiro por perto. O potenciômetro só muda o limite do DO e não tem efeito sobre o AO.

Como ajustar o potenciômetro de sensibilidade

1. Alimente o módulo e coloque o sensor onde ele vai trabalhar, voltado para a direção que vai vigiar; faça sempre esse ajuste no ambiente real.
2. Sem nenhuma chama, gire o potenciômetro azul com uma chave de fenda pequena e encontre o ponto em que o LED do DO alterna entre aceso e apagado.
3. A partir desse ponto, gire mais meia volta a uma volta no sentido em que o LED fica apagado. Assim, pequenas mudanças na luz ambiente não disparam o alarme.
4. Aproxime um isqueiro do sensor na maior distância que você quer detectar e confira se o LED acende. Se não acender, deixe o ajuste um pouco mais sensível e tente de novo.
5. Garanta que o sensor não esteja voltado para uma janela ensolarada ou uma lâmpada incandescente e confira o ajuste de novo algumas horas depois, com outra iluminação.

Alcance e ângulo de detecção

Números como os 80 cm informados pelos fabricantes se referem à chama padrão de um isqueiro; o alcance real depende do tamanho da chama, do ajuste do potenciômetro e da luz ambiente. Aqui vale uma lei simples da física: a intensidade da luz de uma fonte pequena cai com o quadrado da distância. Dobre a distância e a luz infravermelha que chega ao sensor cai para um quarto. Olhando ao contrário, você consegue detectar uma chama que emite quatro vezes mais luz a uma distância duas vezes maior, e uma cem vezes mais forte a uma distância dez vezes maior. Por isso a chama de uma vela é detectada a uma distância menor que a de um isqueiro, enquanto uma pilha de papel pegando fogo pode ser detectada a vários metros.

O ângulo de detecção é de cerca de 60 graus, então o sensor vê chamas dentro de um cone de aproximadamente 30 graus para cada lado do eixo, e o sinal enfraquece rápido conforme a chama vai para a borda desse cone. O receptor tem pernas longas, então você pode dobrá-lo com cuidado para qualquer direção, mas dobrar várias vezes o ponto onde as pernas entram no corpo acaba quebrando-o. Para estreitar o campo de visão, encaixe um tubo preto fosco sobre o receptor: um tubo com 6 mm de diâmetro interno e 2 cm de comprimento reduz o ângulo para cerca de 30 graus e bloqueia a luz do sol ou de lâmpadas vinda das laterais. O campo de visão deve ser só largo o bastante para cobrir a área que você quer vigiar; qualquer coisa além disso só acrescenta novas fontes de alarmes falsos.

Ligação do sensor de chama: Arduino Uno, ESP32 e Pico

Passo a passo: alarme de incêndio com sensor de chama e Arduino

1. Ligue o pino VCC do módulo no 5V do Arduino, o GND no GND e o DO no D2.
2. Ligue a perna longa (+) do buzzer ativo no D8 e a perna curta no GND.
3. Ligue a perna longa do LED vermelho no D7 por meio de um resistor de 220 Ω e a perna curta no GND. Se você usar outro LED, pode calcular o valor do resistor com a calculadora de resistor para LED.
4. Carregue o código abaixo, abra o Monitor Serial em 9600 baud e aproxime rapidamente um isqueiro do sensor, a 20–30 cm de distância.
5. Se o buzzer tocar e o LED acender, o circuito funciona; se o alarme tocar sem chama e silenciar quando há chama, mude FLAME_ACTIVE no código para HIGH.

1// Alev sensörü ile basit yangın alarmı / Simple fire alarm with a flame sensor
2const int FLAME_DO = 2;          // modülün DO pini / module DO pin
3const int BUZZER = 8;            // aktif buzzer / active buzzer
4const int LED = 7;               // kırmızı LED (220 Ω ile) / red LED (with 220 Ω)
5const int FLAME_ACTIVE = LOW;    // çoğu modülde alev = LOW, KY-026'da HIGH / most modules: flame = LOW, KY-026: HIGH
6
7void setup() {
8  Serial.begin(9600);
9  pinMode(FLAME_DO, INPUT);
10  pinMode(BUZZER, OUTPUT);
11  pinMode(LED, OUTPUT);
12}
13
14void loop() {
15  bool flame = digitalRead(FLAME_DO) == FLAME_ACTIVE;
16
17  if (flame) {
18    Serial.println(F("ALEV ALGILANDI! / FLAME DETECTED!"));
19    digitalWrite(LED, HIGH);
20    digitalWrite(BUZZER, HIGH);  // kesik kesik alarm sesi / beeping alarm
21    delay(150);
22    digitalWrite(BUZZER, LOW);
23    delay(150);
24  } else {
25    digitalWrite(LED, LOW);
26    digitalWrite(BUZZER, LOW);
27    delay(50);
28  }
29}

A cada passagem, o código lê o pino DO e compara o resultado com a constante FLAME_ACTIVE. Graças a essa constante, o mesmo código funciona com os módulos azuis, que vão para LOW com chama, e com o KY-026, que vai para HIGH. Enquanto houver uma chama visível, o LED fica aceso, e o buzzer liga e desliga a cada 150 ms para fazer um bipe intermitente que chama a atenção. Um buzzer ativo tem oscilador próprio, então só precisa de HIGH e LOW; se você tem um buzzer passivo, use tone() em vez de digitalWrite, como explicado em o que é um buzzer. Há outro motivo para termos escolhido o D2 para o pino DO: no Uno, o D2 é um dos dois pinos com suporte a interrupção, então com attachInterrupt você pode captar uma chama sem esperar o resto do loop.

Leitura analógica: intensidade da chama e distância aproximada

Se você tem um módulo de 4 pinos, a saída AO permite fazer muito mais. Como o valor bruto é diferente em cada ambiente, use este método em vez de um limite fixo: na inicialização, sem chama, meça um valor de referência e depois veja o quanto cada nova leitura se afasta dele. O código abaixo tira a média de 16 leituras para reduzir o ruído, calcula o desvio como força da chama e diz de forma aproximada se a chama está perto ou longe. Se o valor AO do seu módulo sobe com a chama, basta definir DROPS_WITH_FLAME como false.

1// AO ile alev gücü ve yaklaşık mesafe / Flame strength and rough distance via AO
2const int FLAME_AO = A0;             // 4 pinli modülün AO pini / AO pin of the 4-pin module
3const bool DROPS_WITH_FLAME = true;  // çoğu modülde alev yaklaşınca değer düşer / on most modules the value falls as the flame approaches
4int baseline;                        // alevsiz ortam değeri / flame-free ambient value
5
6int readAverage() {
7  long sum = 0;
8  for (int i = 0; i < 16; i++) {     // 16 ölçümün ortalaması / average of 16 readings
9    sum += analogRead(FLAME_AO);
10    delay(2);
11  }
12  return sum / 16;
13}
14
15void setup() {
16  Serial.begin(9600);
17  delay(1000);                       // açılışta ortamda alev olmamalı / no flame at start-up
18  baseline = readAverage();
19  Serial.print(F("Taban / Baseline: "));
20  Serial.println(baseline);
21}
22
23void loop() {
24  int value = readAverage();
25  int strength = DROPS_WITH_FLAME ? baseline - value : value - baseline;  // alev gücü / flame strength
26  if (strength < 0) strength = 0;
27
28  Serial.print(F("AO: "));
29  Serial.print(value);
30  Serial.print(F("  Guc / Strength: "));
31  Serial.print(strength);
32
33  if (strength > 400) {
34    Serial.println(F("  -> YAKIN ALEV / CLOSE FLAME"));
35  } else if (strength > 100) {
36    Serial.println(F("  -> UZAK ALEV / DISTANT FLAME"));
37  } else {
38    Serial.println(F("  -> alev yok / no flame"));
39  }
40  delay(250);
41}

Os limites de 100 e 400 no código são só um ponto de partida. Para ajustá-los ao seu sensor, carregue o código, abra o Monitor Serial e anote a força da chama segurando um isqueiro a 10, 30 e 60 cm; por causa da lei do inverso do quadrado, você verá o valor mudar muito rápido de perto e devagar de longe. É por isso que não dá para calcular uma distância exata em centímetros a partir do valor analógico: o mesmo valor pode vir de uma chama pequena perto ou de uma chama grande longe. Você aprende como o ADC gera o valor bruto em conversão analógico-digital e os detalhes do Monitor Serial em Monitor Serial do Arduino.

Luz do sol e outras fontes de alarmes falsos

Um sensor de chama não vê fogo; ele vê luz infravermelha em uma certa faixa, e qualquer coisa que emita luz nessa faixa pode dispará-lo. A lei de Wien explica quais fontes dão problema: o comprimento de onda em que um objeto quente mais irradia é de cerca de 2898 / T micrômetros (sendo T a temperatura em kelvin). O sol e as lâmpadas incandescentes irradiam forte bem na faixa do sensor, enquanto o corpo humano é frio demais, então o sensor não enxerga você de jeito nenhum. É por isso que, para detectar movimento, é preciso um sensor PIR, que olha comprimentos de onda muito mais longos.

Você evita a maioria dos alarmes falsos com hardware: posicione o sensor de modo que ele não fique voltado para uma janela, uma parede ensolarada ou uma lâmpada incandescente, de preferência apontando para baixo e para dentro do cômodo, estreite o campo de visão com um tubo preto e ajuste o potenciômetro com a iluminação ambiente real. Lembre que a luz forte do sol não causa só alarmes falsos, ela também pode cegar o sensor saturando-o: se o valor AO já caiu ao mínimo no sol, não sobra nada para mudar quando uma chama real aparece. Detectores de chama infravermelhos profissionais resolvem isso olhando a faixa de 4,3 µm, onde o dióxido de carbono quente irradia e a luz do sol é em grande parte absorvida pela atmosfera, comparando vários comprimentos de onda e analisando a tremulação da chama. Seu módulo não consegue fazer as duas primeiras coisas, mas você pode imitar a análise de tremulação e a confirmação por tempo no software.

Reduzindo alarmes falsos no software: confirmação por tempo e análise de tremulação

Uma chama real nunca queima de forma constante; correntes de ar e gases quentes subindo fazem o brilho dela oscilar cerca de 1 a 20 vezes por segundo. A luz do sol e a de uma lâmpada incandescente, por outro lado, são quase constantes em curtos períodos, e os pulsos de um controle remoto duram só milissegundos. O código abaixo usa essas diferenças com três regras: a força da chama precisa estar claramente acima da referência, o valor precisa ter oscilado mais que um certo tanto no último segundo, e as duas condições precisam se manter sem interrupção por pelo menos dois segundos. Além disso, cada leitura é a média de 20 amostras tiradas ao longo de 10 ms. Em uma rede de 50 Hz, as lâmpadas tremulam levemente 100 vezes por segundo; tirar a média ao longo de 10 ms, exatamente um período dessa tremulação, anula essa ondulação para que uma lâmpada não seja confundida com uma chama tremulando (em redes de 60 Hz, como no Brasil, o período equivalente é de cerca de 8,3 ms).

1// Süre doğrulamalı ve titreşim analizli alev alarmı / Flame alarm with time confirmation and flicker analysis
2const int FLAME_AO = A0;
3const int BUZZER = 8;
4const int LED = 7;
5const int STRENGTH_LIMIT = 150;          // tabandan en az bu kadar sapma / minimum deviation from the baseline
6const int FLICKER_LIMIT = 20;            // 1 sn içindeki en az dalgalanma / minimum swing within 1 s
7const unsigned long CONFIRM_MS = 2000;   // koşul bu kadar kesintisiz sürmeli / condition must hold this long
8
9float baseline;
10int winMin = 1023, winMax = 0;
11bool flickering = false;
12unsigned long windowStart = 0;
13unsigned long candidateSince = 0;
14
15// 10 ms boyunca 20 ölçüm: 100 Hz lamba titreşimini siler / 20 samples over 10 ms: cancels 100 Hz lamp flicker
16int readFiltered() {
17  long sum = 0;
18  for (int i = 0; i < 20; i++) {
19    sum += analogRead(FLAME_AO);         // yaklaşık 0,11 ms sürer / takes about 0.11 ms
20    delayMicroseconds(390);
21  }
22  return sum / 20;
23}
24
25void setup() {
26  Serial.begin(9600);
27  pinMode(BUZZER, OUTPUT);
28  pinMode(LED, OUTPUT);
29  baseline = readFiltered();             // açılışta ortamda alev olmamalı / no flame at start-up
30}
31
32void loop() {
33  int value = readFiltered();
34  int strength = (int)baseline - value;  // AO alevle artıyorsa: value - baseline / if AO rises with flame: value - baseline
35  unsigned long now = millis();
36
37  if (value < winMin) winMin = value;
38  if (value > winMax) winMax = value;
39
40  if (now - windowStart >= 1000) {       // her saniye pencereyi değerlendir / evaluate the window every second
41    int swing = winMax - winMin;
42    flickering = swing > FLICKER_LIMIT;  // alev titrer, güneş sabittir / flames flicker, sunlight is steady
43    if (strength < STRENGTH_LIMIT / 2) {
44      baseline += (value - baseline) * 0.05;  // ortam ışığını yavaşça izle / slowly follow ambient light
45    }
46    Serial.print(F("Guc / Strength: "));
47    Serial.print(strength);
48    Serial.print(F("  Dalgalanma / Swing: "));
49    Serial.println(swing);
50    winMin = 1023;
51    winMax = 0;
52    windowStart = now;
53  }
54
55  bool candidate = strength > STRENGTH_LIMIT && flickering;
56  if (!candidate) candidateSince = now;  // koşul bozulunca sayaç sıfırlanır / timer resets when the condition breaks
57  bool alarm = now - candidateSince >= CONFIRM_MS;
58
59  digitalWrite(LED, alarm ? HIGH : LOW);
60  digitalWrite(BUZZER, (alarm && (now / 200) % 2) ? HIGH : LOW);  // kesik siren / beeping siren
61}

Como o código marca o tempo com millis() em vez de delay(), ele continua medindo mesmo com o alarme tocando; os detalhes dessa abordagem estão em millis ou delay. A referência também não fica fixa: quando não há chama, ela se move 5 por cento em direção à leitura mais recente uma vez por segundo e acompanha devagar a luz ambiente conforme ela muda ao longo do dia. Para achar um bom FLICKER_LIMIT, observe no Monitor Serial a oscilação de um segundo de uma fonte de luz constante, depois a de uma chama de vela, e coloque o limite entre as duas. Esse método não é perfeito; a luz do sol passando por folhas que se mexem com o vento também tremula. Você encontra outras técnicas, como filtros de média móvel e de mediana, em filtragem de dados de sensores.

Usando junto com um sensor de gás MQ-2

Um sensor de chama e um sensor de gás MQ-2 cobrem as fraquezas um do outro. O sensor de chama é muito rápido, mas só vê chamas dentro do seu campo de visão e pode ser enganado pelo sol. O MQ-2 detecta fumaça e gases inflamáveis e consegue perceber um incêndio atrás de um canto ou um fogo que arde sem chama, mas a fumaça demora a chegar até ele e ele precisa aquecer toda vez que é ligado. Usando os dois, você pode tratar o sinal de um sensor como aviso e o sinal dos dois ao mesmo tempo como incêndio.

1// Alev sensörü + MQ-2 ile iki kademeli yangın alarmı / Two-level fire alarm with a flame sensor + MQ-2
2const int FLAME_DO = 2;
3const int MQ2_AO = A1;                   // MQ-2 analog çıkışı / MQ-2 analog output
4const int BUZZER = 8;
5const int LED = 7;
6const int FLAME_ACTIVE = LOW;            // KY-026 kullanıyorsan HIGH / HIGH if you use a KY-026
7const int SMOKE_LIMIT = 400;             // temiz hava değerinin belirgin üstü / well above the clean-air value
8const unsigned long WARMUP_MS = 60000;   // MQ-2 ön ısıtma süresi / MQ-2 warm-up time
9const unsigned long HOLD_MS = 300;       // DO'daki kısa kesintileri yok say / ignore short gaps on DO
10
11unsigned long lastFlame = 0;
12unsigned long lastPrint = 0;
13
14void setup() {
15  Serial.begin(9600);
16  pinMode(FLAME_DO, INPUT);
17  pinMode(BUZZER, OUTPUT);
18  pinMode(LED, OUTPUT);
19}
20
21void loop() {
22  unsigned long now = millis();
23  if (digitalRead(FLAME_DO) == FLAME_ACTIVE) lastFlame = now;
24  bool flame = lastFlame > 0 && now - lastFlame < HOLD_MS;
25
26  int gas = analogRead(MQ2_AO);
27  bool smoke = now > WARMUP_MS && gas > SMOKE_LIMIT;  // ısınana kadar dumanı yok say / ignore smoke until warmed up
28
29  int level = 0;                         // 0 normal, 1 uyarı / warning, 2 yangın / fire
30  if (flame && smoke) level = 2;
31  else if (flame || smoke) level = 1;
32
33  if (level == 2) {
34    digitalWrite(LED, HIGH);
35    digitalWrite(BUZZER, (now / 150) % 2 ? HIGH : LOW);     // hızlı siren / fast siren
36  } else if (level == 1) {
37    digitalWrite(LED, (now / 500) % 2 ? HIGH : LOW);        // yanıp sönen LED / blinking LED
38    digitalWrite(BUZZER, (now % 2000) < 100 ? HIGH : LOW);  // 2 sn'de bir kısa bip / short beep every 2 s
39  } else {
40    digitalWrite(LED, LOW);
41    digitalWrite(BUZZER, LOW);
42  }
43
44  if (now - lastPrint >= 1000) {
45    lastPrint = now;
46    Serial.print(F("Alev / Flame: "));
47    Serial.print(flame ? 1 : 0);
48    Serial.print(F("  MQ-2: "));
49    Serial.print(gas);
50    Serial.print(F("  Seviye / Level: "));
51    Serial.println(level);
52  }
53}

Ligue a saída AO do MQ-2 no A1 e alimente o módulo pelo 5V; o sensor de chama pode continuar no D2. Ajuste SMOKE_LIMIT claramente acima do valor que você lê depois de deixar o sensor funcionando alguns minutos em ar limpo, como descrito no guia do MQ-2. A condição de fumaça é ignorada nos primeiros 60 segundos, porque um MQ-2 frio começa com uma leitura alta. O tempo de retenção de 300 ms no sinal de chama (HOLD_MS) transforma o liga-desliga rápido da saída DO, causado pela chama tremulando, em uma detecção contínua. Se você levar essa combinação para um ESP32, cuidado: o MQ-2 precisa de 5 V e a saída AO dele pode chegar a 5 V, então você precisa colocar um divisor de tensão na saída dele, enquanto o sensor de chama funciona direto no 3V3.

Notificações de incêndio no celular com ESP32 (Telegram)

Para que o alarme avise não só quem está no cômodo, mas também você quando estiver fora, dá para usar um ESP32. Bots do Telegram são o jeito mais fácil de fazer isso: são grátis, não precisam de servidor próprio e a mensagem chega na hora ao celular como notificação. O código abaixo toca o buzzer e envia uma mensagem pelo Telegram quando uma chama é vista por 1,5 segundo, e espera pelo menos um minuto entre as mensagens para não inundar o seu celular por causa do mesmo incêndio. Explicamos em detalhes a criação do bot e o controle bidirecional com comandos em bot do Telegram no ESP32.

1. No Telegram, converse com o @BotFather, envie o comando /newbot, dê um nome ao seu bot e copie o token que ele fornecer.
2. Abra um bot de ID como o @userinfobot e toque em Start (Iniciar); ele responde com o seu chat ID.
3. Encontre o seu novo bot no Telegram e toque em Start (Iniciar); se você pular isso, o bot não consegue enviar mensagens para você.
4. No Arduino IDE, instale as bibliotecas UniversalTelegramBot e ArduinoJson pelo Gerenciador de Bibliotecas.
5. Troque no código o nome do Wi-Fi, a senha, o token e o chat ID pelos seus, selecione ESP32 como placa e carregue o código.

1// ESP32 alev alarmı + Telegram bildirimi / ESP32 flame alarm + Telegram notification
2#include <WiFi.h>
3#include <WiFiClientSecure.h>
4#include <UniversalTelegramBot.h>        // ArduinoJson kütüphanesi de gerekir / also needs the ArduinoJson library
5
6const char* WIFI_SSID = "WIFI_ADI";      // Wi-Fi ağının adı / your Wi-Fi name
7const char* WIFI_PASS = "WIFI_SIFRESI";  // Wi-Fi şifren / your Wi-Fi password
8#define BOT_TOKEN "1234567890:ABCdefGhIJKlmNoPQRstuVWXyz"  // BotFather'dan / from BotFather
9#define CHAT_ID "123456789"              // senin chat ID'n / your chat ID
10
11const int FLAME_DO = 27;                 // modülün DO pini / module DO pin
12const int BUZZER = 25;                   // aktif buzzer / active buzzer
13const int LED = 26;                      // kırmızı LED (220 Ω ile) / red LED (with 220 Ω)
14const int FLAME_ACTIVE = LOW;
15const unsigned long HOLD_MS = 300;       // DO'daki kısa kesintileri yok say / ignore short gaps on DO
16const unsigned long CONFIRM_MS = 1500;   // alev bu kadar sürmeli / flame must last this long
17const unsigned long COOLDOWN_MS = 60000; // iki mesaj arası en az 1 dk / at least 1 min between messages
18
19WiFiClientSecure client;
20UniversalTelegramBot bot(BOT_TOKEN, client);
21
22unsigned long lastFlame = 0;
23unsigned long flameStart = 0;
24unsigned long lastMessage = 0;
25bool messageSent = false;
26
27void setup() {
28  Serial.begin(115200);
29  pinMode(FLAME_DO, INPUT);
30  pinMode(BUZZER, OUTPUT);
31  pinMode(LED, OUTPUT);
32
33  WiFi.mode(WIFI_STA);
34  WiFi.begin(WIFI_SSID, WIFI_PASS);
35  client.setCACert(TELEGRAM_CERTIFICATE_ROOT);  // api.telegram.org kök sertifikası / root certificate
36  unsigned long start = millis();
37  while (WiFi.status() != WL_CONNECTED && millis() - start < 15000) {  // en fazla 15 sn bekle / wait up to 15 s
38    delay(500);
39    Serial.print(".");
40  }
41  if (WiFi.status() == WL_CONNECTED) {
42    Serial.println(WiFi.localIP());
43    bot.sendMessage(CHAT_ID, "Yangin alarmi devrede / Fire alarm is online", "");
44  }
45}
46
47void loop() {
48  unsigned long now = millis();
49  if (digitalRead(FLAME_DO) == FLAME_ACTIVE) lastFlame = now;
50  bool flame = lastFlame > 0 && now - lastFlame < HOLD_MS;
51  if (!flame) flameStart = now;          // alev yoksa sayaç sıfırlanır / timer resets without flame
52  bool alarm = now - flameStart >= CONFIRM_MS;
53
54  digitalWrite(LED, alarm ? HIGH : LOW);
55  digitalWrite(BUZZER, (alarm && (now / 200) % 2) ? HIGH : LOW);  // kesik siren / beeping siren
56
57  if (alarm && (!messageSent || now - lastMessage >= COOLDOWN_MS)) {
58    if (WiFi.status() == WL_CONNECTED) {
59      bool ok = bot.sendMessage(CHAT_ID, "ALEV ALGILANDI! / FLAME DETECTED!", "");
60      Serial.println(ok ? "Mesaj gitti / Message sent" : "Gonderilemedi / Send failed");
61    } else {
62      WiFi.reconnect();                  // bağlantı koptuysa yeniden dene / reconnect if the link dropped
63    }
64    lastMessage = now;                   // başarısızsa 1 dk sonra yeniden dener / retries after 1 min if it failed
65    messageSent = true;
66  }
67  delay(10);
68}

A chamada sendMessage() abre uma conexão HTTPS segura, então pode levar um ou dois segundos; nesse tempo o padrão do buzzer congela por um instante, o que é normal. Na inicialização, o código tenta se conectar ao Wi-Fi por até 15 segundos; se não houver conexão, ele continua rodando o alarme localmente e tenta de novo, um minuto depois, enviar a mensagem pendente, então o buzzer continua tocando mesmo sem internet. Se você também quiser ler a saída AO em um ESP32, ligue-a sempre em um pino ADC1 (GPIO 32–39), porque os pinos ADC2 não podem ser usados com o Wi-Fi ligado; é por isso que o GPIO 34 foi escolhido na tabela. Você pode ver os pinos seguros da sua placa na ferramenta Pinagem. Se um buzzer ativo de 5 V soar fraco em um pino de 3,3 V, acione-o com 5 V por meio de um transistor. Para um galpão ou uma casa de veraneio sem Wi-Fi, você pode montar o mesmo alarme para enviar SMS com um módulo GSM SIM800L.

Sensor de chama com Raspberry Pi Pico e MicroPython

A mesma lógica vale no Raspberry Pi Pico. Alimente o módulo pelo pino 3V3(OUT), ligue o DO no GP15 e, se tiver, o AO no GP26. O módulo tem seu próprio resistor de pull-up na linha DO, então você não precisa do pull-up interno do Pico. O ADC do Pico é de 12 bits, mas o read_u16() do MicroPython escala o resultado para 0–65535, então o equivalente ao 1023 do Arduino aqui é cerca de 65535. O código usa um tempo de retenção de 300 ms que tolera falhas breves no DO e uma confirmação de 1,5 segundo:

1# Raspberry Pi Pico alev alarmı / Raspberry Pi Pico flame alarm
2from machine import Pin, ADC
3import time
4
5flame_do = Pin(15, Pin.IN)      # modülün DO pini / module DO pin
6flame_ao = ADC(26)              # GP26 = ADC0, 4 pinli modülde AO / AO on the 4-pin module
7buzzer = Pin(14, Pin.OUT)       # aktif buzzer / active buzzer
8led = Pin(13, Pin.OUT)          # kırmızı LED (220 Ω ile) / red LED (with 220 Ω)
9
10FLAME_ACTIVE = 0                # çoğu modülde alev = 0, KY-026'da 1 / most modules: flame = 0, KY-026: 1
11HOLD_MS = 300                   # DO'daki kısa kesintileri yok say / ignore short gaps on DO
12CONFIRM_MS = 1500               # alev bu kadar sürmeli / flame must last this long
13
14last_flame = None
15flame_start = time.ticks_ms()
16last_print = time.ticks_ms()
17
18while True:
19    now = time.ticks_ms()
20    if flame_do.value() == FLAME_ACTIVE:
21        last_flame = now
22    flame = last_flame is not None and time.ticks_diff(now, last_flame) < HOLD_MS
23    if not flame:
24        flame_start = now       # alev yoksa sayaç sıfırlanır / timer resets without flame
25    alarm = time.ticks_diff(now, flame_start) >= CONFIRM_MS
26
27    led.value(1 if alarm else 0)
28    buzzer.value(1 if alarm and (now // 200) % 2 else 0)   # kesik siren / beeping siren
29
30    if time.ticks_diff(now, last_print) >= 500:   # yarım saniyede bir yaz / print every half second
31        last_print = now
32        print(flame_ao.read_u16(), "ALARM" if alarm else "-")
33    time.sleep_ms(10)

Quando você roda o código no Thonny, vê o valor AO e o estado do alarme na janela Shell; abra o Plotter pelo menu View (Exibir) para acompanhar os valores em gráfico. Para o programa iniciar automaticamente quando o Pico for ligado, salve o arquivo no Pico como main.py. Usar time.ticks_diff() para a contagem de tempo é importante, porque o contador ticks_ms() dá a volta depois de um certo valor e uma subtração simples dá o resultado errado nesse momento.

Ideias de projetos com sensor de chama

• Alarme de incêndio na cozinha: monte um alarme com um sensor de chama voltado para o fogão e um MQ-2, usando a lógica de dois níveis acima.
• Lembrete de fogão esquecido: se uma chama for vista continuamente por mais de 30 minutos, toque o buzzer e envie uma mensagem para o seu celular.
• Robô bombeiro: encontre a direção da chama com um sensor de 5 canais, leve o robô até ela com um L298N e motores CC e apague a vela com uma minibomba de água.
• Rastreador da direção da chama: monte um único sensor sobre um servo motor, varra de 0 a 180 graus e mostre o ângulo com o sinal mais forte.
• Painel de segurança da casa inteligente: combine sensores de chama, gás e movimento em uma só placa; veja os detalhes em projeto de casa inteligente com Arduino.
• Guarda da oficina: quando uma chama inesperada aparecer perto da estação de solda, acenda uma luz de aviso por meio de um relé.
• Competição de apagar velas: como nas competições escolares de robótica, monte um robô que encontre e apague uma vela em um labirinto o mais rápido possível; um sensor de chama é tudo de que você precisa para começar.

Erros comuns e como resolvê-los

O sensor de chama é uma peça barata, mas instrutiva, que ensina de uma só vez a física da luz infravermelha, os circuitos comparadores e como combater alarmes falsos. Comece com um alarme simples pelo DO e depois reforce seu sistema passo a passo com leituras analógicas, análise de tremulação e um MQ-2; para um sistema de segurança mais completo, dê uma olhada em sistema de alarme com Arduino. No app BlueGrays você encontra os projetos de sensor de chama, alarme com sensor de chama e de gás, detector de fumaça com ESP32 e MQ-2 e sistema de alarme com ESP32 e notificação pelo Telegram, cada um com esquemas do circuito passo a passo e código pronto para usar.