Sensore di fiamma Arduino: schema, codice e allarme incendio

Un sensore di fiamma è un modulo economico che rileva la luce infrarossa emessa da un accendino, una candela o un foglio di carta che brucia, e puoi usarlo con Arduino con poche righe di codice. Per usare un sensore di fiamma con Arduino non serve nessuna libreria: il pin DO del modulo cambia stato quando vede una fiamma, mentre il pin AO delle versioni a 4 pin fornisce una tensione che varia con l'intensità della fiamma. È uno dei sensori più usati per allarmi antincendio, robot pompieri, sistemi di sicurezza per la cucina e progetti scolastici.

In questa guida scoprirai cosa c'è dentro un sensore di fiamma e perché reagisce solo alla luce tra 760 e 1100 nm, in cosa differiscono l'uscita digitale e quella analogica, come regolare correttamente il trimmer della sensibilità e quali sono la portata e l'angolo di rilevamento. Poi costruirai un allarme incendio con buzzer e LED, abbinerai il sensore a un sensore di gas MQ-2, ridurrai via software i falsi allarmi causati da fonti come il sole e i telecomandi, invierai una notifica Telegram al tuo telefono con un ESP32 e farai funzionare lo stesso circuito su un Raspberry Pi Pico con MicroPython.

Cos'è un sensore di fiamma e come funziona?

Il componente nero simile a un LED all'estremità del modulo è in realtà un fototransistor a infrarossi (su alcune schede un fotodiodo); un esempio comune è lo YG1006. Il suo corpo in resina epossidica nera filtra gran parte della luce visibile e lascia passare solo il vicino infrarosso tra circa 760 e 1100 nm, con la massima sensibilità intorno a 940 nm. Il limite superiore dipende dal silicio stesso: con una banda proibita di 1,12 eV, il silicio non riesce ad assorbire fotoni con lunghezza d'onda superiore a circa 1100 nm. Poiché le particelle di fuliggine calda di una fiamma emettono anche in questa banda, la corrente nel fototransistor aumenta man mano che la fiamma si avvicina. Un partitore di tensione sulla scheda trasforma questa corrente in tensione e il comparatore LM393 la confronta con la soglia impostata sul trimmer per decidere lo stato del pin DO.

Esistono diverse schede con sensore di fiamma che fanno lo stesso lavoro. I moduli a 3 pin, come quello della foto, hanno solo l'uscita digitale; quelli a 4 pin aggiungono un'uscita analogica. Il KY-026, che forse conosci dai kit di sensori, funziona allo stesso modo, ma la sua uscita DO di solito è invertita. I robot pompieri usano schede multicanale con cinque ricevitori disposti a ventaglio. Il sensore di fiamma è passivo, cioè non emette luce propria; in questo si distingue dal sensore a infrarossi TCRT5000, che ha sia un emettitore sia un ricevitore.

Differenza tra uscita digitale (DO) e analogica (AO)

Il pin DO dà una risposta sì/no: cambia stato quando la luce infrarossa supera la soglia impostata con il trimmer. Sulle comuni schede blu questo pin è normalmente HIGH, passa a LOW quando vede una fiamma e il LED DO si accende; su alcune schede come il KY-026 avviene il contrario. Per questo la prima cosa da fare è provare il tuo modulo con un accendino e controllare nel monitor seriale quale valore leggi. Il pin AO fornisce il segnale grezzo. Sulla maggior parte dei moduli questo valore diminuisce quando la fiamma si avvicina: una lettura analogRead di 900–1020 in una stanza senza fiamme può scendere a poche centinaia con un accendino vicino. Il trimmer cambia solo la soglia di DO e non influisce su AO.

Come regolare il trimmer della sensibilità

1. Alimenta il modulo e posiziona il sensore dove dovrà lavorare, rivolto verso la zona da sorvegliare; fai sempre la regolazione nell'ambiente reale.
2. Senza fiamme presenti, gira il trimmer blu con un piccolo cacciavite e trova il punto in cui il LED DO passa da acceso a spento.
3. Da quel punto, gira ancora di mezzo giro o un giro nella direzione in cui il LED resta spento. Così le piccole variazioni della luce ambiente non faranno scattare l'allarme.
4. Tieni un accendino rivolto verso il sensore alla distanza massima che vuoi rilevare e verifica che il LED si accenda. Se non succede, aumenta leggermente la sensibilità e riprova.
5. Assicurati che il sensore non guardi una finestra soleggiata o una lampadina a incandescenza e ricontrolla la regolazione qualche ora dopo con un'illuminazione diversa.

Portata e angolo di rilevamento

Valori come gli 80 cm indicati dai produttori si riferiscono alla normale fiamma di un accendino; la portata reale dipende dalla grandezza della fiamma, dalla regolazione del trimmer e dalla luce ambiente. Qui vale una semplice legge fisica: l'intensità della luce di una piccola sorgente diminuisce con il quadrato della distanza. Se raddoppi la distanza, la luce infrarossa che arriva al sensore scende a un quarto. Al contrario, una fiamma che emette quattro volte più luce si rileva dal doppio della distanza e una cento volte più forte da dieci volte più lontano. Per questo la fiamma di una candela si rileva da più vicino rispetto a un accendino, mentre un mucchio di carta che brucia si rileva da diversi metri.

L'angolo di rilevamento è di circa 60 gradi: il sensore vede le fiamme all'interno di un cono di circa 30 gradi per lato rispetto al suo asse, e il segnale si indebolisce rapidamente quando la fiamma si avvicina al bordo del cono. Il ricevitore ha i terminali lunghi, quindi puoi piegarlo con delicatezza nella direzione che preferisci, ma piegare di continuo il punto in cui i terminali entrano nel corpo finisce per spezzarli. Per restringere il campo visivo, infila sul ricevitore un tubetto nero opaco: un tubetto con diametro interno di 6 mm e lungo 2 cm riduce l'angolo a circa 30 gradi e blocca la luce del sole o delle lampade che arriva di lato. Il campo visivo deve essere ampio quanto basta per coprire la zona da sorvegliare; tutto il resto aggiunge solo nuove fonti di falsi allarmi.

Collegamento del sensore di fiamma: Arduino Uno, ESP32 e Pico

Passo dopo passo: allarme incendio con sensore di fiamma e Arduino

1. Collega il pin VCC del modulo al pin 5V di Arduino, GND a GND e DO a D2.
2. Collega il terminale lungo (+) del buzzer attivo a D8 e quello corto a GND.
3. Collega il terminale lungo del LED rosso a D7 tramite una resistenza da 220 Ω e quello corto a GND. Se usi un LED diverso, puoi calcolare la resistenza con il calcolatore della resistenza per LED.
4. Carica il codice qui sotto, apri il monitor seriale a 9600 baud e avvicina per un attimo un accendino al sensore da 20–30 cm.
5. Se il buzzer suona e il LED si accende, il circuito funziona; se l'allarme suona senza fiamma e si zittisce quando c'è, imposta FLAME_ACTIVE su HIGH nel codice.

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 ogni ciclo il codice legge il pin DO e confronta il risultato con la costante FLAME_ACTIVE. Grazie a questa costante, lo stesso codice funziona sia con i moduli blu che danno LOW in presenza di fiamma sia con il KY-026 che dà HIGH. Finché la fiamma è visibile il LED resta acceso, mentre il buzzer si accende e si spegne ogni 150 ms producendo un suono intermittente che attira l'attenzione. Un buzzer attivo ha un oscillatore interno e gli bastano HIGH e LOW; se hai un buzzer passivo usa tone() invece di digitalWrite, come spiegato in cos'è un buzzer. C'è anche un altro motivo per collegare DO a D2: sull'Uno, D2 è uno dei due pin che supportano gli interrupt, quindi con attachInterrupt puoi intercettare la fiamma senza aspettare il resto del loop.

Lettura analogica: intensità della fiamma e distanza approssimativa

Con un modulo a 4 pin, l'uscita AO ti permette di fare molto di più. Dato che il valore grezzo cambia in ogni ambiente, invece di una soglia fissa usa questo metodo: all'avvio, senza fiamme, misura un valore di riferimento (baseline) e poi osserva quanto ogni nuova lettura se ne discosta. Il codice seguente fa la media di 16 letture per ridurre il rumore, calcola lo scostamento come forza della fiamma e indica in modo approssimativo se la fiamma è vicina o lontana. Se il valore AO del tuo modulo sale con la fiamma, basta impostare DROPS_WITH_FLAME su 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}

Le soglie di 100 e 400 nel codice sono solo un punto di partenza. Per adattarle al tuo sensore, carica il codice, apri il monitor seriale e annota la forza della fiamma tenendo un accendino a 10, 30 e 60 cm; per la legge dell'inverso del quadrato vedrai il valore cambiare molto in fretta da vicino e lentamente da lontano. Per questo non si può ricavare una distanza esatta in centimetri dal valore analogico: lo stesso valore può arrivare da una piccola fiamma vicina o da una grande fiamma lontana. Puoi vedere come l'ADC produce il valore grezzo in conversione analogico-digitale e i dettagli del monitor seriale in Arduino Serial Monitor.

La luce del sole e le altre cause di falsi allarmi

Un sensore di fiamma non vede il fuoco, ma la luce infrarossa di una banda precisa, e qualsiasi cosa emetta luce in quella banda può farlo scattare. La legge di Wien spiega quali fonti creano problemi: la lunghezza d'onda a cui un corpo caldo emette di più è circa 2898 / T micrometri (T è la temperatura in kelvin). Il sole e le lampadine a incandescenza emettono molto proprio nella banda del sensore, mentre il corpo umano è troppo freddo, quindi il sensore non ti vede affatto. Ecco perché per rilevare il movimento serve un sensore PIR, che lavora su lunghezze d'onda molto più lunghe.

Puoi evitare la maggior parte dei falsi allarmi con l'hardware: posiziona il sensore in modo che non guardi una finestra, una parete al sole o una lampadina a incandescenza, possibilmente rivolto verso il basso e verso l'interno della stanza, restringi il campo visivo con un tubetto nero e regola il trimmer con la luce ambiente reale. Ricorda che la luce solare intensa non provoca solo falsi allarmi, ma può anche accecare il sensore saturandolo: se al sole il valore AO è già al minimo, non resta nulla da far variare quando compare una fiamma vera. I rilevatori di fiamma a infrarossi professionali risolvono il problema osservando la banda di 4,3 µm, in cui emette l'anidride carbonica calda e in cui l'atmosfera assorbe gran parte della luce solare, confrontando più lunghezze d'onda e analizzando lo sfarfallio della fiamma. Il tuo modulo non può fare le prime due cose, ma puoi imitare via software l'analisi dello sfarfallio e la conferma temporale.

Ridurre i falsi allarmi via software: conferma temporale e analisi dello sfarfallio

Una fiamma vera non brucia mai in modo costante; le correnti d'aria e i gas caldi che salgono fanno oscillare la sua luminosità circa da 1 a 20 volte al secondo. La luce del sole e quella di una lampadina a incandescenza, invece, sono quasi costanti su brevi intervalli, e gli impulsi di un telecomando durano solo millisecondi. Il codice seguente sfrutta queste differenze con tre regole: la forza della fiamma deve essere nettamente sopra il riferimento, il valore deve aver oscillato più di una certa quantità nell'ultimo secondo e le due condizioni devono restare vere senza interruzioni per almeno due secondi. Inoltre ogni lettura è la media di 20 campioni presi in 10 ms. Con la rete a 50 Hz le lampade sfarfallano leggermente 100 volte al secondo; una media su 10 ms, esattamente un periodo di questo sfarfallio, cancella l'oscillazione e la lampada non viene scambiata per una fiamma che tremola.

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}

Poiché il codice misura il tempo con millis() invece di delay(), continua a misurare anche mentre l'allarme suona; trovi i dettagli in millis e delay a confronto. Anche il riferimento non è fisso: quando non c'è fiamma, si sposta del 5% verso l'ultima lettura una volta al secondo e segue lentamente la luce ambiente che cambia durante il giorno. Per trovare un buon FLICKER_LIMIT, osserva nel monitor seriale l'oscillazione in un secondo di una sorgente di luce stabile, poi quella di una candela, e metti la soglia a metà strada. Il metodo non è perfetto: anche la luce del sole che filtra tra foglie mosse dal vento sfarfalla. Altre tecniche, come la media mobile e il filtro mediano, sono spiegate in filtrare i dati dei sensori.

Uso insieme al sensore di gas MQ-2

Un sensore di fiamma e un sensore di gas MQ-2 compensano a vicenda i propri limiti. Il sensore di fiamma è velocissimo, ma vede solo le fiamme nel suo campo visivo e il sole può ingannarlo. L'MQ-2 rileva fumo e gas infiammabili e può accorgersi di un incendio dietro un angolo o di una combustione lenta senza fiamma, ma il fumo impiega tempo a raggiungerlo e a ogni accensione deve scaldarsi. Usandoli insieme, puoi considerare il segnale di un solo sensore come un avviso e il segnale contemporaneo di entrambi come 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}

Collega l'uscita AO dell'MQ-2 ad A1 e alimenta il modulo dai 5V; il sensore di fiamma può restare su D2. Imposta SMOKE_LIMIT ben al di sopra del valore che leggi dopo alcuni minuti in aria pulita, come spiegato nella guida dell'MQ-2. La condizione del fumo viene ignorata nei primi 60 secondi, perché un MQ-2 freddo parte con un valore alto. Il tempo di mantenimento di 300 ms sul segnale di fiamma (HOLD_MS) trasforma le brevi commutazioni dell'uscita DO, causate dallo sfarfallio della fiamma, in un unico rilevamento continuo. Se porti questa combinazione su un ESP32, fai attenzione: l'MQ-2 richiede 5 V e la sua uscita AO può arrivare a 5 V, quindi devi assolutamente mettere un partitore di tensione sulla sua uscita, mentre il sensore di fiamma funziona direttamente a 3V3.

Notifica di incendio sul telefono con ESP32 (Telegram)

Perché l'allarme avvisi non solo chi si trova nella stanza ma anche te quando sei fuori casa, puoi usare un ESP32. I bot di Telegram sono il modo più semplice: sono gratuiti, non richiedono un server e il messaggio arriva subito sul telefono come notifica. Il codice seguente fa suonare il buzzer e invia un messaggio Telegram quando una fiamma è visibile per 1,5 secondi, e aspetta almeno un minuto tra due messaggi per non riempirti il telefono di avvisi per lo stesso incendio. Spieghiamo nel dettaglio come creare il bot e controllarlo nei due sensi con i comandi in bot Telegram con ESP32.

1. Su Telegram scrivi a @BotFather, invia il comando /newbot, dai un nome al tuo bot e copia il token che ti fornisce.
2. Apri un bot di identificazione come @userinfobot e tocca Avvia; ti risponderà con il tuo chat ID.
3. Cerca il tuo nuovo bot su Telegram e tocca Avvia (Start); altrimenti il bot non potrà mandarti messaggi.
4. Nell'IDE di Arduino installa le librerie UniversalTelegramBot e ArduinoJson dal gestore delle librerie.
5. Sostituisci nel codice il nome della rete Wi-Fi, la password, il token e il chat ID con i tuoi dati, scegli ESP32 come scheda e carica il codice.

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 chiamata a sendMessage() apre una connessione HTTPS sicura, quindi può durare uno o due secondi; in quel momento lo schema del buzzer si blocca per un attimo, ed è normale. All'avvio il codice prova a connettersi al Wi-Fi per al massimo 15 secondi; se la connessione manca, l'allarme continua a funzionare in locale e il messaggio non inviato viene riprovato un minuto dopo, quindi il buzzer suona anche senza internet. Se vuoi leggere anche l'uscita AO sull'ESP32, collegala sempre a un pin ADC1 (GPIO 32–39), perché i pin ADC2 non si possono usare con il Wi-Fi attivo; per questo nella tabella c'è GPIO 34. Puoi vedere i pin sicuri della tua scheda nello strumento Pinout. Se un buzzer attivo da 5 V suona debole su un pin a 3,3 V, pilotalo dai 5 V con un transistor. Per un magazzino o una casa di campagna senza Wi-Fi puoi realizzare lo stesso allarme in modo che invii un SMS con un modulo GSM SIM800L.

Sensore di fiamma con Raspberry Pi Pico e MicroPython

Sul Raspberry Pi Pico vale la stessa logica. Alimenta il modulo dal pin 3V3(OUT), collega DO a GP15 e, se c'è, AO a GP26. Il modulo ha già una propria resistenza di pull-up sulla linea DO, quindi non serve il pull-up interno del Pico. L'ADC del Pico è a 12 bit, ma in MicroPython read_u16() scala il risultato su 0–65535, perciò l'equivalente del 1023 di Arduino qui è circa 65535. Il codice usa un tempo di mantenimento di 300 ms che tollera brevi interruzioni su DO e una conferma di 1,5 secondi:

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 esegui il codice in Thonny vedi il valore di AO e lo stato dell'allarme nella finestra Shell; aprendo il Plotter dal menu Visualizza puoi seguire i valori in un grafico. Perché il programma parta da solo quando dai alimentazione al Pico, salva il file sul Pico con il nome main.py. Usare time.ticks_diff() per misurare il tempo è importante, perché il contatore di ticks_ms() ricomincia da capo dopo un certo valore e una semplice sottrazione in quel momento dà un risultato sbagliato.

Idee di progetti con il sensore di fiamma

• Allarme incendio per la cucina: Costruisci un allarme con un sensore di fiamma rivolto verso i fornelli e un MQ-2, usando la logica a due livelli vista sopra.
• Avviso fornello dimenticato: Se una fiamma resta visibile senza interruzioni per più di 30 minuti, il buzzer suona e parte un messaggio verso il telefono.
• Robot pompiere: Trova la direzione della fiamma con un sensore a 5 canali, guida il robot verso di essa con un L298N e motori DC e spegni la candela con una mini pompa dell'acqua.
• Scanner della direzione della fiamma: Monta un solo sensore su un servomotore, fai una scansione da 0 a 180 gradi e mostra l'angolo con il segnale più forte.
• Pannello di sicurezza per la casa smart: Riunisci sensori di fiamma, gas e movimento su un'unica scheda; i dettagli sono in progetto di casa intelligente con Arduino.
• Guardiano del laboratorio: Se vicino alla stazione di saldatura compare una fiamma inattesa, accendi una spia di allarme tramite un relè.
• Gara di spegnimento candele: Come nelle gare di robotica scolastiche, costruisci un robot che trovi e spenga una candela in un labirinto nel minor tempo possibile; per iniziare basta un sensore di fiamma.

Errori comuni e soluzioni

Il sensore di fiamma è un componente economico ma molto istruttivo, che insegna insieme la fisica della luce infrarossa, i circuiti comparatori e la lotta ai falsi allarmi. Parti da un semplice allarme su DO e poi rafforza il tuo sistema passo dopo passo con la lettura analogica, l'analisi dello sfarfallio e un MQ-2; per un sistema di sicurezza più completo dai un'occhiata a sistema d'allarme con Arduino. Nell'app BlueGrays trovi i progetti sull'uso del sensore di fiamma, sull'allarme con sensore di fiamma e di gas, sul rilevatore di fumo MQ-2 con ESP32 e sul sistema d'allarme ESP32 con notifica Telegram, con schemi passo dopo passo e codice pronto all'uso.