Sensor de llama Arduino: conexión, código y alarma de incendio

Un sensor de llama es un módulo barato que detecta la luz infrarroja que emite un mechero, una vela o un papel ardiendo, y puedes usarlo con Arduino con unas pocas líneas de código. Para usar un sensor de llama con Arduino no necesitas ninguna librería: el pin DO del módulo cambia de estado cuando ve una llama y el pin AO de las versiones de 4 pines da una tensión que varía con la intensidad de la llama. Es uno de los sensores más usados en alarmas de incendio, robots bomberos, sistemas de seguridad para la cocina y proyectos escolares.

En esta guía verás qué hay dentro de un sensor de llama y por qué solo responde a la luz entre 760 y 1100 nm, en qué se diferencian la salida digital y la analógica, cómo ajustar bien el potenciómetro de sensibilidad y cuál es su alcance y su ángulo de detección. Después montarás una alarma de incendio con zumbador y LED, combinarás el sensor con un sensor de gas MQ-2, reducirás por software las falsas alarmas que provocan fuentes como el sol o los mandos a distancia, enviarás una notificación de Telegram a tu móvil con un ESP32 y harás funcionar el mismo circuito en una Raspberry Pi Pico con MicroPython.

¿Qué es un sensor de llama y cómo funciona?

La pieza negra con aspecto de LED que hay en el extremo del módulo es en realidad un fototransistor infrarrojo (en algunas placas, un fotodiodo); un ejemplo habitual es el YG1006. Su encapsulado de epoxi negro filtra la mayor parte de la luz visible y solo deja pasar el infrarrojo cercano, aproximadamente entre 760 y 1100 nm, con la máxima sensibilidad hacia los 940 nm. El límite superior lo pone el propio silicio: con una banda prohibida de 1,12 eV, el silicio no puede absorber fotones de longitud de onda mayor que unos 1100 nm. Como las partículas de hollín caliente de una llama también emiten en esa banda, la corriente que atraviesa el fototransistor aumenta a medida que la llama se acerca. Un divisor de tensión de la placa convierte esa corriente en tensión y el comparador LM393 la compara con el umbral que fijas en el potenciómetro para decidir el estado del pin DO.

Existen varias placas de sensor de llama que hacen el mismo trabajo. Los módulos de 3 pines, como el de la foto, solo tienen salida digital; los de 4 pines añaden una salida analógica. El KY-026, que quizá conozcas de los kits de sensores, funciona igual, pero su salida DO suele estar invertida. Los robots bomberos usan placas multicanal con cinco receptores dispuestos en abanico. Un sensor de llama es pasivo, es decir, no emite luz propia; en eso se diferencia del sensor infrarrojo TCRT5000, que tiene emisor y receptor.

Diferencia entre la salida digital (DO) y la analógica (AO)

El pin DO es una respuesta de sí o no: cambia de estado cuando la luz infrarroja supera el umbral que fijas con el potenciómetro. En las placas azules habituales este pin está normalmente en HIGH, pasa a LOW al ver una llama y se enciende el LED de DO; en algunas placas, como la KY-026, ocurre lo contrario. Por eso, lo primero es probar tu módulo con un mechero y comprobar en el monitor serie qué valor lees. El pin AO entrega la señal en bruto. En la mayoría de los módulos este valor baja cuando la llama se acerca: una lectura de analogRead de 900–1020 en una habitación sin llama puede caer a unos pocos cientos con un mechero cerca. El potenciómetro solo cambia el umbral de DO y no afecta a AO.

Cómo ajustar el potenciómetro de sensibilidad

1. Alimenta el módulo y coloca el sensor donde vaya a trabajar, mirando hacia la zona que vigilará; haz siempre el ajuste en el entorno real.
2. Sin ninguna llama presente, gira el potenciómetro azul con un destornillador pequeño y busca el punto en el que el LED de DO pasa de encendido a apagado.
3. Desde ese punto, gira media o una vuelta más hacia el lado en el que el LED queda apagado. Así, los pequeños cambios de la luz ambiente no dispararán la alarma.
4. Sostén un mechero hacia el sensor a la mayor distancia que quieras detectar y comprueba que el LED se enciende. Si no lo hace, aumenta un poco la sensibilidad y vuelve a probar.
5. Asegúrate de que el sensor no apunta a una ventana soleada ni a una bombilla incandescente y revisa el ajuste unas horas después con otra iluminación.

Alcance y ángulo de detección

Valores como los 80 cm que indican los fabricantes se refieren a la llama normal de un mechero; el alcance real depende del tamaño de la llama, del ajuste del potenciómetro y de la luz ambiente. Aquí se aplica una ley física sencilla: la intensidad de la luz de una fuente pequeña disminuye con el cuadrado de la distancia. Si duplicas la distancia, la luz infrarroja que llega al sensor baja a una cuarta parte. Visto al revés, detectarás una llama que emite cuatro veces más luz desde el doble de distancia, y una cien veces más potente desde diez veces más lejos. Por eso la llama de una vela se detecta a menos distancia que un mechero, mientras que un montón de papel ardiendo se detecta a varios metros.

El ángulo de detección es de unos 60 grados, así que el sensor ve las llamas dentro de un cono de unos 30 grados a cada lado de su eje, y la señal se debilita rápidamente cuando la llama se acerca al borde de ese cono. El receptor tiene patas largas, por lo que puedes doblarlo con cuidado hacia donde quieras, pero doblar una y otra vez el punto donde las patas entran en el encapsulado acaba rompiéndolas. Para estrechar el campo de visión, coloca un tubo negro mate sobre el receptor: un tubo de 6 mm de diámetro interior y 2 cm de largo reduce el ángulo a unos 30 grados y bloquea la luz del sol o de las lámparas que llega de lado. El campo de visión debe ser justo el necesario para cubrir la zona que quieres vigilar; todo lo demás solo añade nuevas fuentes de falsas alarmas.

Conexión del sensor de llama: Arduino Uno, ESP32 y Pico

Paso a paso: alarma de incendio con sensor de llama y Arduino

1. Conecta el pin VCC del módulo al pin 5V de Arduino, GND a GND y DO a D2.
2. Conecta la pata larga (+) del zumbador activo a D8 y la pata corta a GND.
3. Conecta la pata larga del LED rojo a D7 a través de una resistencia de 220 Ω y la pata corta a GND. Si usas otro LED, puedes calcular la resistencia con la calculadora de resistencia para LED.
4. Sube el código de abajo, abre el monitor serie a 9600 baudios y acerca un momento un mechero hacia el sensor desde 20–30 cm.
5. Si el zumbador suena y el LED se enciende, el circuito funciona; si la alarma suena sin llama y se calla cuando hay una, cambia FLAME_ACTIVE a HIGH en el código.

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}

En cada vuelta, el código lee el pin DO y compara el resultado con la constante FLAME_ACTIVE. Gracias a ella, el mismo código funciona con los módulos azules que dan LOW ante una llama y con el KY-026, que da HIGH. Mientras haya una llama a la vista, el LED permanece encendido y el zumbador se activa y desactiva cada 150 ms para producir un pitido intermitente que llama la atención. Un zumbador activo lleva su propio oscilador y solo necesita HIGH y LOW; si tienes uno pasivo, usa tone() en lugar de digitalWrite, como se explica en qué es un zumbador. Hay otra razón para conectar DO a D2: en el Uno, D2 es uno de los dos pines que admiten interrupciones, así que con attachInterrupt puedes detectar la llama sin esperar al resto del bucle.

Lectura analógica: intensidad de la llama y distancia aproximada

Con un módulo de 4 pines, la salida AO te permite hacer mucho más. Como el valor en bruto cambia en cada entorno, en lugar de un umbral fijo usa este método: al arrancar, sin llama, mide un valor base (baseline) y después observa cuánto se aleja cada nueva lectura de él. El código siguiente promedia 16 lecturas para reducir el ruido, calcula la desviación como fuerza de la llama e indica de forma aproximada si la llama está cerca o lejos. Si el valor AO de tu módulo sube con la llama, basta con poner DROPS_WITH_FLAME a 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}

Los umbrales 100 y 400 del código son solo un punto de partida. Para ajustarlos a tu sensor, sube el código, abre el monitor serie y anota la fuerza de la llama con un mechero a 10, 30 y 60 cm; por la ley del cuadrado inverso verás que el valor cambia muy rápido de cerca y despacio de lejos. Por eso no se puede calcular una distancia exacta en centímetros a partir del valor analógico: el mismo valor puede venir de una llama pequeña cercana o de una grande lejana. Puedes ver cómo genera el ADC el valor en bruto en conversión analógico-digital y los detalles del monitor serie en Arduino Serial Monitor.

La luz del sol y otras causas de falsas alarmas

Un sensor de llama no ve el fuego, sino la luz infrarroja de una banda concreta, y cualquier cosa que emita luz en esa banda puede dispararlo. La ley de Wien explica qué fuentes dan problemas: la longitud de onda a la que un cuerpo caliente emite con más fuerza es de unos 2898 / T micrómetros (T es la temperatura en kelvin). El sol y las bombillas incandescentes emiten con fuerza justo en la banda del sensor, mientras que el cuerpo humano está demasiado frío, así que el sensor no te ve en absoluto. Por eso, para detectar movimiento hace falta un sensor PIR, que trabaja con longitudes de onda mucho mayores.

Puedes evitar la mayoría de las falsas alarmas con el hardware: coloca el sensor de modo que no mire a una ventana, a una pared soleada ni a una bombilla incandescente, a ser posible apuntando hacia abajo y hacia el interior de la habitación, estrecha su campo de visión con un tubo negro y ajusta el potenciómetro con la luz ambiente real. Recuerda que la luz solar intensa no solo provoca falsas alarmas, también puede cegar el sensor al saturarlo: si al sol el valor AO ya está en el mínimo, no queda nada que cambiar cuando aparezca una llama real. Los detectores de llama infrarrojos profesionales lo resuelven observando la banda de 4,3 µm, donde emite el dióxido de carbono caliente y la atmósfera absorbe gran parte de la luz solar, comparando varias longitudes de onda y analizando el parpadeo de la llama. Tu módulo no puede hacer lo primero ni lo segundo, pero sí puedes imitar por software el análisis del parpadeo y la confirmación por tiempo.

Reducir falsas alarmas por software: confirmación por tiempo y análisis del parpadeo

Una llama real nunca arde de forma constante; las corrientes de aire y los gases calientes que suben hacen que su brillo oscile aproximadamente entre 1 y 20 veces por segundo. En cambio, la luz del sol y la de una bombilla incandescente son casi constantes en periodos cortos, y los pulsos de un mando a distancia duran solo milisegundos. El código siguiente aprovecha estas diferencias con tres reglas: la fuerza de la llama debe estar claramente por encima del valor base, el valor debe haber oscilado más de cierta cantidad en el último segundo y ambas condiciones deben mantenerse sin interrupción al menos dos segundos. Además, cada lectura es la media de 20 muestras tomadas durante 10 ms. En una red de 50 Hz, las lámparas parpadean ligeramente 100 veces por segundo; promediar durante 10 ms, exactamente un periodo de ese parpadeo, elimina la oscilación y la lámpara no se confunde con una llama que parpadea.

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 el código mide el tiempo con millis() en lugar de delay(), sigue midiendo incluso mientras suena la alarma; tienes los detalles en millis frente a delay. El valor base tampoco es fijo: cuando no hay llama, se desplaza un 5 % hacia la última lectura una vez por segundo y sigue lentamente los cambios de luz ambiente a lo largo del día. Para encontrar un FLICKER_LIMIT adecuado, observa en el monitor serie la oscilación por segundo de una fuente de luz estable y luego la de una vela, y coloca el umbral entre ambas. El método no es perfecto; la luz del sol que atraviesa hojas movidas por el viento también parpadea. Encontrarás otras técnicas, como la media móvil y el filtro de mediana, en filtrar datos de sensores.

Uso junto con el sensor de gas MQ-2

Un sensor de llama y un sensor de gas MQ-2 se complementan. El sensor de llama es muy rápido, pero solo ve las llamas de su campo de visión y el sol puede engañarlo. El MQ-2 detecta humo y gases inflamables y puede notar un fuego detrás de una esquina o uno que arde sin llama, pero el humo tarda en llegar hasta él y necesita precalentarse cada vez que se enciende. Si usas los dos, puedes tratar la señal de uno solo como un aviso y la señal simultánea de ambos como un incendio.

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}

Conecta la salida AO del MQ-2 a A1 y alimenta el módulo desde 5V; el sensor de llama puede seguir en D2. Fija SMOKE_LIMIT claramente por encima del valor que leas tras unos minutos en aire limpio, como explicamos en la guía del MQ-2. La condición de humo se ignora durante los primeros 60 segundos porque un MQ-2 frío arranca con un valor alto. El tiempo de retención de 300 ms de la señal de llama (HOLD_MS) convierte los breves encendidos y apagados de la salida DO, causados por el parpadeo de la llama, en una detección continua. Si pasas esta combinación a un ESP32, cuidado: el MQ-2 necesita 5 V y su salida AO puede llegar a 5 V, así que debes poner un divisor de tensión en su salida; el sensor de llama, en cambio, funciona directamente a 3V3.

Aviso de incendio en el móvil con ESP32 (Telegram)

Para que la alarma no solo avise a quien esté en la habitación, sino también a ti cuando estés fuera, puedes usar un ESP32. Los bots de Telegram son la forma más sencilla: son gratuitos, no necesitas montar un servidor y el mensaje llega al instante como notificación al móvil. El código siguiente hace sonar el zumbador y envía un mensaje de Telegram cuando se ha visto una llama durante 1,5 segundos, y espera al menos un minuto entre mensajes para no llenarte el móvil de avisos por el mismo fuego. Explicamos en detalle cómo crear el bot y controlarlo en ambos sentidos con comandos en bot de Telegram con ESP32.

1. En Telegram, habla con @BotFather, envía el comando /newbot, ponle un nombre a tu bot y copia el token que te da.
2. Abre un bot de identificación como @userinfobot y pulsa Iniciar; te responderá con tu propio chat ID.
3. Busca tu nuevo bot en Telegram y pulsa Iniciar (Start); si no lo haces, el bot no podrá enviarte mensajes.
4. En el IDE de Arduino, instala las librerías UniversalTelegramBot y ArduinoJson desde el gestor de librerías.
5. Sustituye en el código el nombre de la red Wi-Fi, la contraseña, el token y el chat ID por los tuyos, elige ESP32 como placa y sube el 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}

La llamada a sendMessage() abre una conexión HTTPS segura, así que puede tardar uno o dos segundos; durante ese tiempo el patrón del zumbador se congela un instante, y es normal. Al arrancar, el código intenta conectarse a la Wi-Fi durante 15 segundos como máximo; si no hay conexión, la alarma sigue funcionando en local y el mensaje no enviado se reintenta un minuto después, de modo que el zumbador suena aunque no haya internet. Si también quieres leer la salida AO en el ESP32, conéctala siempre a un pin ADC1 (GPIO 32–39), porque los pines ADC2 no se pueden usar con la Wi-Fi activa; por eso la tabla usa GPIO 34. Puedes ver los pines seguros de tu placa en la herramienta Pinout. Si un zumbador activo de 5 V suena débil en un pin de 3,3 V, gobiérnalo desde 5 V con un transistor. Para un trastero o una casa de campo sin Wi-Fi, puedes montar la misma alarma para que envíe un SMS con un módulo GSM SIM800L.

Sensor de llama con Raspberry Pi Pico y MicroPython

En la Raspberry Pi Pico se aplica la misma lógica. Alimenta el módulo desde el pin 3V3(OUT), conecta DO a GP15 y, si lo tienes, AO a GP26. El módulo ya lleva su propia resistencia pull-up en la línea DO, así que no necesitas la pull-up interna de la Pico. El ADC de la Pico es de 12 bits, pero en MicroPython read_u16() escala el resultado a 0–65535, de modo que el equivalente al 1023 de Arduino es aquí unos 65535. El código usa un tiempo de retención de 300 ms que tolera los cortes breves en DO y una confirmación de 1,5 segundos:

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)

Al ejecutar el código en Thonny verás el valor de AO y el estado de la alarma en la ventana Shell; si abres el Plotter desde el menú Ver, podrás seguir los valores en una gráfica. Para que el programa arranque solo al alimentar la Pico, guarda el archivo en la Pico con el nombre main.py. Usar time.ticks_diff() para medir el tiempo es importante, porque el contador de ticks_ms() vuelve a empezar al llegar a cierto valor y una resta directa da un resultado erróneo en ese momento.

Ideas de proyectos con sensor de llama

• Alarma de incendio para la cocina: Monta una alarma con un sensor de llama que mire a los fogones y un MQ-2, usando la lógica de dos niveles de arriba.
• Aviso de fuego olvidado: Si se ve una llama sin interrupción durante más de 30 minutos, que suene el zumbador y llegue un mensaje al móvil.
• Robot bombero: Localiza la dirección de la llama con un sensor de 5 canales, lleva el robot hasta ella con un L298N y motores DC y apaga la vela con una mini bomba de agua.
• Escáner de dirección de la llama: Monta un solo sensor sobre un servomotor, barre de 0 a 180 grados y muestra el ángulo con la señal más fuerte.
• Panel de seguridad para casa inteligente: Reúne sensores de llama, gas y movimiento en una sola placa; tienes los detalles en proyecto de casa inteligente con Arduino.
• Vigilante del taller: Si aparece una llama inesperada cerca de la estación de soldadura, enciende una luz de aviso mediante un relé.
• Concurso de apagar velas: Como en las competiciones escolares de robótica, construye un robot que encuentre y apague una vela en un laberinto lo antes posible; un sensor de llama basta para empezar.

Errores frecuentes y cómo solucionarlos

El sensor de llama es una pieza barata pero muy didáctica que enseña a la vez la física de la luz infrarroja, los circuitos comparadores y cómo combatir las falsas alarmas. Empieza con una alarma sencilla por DO y refuerza tu sistema paso a paso con lecturas analógicas, análisis del parpadeo y un MQ-2; para un sistema de seguridad más completo, echa un vistazo a sistema de alarma con Arduino. En la aplicación BlueGrays encontrarás proyectos de uso del sensor de llama, alarma con sensor de llama y de gas, detector de humo MQ-2 con ESP32 y sistema de alarma ESP32 con aviso por Telegram, con esquemas paso a paso y código listo para usar.