Flammensensor mit Arduino: Anschluss, Code und Feueralarm

Ein Flammensensor ist ein günstiges Modul, das das Infrarotlicht eines Feuerzeugs, einer Kerze oder von brennendem Papier erkennt, und du kannst ihn mit wenigen Zeilen Code am Arduino nutzen. Für den Flammensensor am Arduino brauchst du keine Bibliothek: Der DO-Pin des Moduls wechselt seinen Zustand, sobald er eine Flamme sieht, und der AO-Pin der 4-poligen Versionen liefert eine Spannung, die sich mit der Stärke der Flamme ändert. Er gehört zu den beliebtesten Sensoren für Feueralarme, Löschroboter, Sicherheitssysteme für die Küche und Schulprojekte.

In dieser Anleitung erfährst du, was in einem Flammensensor steckt und warum er nur auf Licht zwischen 760 und 1100 nm reagiert, wie sich der digitale und der analoge Ausgang unterscheiden, wie du das Empfindlichkeits-Poti richtig einstellst und welche Reichweite und welchen Erfassungswinkel er hat. Danach baust du einen Feueralarm mit Buzzer und LED, kombinierst den Sensor mit einem MQ-2-Gassensor, verringerst Fehlalarme durch Sonnenlicht oder Fernbedienungen per Software, schickst mit einem ESP32 eine Telegram-Nachricht auf dein Handy und bringst dieselbe Schaltung mit MicroPython auf einem Raspberry Pi Pico zum Laufen.

Was ist ein Flammensensor und wie funktioniert er?

Das schwarze, LED-ähnliche Bauteil an der Spitze des Moduls ist in Wirklichkeit ein Infrarot-Fototransistor (auf manchen Platinen eine Fotodiode); ein verbreitetes Beispiel ist der YG1006. Sein schwarzes Epoxidgehäuse filtert den Großteil des sichtbaren Lichts heraus und lässt nur nahes Infrarot zwischen etwa 760 und 1100 nm durch; am empfindlichsten ist er um 940 nm. Die obere Grenze kommt vom Silizium selbst: Mit einer Bandlücke von 1,12 eV kann Silizium keine Photonen mit Wellenlängen über etwa 1100 nm absorbieren. Weil die heißen Rußpartikel einer Flamme auch in diesem Bereich strahlen, steigt der Strom durch den Fototransistor, je näher eine Flamme kommt. Ein Spannungsteiler auf der Platine wandelt diesen Strom in eine Spannung um, und der LM393-Komparator vergleicht sie mit der am Poti eingestellten Schwelle und legt so den Zustand des DO-Pins fest.

Es gibt mehrere Flammensensor-Platinen, die dieselbe Aufgabe erfüllen. 3-polige Module wie das auf dem Foto oben haben nur einen digitalen Ausgang; 4-polige Module bringen zusätzlich einen analogen Ausgang mit. Der KY-026, den du vielleicht aus Sensor-Kits kennst, funktioniert genauso, sein DO-Ausgang ist aber meist invertiert. Löschroboter verwenden Mehrkanal-Platinen mit fünf fächerförmig angeordneten Empfängern. Ein Flammensensor ist passiv, er sendet also selbst kein Licht aus; darin unterscheidet er sich vom TCRT5000-Infrarotsensor, der Sender und Empfänger enthält.

Digitaler (DO) und analoger (AO) Ausgang im Vergleich

Der DO-Pin liefert eine Ja/Nein-Antwort: Er wechselt den Zustand, wenn das Infrarotlicht die am Poti eingestellte Schwelle überschreitet. Bei den verbreiteten blauen Platinen ist dieser Pin normalerweise HIGH, wird bei einer Flamme LOW, und die DO-LED leuchtet; bei manchen Platinen wie dem KY-026 ist es umgekehrt. Teste dein Modul deshalb zuerst mit einem Feuerzeug und schau im seriellen Monitor nach, welchen Wert du liest. Der AO-Pin liefert das Rohsignal. Bei den meisten Modulen sinkt dieser Wert, je näher die Flamme kommt: Ein analogRead-Wert von 900–1020 in einem Raum ohne Flamme kann mit einem nahen Feuerzeug auf einige Hundert fallen. Das Poti ändert nur die DO-Schwelle und hat keinen Einfluss auf AO.

Empfindlichkeit am Poti richtig einstellen

1. Versorge das Modul mit Strom und platziere den Sensor dort, wo er arbeiten soll, in der Richtung, die er überwachen soll; stelle ihn immer in der echten Umgebung ein.
2. Drehe das blaue Poti ohne Flamme mit einem kleinen Schraubendreher und suche den Punkt, an dem die DO-LED zwischen an und aus wechselt.
3. Drehe von diesem Punkt aus noch eine halbe bis ganze Umdrehung in die Richtung, in der die LED aus bleibt. So lösen kleine Schwankungen im Umgebungslicht keinen Alarm aus.
4. Halte ein Feuerzeug im größten gewünschten Abstand in Richtung Sensor und prüfe, ob die LED aufleuchtet. Wenn nicht, stelle ihn etwas empfindlicher ein und versuche es erneut.
5. Achte darauf, dass der Sensor nicht auf ein sonniges Fenster oder eine Glühlampe zeigt, und prüfe die Einstellung einige Stunden später bei anderem Licht noch einmal.

Reichweite und Erfassungswinkel

Angaben wie 80 cm in Herstellerdaten beziehen sich auf eine normale Feuerzeugflamme; die echte Reichweite hängt von der Größe der Flamme, der Poti-Einstellung und dem Umgebungslicht ab. Hier gilt ein einfaches physikalisches Gesetz: Die Intensität des Lichts einer kleinen Quelle nimmt mit dem Quadrat der Entfernung ab. Verdoppelst du den Abstand, sinkt das Infrarotlicht am Sensor auf ein Viertel. Umgekehrt erkennst du eine Flamme, die viermal so viel Licht abgibt, aus doppelter Entfernung und eine hundertmal stärkere aus zehnfacher Entfernung. Deshalb wird eine Kerzenflamme aus kürzerer Entfernung erkannt als ein Feuerzeug, ein brennender Papierstapel dagegen aus mehreren Metern.

Der Erfassungswinkel beträgt etwa 60 Grad; der Sensor sieht also Flammen in einem Kegel von rund 30 Grad zu beiden Seiten seiner Achse, und das Signal wird schnell schwächer, je weiter die Flamme an den Rand dieses Kegels rückt. Der Empfänger hat lange Beinchen, deshalb kannst du ihn vorsichtig in jede Richtung biegen, aber ständiges Biegen an der Stelle, wo die Beinchen ins Gehäuse gehen, bricht sie ab. Um den Sichtbereich einzuengen, schiebst du ein mattschwarzes Röhrchen über den Empfänger: Ein Röhrchen mit 6 mm Innendurchmesser und 2 cm Länge verringert den Winkel auf ungefähr 30 Grad und blockiert seitlich einfallendes Sonnen- oder Lampenlicht. Der Sichtbereich sollte gerade groß genug sein, um den zu überwachenden Bereich abzudecken; alles darüber hinaus bringt nur neue Fehlalarmquellen.

Flammensensor anschließen: Arduino Uno, ESP32 und Pico

Schritt für Schritt: Feueralarm mit Flammensensor und Arduino

1. Verbinde VCC des Moduls mit dem 5V-Pin des Arduino, GND mit GND und DO mit D2.
2. Verbinde das lange (+) Bein des aktiven Buzzers mit D8 und das kurze Bein mit GND.
3. Verbinde das lange Bein der roten LED über einen 220-Ω-Widerstand mit D7 und das kurze Bein mit GND. Für eine andere LED berechnest du den Vorwiderstand mit dem LED-Vorwiderstandsrechner.
4. Lade den folgenden Code hoch, öffne den seriellen Monitor mit 9600 Baud und halte kurz ein Feuerzeug aus 20–30 cm Entfernung in Richtung Sensor.
5. Piept der Buzzer und leuchtet die LED, funktioniert die Schaltung; löst der Alarm ohne Flamme aus und verstummt bei einer Flamme, setze FLAME_ACTIVE im Code auf 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}

Der Code liest bei jedem Durchlauf den DO-Pin und vergleicht das Ergebnis mit der Konstante FLAME_ACTIVE. Dank dieser Konstante funktioniert derselbe Code mit blauen Modulen, die bei einer Flamme LOW liefern, und mit dem KY-026, der HIGH liefert. Solange eine Flamme zu sehen ist, leuchtet die LED, und der Buzzer schaltet alle 150 ms ein und aus, sodass ein auffälliges, unterbrochenes Piepen entsteht. Ein aktiver Buzzer hat einen eigenen Oszillator und braucht nur HIGH und LOW; hast du einen passiven Buzzer, nimm tone() statt digitalWrite, wie in Was ist ein Buzzer erklärt. Es gibt noch einen Grund, warum DO an D2 hängt: Beim Uno ist D2 einer der beiden interruptfähigen Pins, du kannst die Flamme also mit attachInterrupt erfassen, ohne auf den Rest der Schleife zu warten.

Analog auslesen: Flammenstärke und ungefähre Entfernung

Mit einem 4-poligen Modul kannst du über den AO-Ausgang viel mehr machen. Weil der Rohwert in jeder Umgebung anders ist, nutze statt einer festen Schwelle diese Methode: Miss beim Start, ohne Flamme, einen Grundwert (Baseline) und beobachte dann, wie weit jede neue Messung davon abweicht. Der folgende Code mittelt 16 Messungen, um das Rauschen zu verringern, berechnet die Abweichung als Flammenstärke und sagt grob, ob die Flamme nah oder fern ist. Steigt der AO-Wert deines Moduls bei einer Flamme, setze DROPS_WITH_FLAME einfach auf 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}

Die Schwellen 100 und 400 im Code sind nur ein Ausgangspunkt. Um sie an deinen Sensor anzupassen, lade den Code hoch, öffne den seriellen Monitor und notiere die Flammenstärke, während du ein Feuerzeug in 10, 30 und 60 cm Abstand hältst; wegen des Abstandsquadratgesetzes ändert sich der Wert in der Nähe sehr schnell und in der Ferne langsam. Darum lässt sich aus dem Analogwert keine genaue Entfernung in Zentimetern berechnen: Derselbe Wert kann von einer kleinen nahen oder einer großen fernen Flamme stammen. Wie der ADC den Rohwert erzeugt, erfährst du in Analog-Digital-Wandlung, Feinheiten des seriellen Monitors in Arduino Serial Monitor.

Sonnenlicht und andere Ursachen für Fehlalarme

Ein Flammensensor sieht kein Feuer, sondern Infrarotlicht in einem bestimmten Band, und alles, was in diesem Band Licht abgibt, kann ihn auslösen. Welche Quellen Ärger machen, erklärt das Wiensche Verschiebungsgesetz: Die Wellenlänge, bei der ein heißer Körper am stärksten strahlt, liegt bei etwa 2898 / T Mikrometern (T ist die Temperatur in Kelvin). Sonne und Glühlampen strahlen genau im Band des Sensors stark, der menschliche Körper ist dagegen viel zu kühl, der Sensor sieht dich also überhaupt nicht. Deshalb brauchst du zur Bewegungserkennung einen PIR-Sensor, der viel längere Wellenlängen auswertet.

Die meisten Fehlalarme kannst du mit der Hardware verhindern: Platziere den Sensor so, dass er nicht auf ein Fenster, eine sonnige Wand oder eine Glühlampe zeigt, möglichst nach unten und in den Raum hinein, enge seinen Sichtbereich mit einem schwarzen Röhrchen ein und stelle das Poti bei echtem Umgebungslicht ein. Bedenke, dass starkes Sonnenlicht nicht nur Fehlalarme auslöst, sondern den Sensor auch durch Sättigung blind macht: Ist der AO-Wert in der Sonne schon ganz unten, bleibt nichts mehr übrig, was sich bei einer echten Flamme ändern könnte. Professionelle Infrarot-Flammenmelder lösen das, indem sie das 4,3-µm-Band auswerten, in dem heißes Kohlendioxid strahlt und das Sonnenlicht von der Atmosphäre weitgehend absorbiert wird, mehrere Wellenlängen vergleichen und das Flackern der Flamme analysieren. Dein Modul kann die ersten beiden Punkte nicht, aber Flackeranalyse und Zeitbestätigung kannst du per Software nachbilden.

Fehlalarme per Software verringern: Zeitbestätigung und Flackeranalyse

Eine echte Flamme brennt nie gleichmäßig; Luftströmungen und aufsteigende heiße Gase lassen ihre Helligkeit etwa 1- bis 20-mal pro Sekunde schwanken. Sonnenlicht und das Licht einer Glühlampe sind dagegen über kurze Zeit fast konstant, und die Impulse einer Fernbedienung dauern nur Millisekunden. Der folgende Code nutzt diese Unterschiede mit drei Regeln: Die Flammenstärke muss deutlich über dem Grundwert liegen, der Wert muss in der letzten Sekunde stärker als ein festgelegter Betrag geschwankt haben, und beide Bedingungen müssen mindestens zwei Sekunden ununterbrochen erfüllt sein. Außerdem ist jede Messung der Mittelwert aus 20 Werten, die über 10 ms erfasst werden. Am 50-Hz-Netz flackern Lampen leicht mit 100 Hz; der Mittelwert über 10 ms, also genau eine Flackerperiode, löscht diese Welligkeit aus, sodass eine Lampe nicht für eine flackernde Flamme gehalten wird.

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}

Weil der Code die Zeit mit millis() statt mit delay() misst, misst er auch weiter, während der Alarm läuft; die Details dazu stehen in millis und delay im Vergleich. Auch der Grundwert bleibt nicht fest: Ohne Flamme wandert er einmal pro Sekunde um 5 Prozent in Richtung des neuesten Messwerts und folgt so langsam dem Umgebungslicht im Tagesverlauf. Um einen passenden FLICKER_LIMIT zu finden, beobachte im seriellen Monitor die Schwankung pro Sekunde einer gleichmäßigen Lichtquelle, dann die einer Kerzenflamme, und lege die Schwelle dazwischen. Die Methode ist nicht perfekt; Sonnenlicht, das durch im Wind bewegte Blätter fällt, flackert ebenfalls. Weitere Verfahren wie gleitenden Mittelwert und Medianfilter findest du in Sensordaten filtern.

Kombination mit dem MQ-2-Gassensor

Ein Flammensensor und ein MQ-2-Gassensor gleichen gegenseitig ihre Schwächen aus. Der Flammensensor ist sehr schnell, sieht aber nur Flammen in seinem Sichtbereich und lässt sich von der Sonne täuschen. Der MQ-2 erkennt Rauch und brennbare Gase und bemerkt auch ein Feuer hinter einer Ecke oder einen Schwelbrand ohne Flamme, doch der Rauch braucht Zeit, um ihn zu erreichen, und er muss nach jedem Einschalten vorheizen. Nutzt du beide, kannst du das Signal eines Sensors als Warnung und das gleichzeitige Signal beider als Feuer werten.

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}

Verbinde den AO-Ausgang des MQ-2 mit A1 und versorge das Modul mit 5V; der Flammensensor bleibt an D2. Lege SMOKE_LIMIT deutlich über den Wert, den du nach einigen Minuten in sauberer Luft liest, wie in der MQ-2-Anleitung beschrieben. Die Rauchbedingung wird in den ersten 60 Sekunden ignoriert, weil ein kalter MQ-2 mit einem hohen Wert startet. Die Haltezeit von 300 ms für das Flammensignal (HOLD_MS) macht aus dem kurzen An- und Ausschalten des DO-Ausgangs, das die flackernde Flamme verursacht, eine durchgehende Erkennung. Wenn du diese Kombination auf einen ESP32 überträgst, aufgepasst: Der MQ-2 braucht 5 V und sein AO-Ausgang kann 5 V erreichen, deshalb gehört an seinen Ausgang unbedingt ein Spannungsteiler; der Flammensensor läuft dagegen direkt an 3V3.

Feuer-Benachrichtigung aufs Handy mit dem ESP32 (Telegram)

Damit der Alarm nicht nur die Leute im Raum warnt, sondern auch dich, wenn du unterwegs bist, kannst du einen ESP32 verwenden. Telegram-Bots sind der einfachste Weg: Sie sind kostenlos, brauchen keinen eigenen Server, und die Nachricht kommt sofort als Benachrichtigung auf dem Handy an. Der folgende Code lässt den Buzzer ertönen und schickt eine Telegram-Nachricht, sobald 1,5 Sekunden lang eine Flamme zu sehen war, und wartet zwischen zwei Nachrichten mindestens eine Minute, damit dein Handy beim selben Feuer nicht überflutet wird. Die Einrichtung des Bots und die Steuerung in beide Richtungen per Befehl erklären wir ausführlich in ESP32-Telegram-Bot.

1. Schreibe in Telegram mit @BotFather, sende den Befehl /newbot, gib deinem Bot einen Namen und kopiere den Token, den du erhältst.
2. Öffne einen ID-Bot wie @userinfobot und tippe auf Start; er schickt dir deine eigene Chat-ID.
3. Suche deinen neuen Bot in Telegram und tippe auf Start; sonst kann der Bot dir keine Nachrichten schicken.
4. Installiere in der Arduino IDE über den Bibliotheksverwalter die Bibliotheken UniversalTelegramBot und ArduinoJson.
5. Ersetze WLAN-Name, Passwort, Token und Chat-ID im Code durch deine eigenen Daten, wähle als Board den ESP32 und lade den Code hoch.

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}

Der Aufruf sendMessage() baut eine sichere HTTPS-Verbindung auf und kann deshalb ein bis zwei Sekunden dauern; in dieser Zeit friert das Piepmuster kurz ein, das ist normal. Beim Start versucht der Code bis zu 15 Sekunden lang, sich mit dem WLAN zu verbinden; ohne Verbindung läuft der Alarm lokal weiter, und eine nicht gesendete Nachricht wird eine Minute später erneut versucht, der Buzzer piept also auch ohne Internet. Willst du am ESP32 auch AO auslesen, schließe ihn unbedingt an einen ADC1-Pin (GPIO 32–39) an, denn ADC2-Pins sind bei aktivem WLAN nicht nutzbar; deshalb steht in der Tabelle GPIO 34. Die sicheren Pins deines Boards zeigt dir das Tool Pinout. Klingt ein 5-V-Aktivbuzzer an einem 3,3-V-Pin zu leise, steuere ihn über einen Transistor aus 5 V an. Für eine Garage oder ein Ferienhaus ohne WLAN kannst du denselben Alarm auch mit einem SIM800L-GSM-Modul per SMS melden lassen.

Flammensensor mit Raspberry Pi Pico und MicroPython

Am Raspberry Pi Pico gilt dieselbe Logik. Versorge das Modul über den Pin 3V3(OUT), verbinde DO mit GP15 und, falls vorhanden, AO mit GP26. Das Modul hat auf der DO-Leitung einen eigenen Pull-up-Widerstand, den internen Pull-up des Pico brauchst du also nicht. Der ADC des Pico hat 12 Bit, aber read_u16() skaliert das Ergebnis in MicroPython auf 0–65535; das Gegenstück zu den 1023 des Arduino ist hier also etwa 65535. Der Code nutzt eine Haltezeit von 300 ms, die kurze Lücken an DO überbrückt, und eine Bestätigung von 1,5 Sekunden:

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)

Wenn du den Code in Thonny ausführst, siehst du den AO-Wert und den Alarmzustand im Shell-Fenster; über das Menü Ansicht öffnest du den Plotter und verfolgst die Werte als Grafik. Damit das Programm beim Einschalten des Pico automatisch startet, speichere die Datei auf dem Pico als main.py. Für die Zeitmessung ist time.ticks_diff() wichtig, denn der Zähler von ticks_ms() läuft nach einem bestimmten Wert über, und eine einfache Subtraktion liefert in diesem Moment ein falsches Ergebnis.

Projektideen mit dem Flammensensor

• Feueralarm für die Küche: Baue mit einem auf den Herd gerichteten Flammensensor und einem MQ-2 einen Alarm mit der zweistufigen Logik von oben.
• Herd-vergessen-Warnung: Ist länger als 30 Minuten ununterbrochen eine Flamme zu sehen, ertönt der Buzzer und eine Nachricht geht ans Handy.
• Löschroboter: Finde mit einem 5-Kanal-Sensor die Richtung der Flamme, fahre den Roboter mit L298N und DC-Motoren dorthin und lösche die Kerze mit einer Mini-Wasserpumpe.
• Flammen-Richtungsscanner: Setze einen einzelnen Sensor auf einen Servomotor, schwenke von 0 bis 180 Grad und zeige den Winkel mit dem stärksten Signal an.
• Sicherheitszentrale fürs Smart Home: Vereine Flammen-, Gas- und Bewegungssensoren auf einer Platine; Details in Arduino-Smart-Home-Projekt.
• Werkstattwächter: Taucht in der Nähe der Lötstation unerwartet eine Flamme auf, schaltet ein Relais eine Warnleuchte ein.
• Kerzenlösch-Wettbewerb: Baue wie bei Schul-Roboterwettbewerben einen Roboter, der eine Kerze im Labyrinth möglichst schnell findet und löscht; für den Einstieg reicht ein Flammensensor.

Typische Fehler und ihre Lösungen

Ein Flammensensor ist ein günstiges, aber lehrreiches Bauteil, mit dem du gleichzeitig die Physik des Infrarotlichts, Komparatorschaltungen und den Kampf gegen Fehlalarme kennenlernst. Beginne mit einem einfachen DO-Alarm und verbessere dein System dann Schritt für Schritt mit Analogwerten, Flackeranalyse und einem MQ-2; für ein umfassenderes Sicherheitssystem wirf einen Blick auf Arduino-Alarmanlage. In der BlueGrays-App findest du Projekte zu Flammensensor, Flammen- und Gassensor-Alarm, ESP32-MQ-2-Rauchmelder und ESP32-Alarmanlage mit Telegram-Benachrichtigung, jeweils mit Schritt-für-Schritt-Schaltplänen und fertigem Code.