Feuer und Flamme bei Tageslicht erkennen

Um Feuer mit einen Sensor zu erfassen, wird in den gängigen Feuermelder das Erkennen von Rauch, besser gesagt, das Erkennen des gestreuten Licht genutzt, um Alarm auszulösen.
Umsetzung wird hier für Arduino und Raspberry Pi gezeigt.

In diesem Fall wird das elektromagnetische Spektrum des kalten Feuers mal betrachtet.
Der elektromagnetische Wellenlängenbereich von Feuer umfasst Infrarotstrahlung, sichtbares Licht und kann bei sehr heißen Feuern auch ultraviolette Strahlung beinhalten. Die genaue Verteilung der Wellenlängen hängt von der Temperatur des Feuers, der Zusammensetzung des Brennstoffs und der Menge des Sauerstoffs ab.
Beispiele:

Ein Holzfeuer: emittiert hauptsächlich Infrarotstrahlung und etwas sichtbares Licht im roten und orangen Bereich.

Ein Gasfeuer: emittiert mehr sichtbares Licht, insbesondere im blauen Bereich, da die Verbrennungstemperatur höher ist.

Eine Magnesiumfackel: emittiert aufgrund der hohen Verbrennungstemperatur neben sichtbarem Licht auch kurzwellige ultraviolette Strahlung.

Der KY-026 ist ein Flammensensor-Modul, das zur Erkennung von offenen Flammen verwendet wird. Hier sind die Hauptkomponenten und Funktionsweise:

1. Fotodiode: Der Sensor enthält eine Fotodiode, die besonders empfindlich auf Infrarotstrahlung (IR) im Wellenlängenbereich von etwa 760nm bis 1100nm ist, die von Flammen emittiert wird
2. Komparator: Ein LM393-Komparator auf dem Modul vergleicht den gemessenen Wert der Fotodiode mit einem am Potentiometer eingestellten Schwellenwert
3. Digitaler und analoger Ausgang:
   • Der digitale Ausgang gibt ein High-Signal aus, wenn der Schwellenwert überschritten wird.
   • Der analoge Ausgang liefert den direkten Messwert der Fotodiode

Anschluss und Nutzung mit Arduino

• Anschlüsse:
  • VCC: 5V
  • GND: Masse
  • D0: Digitaler Ausgang
  • A0: Analoger Ausgang

int analogPin = A0; // Analoger Ausgang des Sensors
int digitalPin = 3; // Digitaler Ausgang des Sensors

void setup() {
  pinMode(analogPin, INPUT);
  pinMode(digitalPin, INPUT);
  Serial.begin(9600);
}

void loop() {
  float analogValue = analogRead(analogPin) * (5.0 / 1023.0);
  int digitalValue = digitalRead(digitalPin);
  Serial.print("Analog: ");
  Serial.println(analogValue);
  Serial.print("Digital: ");
  Serial.println(digitalValue);
  delay(1000);
}

Mit diesem Code kannst du die analogen und digitalen Signale des Sensors auslesen und auf der seriellen Konsole anzeigen lassen

Erweiterter Code ohne seriellen monitor, aber mit blau – rot blinkenden LED´s und nur Auswertung des digitalen Ausgang:

int digitalPin = 3; // Digitaler Ausgang des Sensors

void setup() {
  pinMode(digitalPin, INPUT);
  pinMode(8, OUTPUT);
  pinMode(12, OUTPUT);
}

void loop() {
  int digitalValue = digitalRead(digitalPin);

  if (digitalValue == LOW) {
    // Feuer erkannt, LEDs abwechselnd blinken lassen
    digitalWrite(8, HIGH);
    digitalWrite(12, LOW);
    delay(500);
    digitalWrite(8, LOW);
    digitalWrite(12, HIGH);
    delay(500);
  } else {
    // Keine Flamme erkannt, LEDs ausschalten
    digitalWrite(8, LOW);
    digitalWrite(12, LOW);
  }

  delay(1000); // Wartezeit zwischen den Messungen
}

Umsetzung mit einem Raspberry Pi:

Da bei einem Raspberry kein analoger Eingang vorhanden ist, wird das digitale Signal zum auslösen verwendet. Als Variante ändere ich die LED durch einen Buzzer.

Benötigte Komponenten:

• Raspberry Pi
• KY-026 Flammensensor
• aktiver Buzzer
• Breadboard und Jumper-Kabel

1. Verbindungen herstellen:
   • Verbinde den VCC-Pin des KY-026 mit dem 5V-Pin des Raspberry Pi.
   • Verbinde den GND-Pin des KY-026 mit einem GND-Pin des Raspberry Pi.
   • Verbinde den digitalen Ausgang (D0) des KY-026 mit dem GPIO-Pin 24 des Raspberry Pi
   • Verbinde den Buzzer mit dem GPIO-Pin 18 des Raspberry Pi. Auf das plus Zeichen des Aufklebers achten. Und Minus mit GND

Code:

Hier ist ein einfaches Python-Skript, um den Flammensensor zu überwachen und den Buzzer auszulösen, wenn eine Flamme erkannt wird:

import RPi.GPIO as GPIO
import time

# GPIO-Modus (BOARD / BCM)
GPIO.setmode(GPIO.BCM)

# Pins definieren
FLAME_SENSOR_PIN = 24
BUZZER_PIN = 18

# Pins als Input/Output setzen
GPIO.setup(FLAME_SENSOR_PIN, GPIO.IN)
GPIO.setup(BUZZER_PIN, GPIO.OUT)

try:
    while True:
        if GPIO.input(FLAME_SENSOR_PIN):            
            GPIO.output(BUZZER_PIN, GPIO.LOW)
        else:
            print("Flamme erkannt!")
            GPIO.output(BUZZER_PIN, GPIO.HIGH)
        time.sleep(0.1)
except KeyboardInterrupt:
    print("Programm beendet")
finally:
    GPIO.cleanup()

Ich habe den Code mit dem Editor Mousepad erstellt und gespeichert als flammeerkennen.py.

Im Terminal dann gestartet mit python3 flammeerkennen.py

Fazit: Ich könnte mir vorstellen das dieser Flammensensor ergänzend in bestimmten Anwendungen als Teil eines Feuermeldersystems eine Verwendung findet. Aber er allein wird nicht meine smarten Rauchmelder ersetzen.

Video: