Arduino UNO Q - Flammen Sensor
Ein Flammen Sensor erkennt Infrarotstrahlung von Feuer und gibt sowohl ein digitales Signal (Flamme/keine Flamme) als auch ein analoges Signal (Flammenintensität) aus. Auf Arduino UNO Q gibt der 12-Bit-ADC feinere Intensitätsmessungen. Mit Bridge und Telegram erhalten Sie sofortige Feueralarmbenachrichtigungen auf Ihrem Telefon.
In diesem Tutorial erfahren Sie:
- Was ein Flammen Sensor ist und wie er funktioniert
- Wie Sie den Flammen Sensor mit der Arduino UNO Q MCU verkabeln
- Wie Sie beide digitalen (DO) und analogen (AO) Ausgänge lesen
- Wie Sie Bridge verwenden, um den Flammenzustand und Ereignisse der Linux-Seite (Python) freizulegen
- Wie Sie dringende Telegram-Feueralarmbenachrichtigungen vom Arduino UNO Q Flammen Sensor erhalten
- Wie Sie OpenClaw auf Arduino UNO Q mit dem Flammen Sensor verwenden
※ Notiz:
Der Flammen Sensor erkennt Infrarotstrahlung. Verwenden Sie ihn zur Frühbranderkennung und als Teil eines Sicherheitssystems – kombinieren Sie ihn immer mit ordnungsgemäßen Feueralarmmeldern und Sicherheitsausrüstung. Verlassen Sie sich niemals nur auf diesen Sensor für Anwendungen mit Lebenssicherheit.
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Über den Flammen Sensor
Der Flammen Sensor enthält eine Infrarot-Fotodiode, die für die spezifischen Infrarotwellenlängen empfindlich ist, die von Flammen erzeugt werden. Es enthält ein Onboard-Potentiometer zum Einstellen der digitalen Erkennungsschwelle.
Pinbelegung
- VCC-Pin: 3,3V bis 5V Stromversorgung
- GND-Pin: Masse
- DO-Pin: Digitaler Ausgang — HIGH = keine Flamme, LOW = Flamme erkannt. Die Empfindlichkeit wird durch das Onboard-Potentiometer eingestellt.
- AO-Pin: Analoger Ausgang — höherer Wert = mehr Infrarot/Flamme, niedrigerer Wert = weniger Flamme
LED-Indikatoren
- PWR-LED: Stromanzeige
- DO-LED: Leuchtet auf, wenn Flamme erkannt wird (DO-Pin LOW)
Wie es funktioniert
- DO-Pin: Das Potentiometer setzt eine Schwelle. Wenn die Infrarotstufe die Schwelle überschreitet, wird DO LOW (Flamme erkannt). Stellen Sie das Potentiometer so ein, dass die DO-LED zuverlässig in der Nähe einer Flamme auslöst.
- AO-Pin: Gibt eine kontinuierliche analoge Spannung proportional zur Infrarotintensität aus. Auf Arduino UNO Q wird dies als 12-Bit-Wert (0–4095) gelesen – höhere Werte bedeuten mehr Infrarot/Flamme.
※ Notiz:
Flammen Sensoren reagieren auf jede starke Infrarotquelle, nicht nur auf Feuer. Starkes Sonnenlicht oder Infrarot-LEDs können den Sensor auch auslösen. Schirmen Sie den Sensor vor direktem Sonnenlicht ab, um Fehlalarme zu vermeiden.
Schaltungsschema
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
| Flammen Sensor Pin | Arduino UNO Q MCU |
|---|---|
| VCC | 5V |
| GND | GND |
| DO | D2 |
| AO | A0 |
Programmierung für Flammen Sensor
- Konfigurieren Sie den DO-Pin als digitalen Eingang:
pinMode(DO_PIN, INPUT);
- Lesen Sie beide Ausgänge:
int do_state = digitalRead(DO_PIN); // HIGH = no flame, LOW = flame
int ao_value = analogRead(AO_PIN); // 0-4095, higher = more flame
- Überprüfen Sie auf Flamme vom digitalen Ausgang:
if (do_state == LOW) {
Serial.print("FLAME DETECTED! Intensity (AO): ");
Serial.println(ao_value);
}
Arduino UNO Q Code
Arduino UNO Q hat zwei Prozessoren, die zusammenarbeiten:
- Die STM32 MCU liest alle 500 ms sowohl DO als auch AO Ausgänge vom Flammen Sensor
- Die Qualcomm MPU führt Debian Linux mit Wi-Fi aus – in diesem Abschnitt wird nur die MCU programmiert. Ein späterer Abschnitt zeigt, wie beide Prozessoren über Bridge zusammenarbeiten.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-flame-sensor
*/
// Flame sensor:
// DO pin: HIGH = no flame, LOW = flame detected
// AO pin: analog — higher value = more infrared/flame (12-bit ADC: 0-4095)
#define DO_PIN 2 // The Arduino UNO Q MCU pin connected to DO of the flame sensor
#define AO_PIN A0 // The Arduino UNO Q MCU pin connected to AO of the flame sensor
void setup() {
Serial.begin(9600);
pinMode(DO_PIN, INPUT);
Serial.println("Arduino UNO Q Flame Sensor ready");
}
void loop() {
int do_state = digitalRead(DO_PIN); // HIGH = no flame, LOW = flame
int ao_value = analogRead(AO_PIN); // 0-4095, higher = more flame
if (do_state == LOW) {
Serial.print("FLAME DETECTED! Intensity (AO): ");
Serial.println(ao_value);
} else {
Serial.print("No flame. AO value: ");
Serial.println(ao_value);
}
delay(500);
}
Schnelle Schritte
Erste Zeit mit Arduino UNO Q? Folgen Sie zunächst dem Tutorial Erste Schritte mit Arduino UNO Q.
- Verbinden: Verkabeln Sie den Flammen Sensor mit der Arduino UNO Q MCU wie im Schaltungsschema gezeigt.
- Öffnen Sie Arduino App Lab: Starten Sie Arduino App Lab und warten Sie, bis es Ihre Arduino UNO Q erkennt.
- Erstellen Sie eine neue App: Klicken Sie auf die Schaltfläche Create New App.
- Geben Sie der App einen Namen, z.B.: FlameSensor
- Klicken Sie auf Create, um zu bestätigen.
- Fügen Sie die Skizze ein: Kopieren Sie den MCU-Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Hochladen: Klicken Sie auf die Run-Schaltfläche in Arduino App Lab.
- Richten Sie den Flammen Sensor auf eine Kerzenflamme – beobachten Sie die Serial Monitor-Ausgabe.
- Passen Sie das Potentiometer auf dem Modul an, wenn der DO-Pin nicht richtig reagiert.
App Lab Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Arduino UNO Q Flame Sensor ready
[2026-04-29 09:00:02] No flame. AO value: 45
[2026-04-29 09:00:03] No flame. AO value: 48
[2026-04-29 09:00:04] FLAME DETECTED! Intensity (AO): 2156
[2026-04-29 09:00:05] FLAME DETECTED! Intensity (AO): 2843
[2026-04-29 09:00:06] FLAME DETECTED! Intensity (AO): 3102
[2026-04-29 09:00:07] No flame. AO value: 51
Bridge: Linux + MCU
Dieser Abschnitt zeigt, wie Sie beide Prozessoren des Arduino UNO Q programmieren, damit die Linux-Seite den Flammenzustand lesen und Ereignisse über Bridge empfangen kann:
- Der Flammen Sensor ist mit der MCU verbunden – die MCU liest alle 500 ms DO und AO aus und speichert die Werte
- Die MPU kann die Sensorstifte nicht direkt lesen – sie ruft Bridge-Funktionen auf, um den Status, Intensitätswert oder Ereignisse zu erhalten
- Die MPU hat Wi-Fi – Debian Linux ausgeführt, kann es in dem Moment, in dem eine Flamme erkannt wird, dringende Telegram-Feueralarmbenachrichtigungen senden
- Arduino_RouterBridge ermöglicht RPC-Kommunikation zwischen den beiden Prozessoren
- ⚠️ /dev/ttyHS1 (Linux) und Serial1 (MCU) sind RESERVIERT durch den Router – öffnen Sie sie nie in Benutzercode
MCU Code (Bridge)
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-flame-sensor
*/
#include "Arduino_RouterBridge.h"
#define DO_PIN 2 // The Arduino UNO Q MCU pin connected to DO of the flame sensor
#define AO_PIN A0 // The Arduino UNO Q MCU pin connected to AO of the flame sensor
// Cached values
bool cached_flame = false;
int cached_ao = 0;
bool flame_event = false;
bool prev_flame = false;
unsigned long last_read_ms = 0;
const unsigned long READ_INTERVAL = 500;
String get_state(String arg) {
return cached_flame ? "flame" : "no_flame";
}
String get_value(String arg) {
return String(cached_ao);
}
String get_event(String arg) {
if (flame_event) {
flame_event = false;
return "flame_detected";
}
return "none";
}
void setup() {
Bridge.begin();
Monitor.begin();
pinMode(DO_PIN, INPUT);
Bridge.provide("get_state", get_state);
Bridge.provide("get_value", get_value);
Bridge.provide("get_event", get_event);
Monitor.println("Arduino UNO Q Flame Sensor Bridge ready");
}
void loop() {
unsigned long now = millis();
if (now - last_read_ms >= READ_INTERVAL) {
last_read_ms = now;
int do_state = digitalRead(DO_PIN); // LOW = flame
cached_ao = analogRead(AO_PIN);
cached_flame = (do_state == LOW);
if (cached_flame && !prev_flame) {
flame_event = true;
Monitor.print("FLAME DETECTED! AO value: ");
Monitor.println(cached_ao);
} else if (!cached_flame && prev_flame) {
Monitor.println("Flame gone. No flame detected.");
}
prev_flame = cached_flame;
}
}
Python Code (Bridge)
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-flame-sensor
*/
from arduino.app_utils import *
import time
def loop():
state = Bridge.call("get_state")
value = Bridge.call("get_value")
print(f"Flame state: {state} AO value: {value}")
time.sleep(0.5)
App.run(user_loop=loop)
Schnelle Schritte
- Verbinden: Verkabeln Sie den Flammen Sensor mit der Arduino UNO Q wie im Schaltungsschema gezeigt.
- Öffnen Sie Arduino App Lab und erstellen Sie eine neue App mit dem Namen FlameSensorBridge.
- Fügen Sie die MCU-Skizze in sketch/sketch.ino ein.
- Fügen Sie den Python-Code in die Python-Datei ein.
- Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.
- Search for Arduino_RouterBridge created by Arduino and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Hochladen: Klicken Sie auf die Run-Schaltfläche.
- Richten Sie den Sensor auf eine Kerze – beobachten Sie das Flammenereignis in beiden Konsolen.
App Lab Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Arduino UNO Q Flame Sensor Bridge ready
[2026-04-29 09:00:06] FLAME DETECTED! AO value: 2843
[2026-04-29 09:00:10] Flame gone. No flame detected.
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:02] Flame state: no_flame AO value: 48
[2026-04-29 09:00:04] Flame state: no_flame AO value: 50
[2026-04-29 09:00:06] Flame state: flame AO value: 2843
[2026-04-29 09:00:08] Flame state: flame AO value: 3102
[2026-04-29 09:00:10] Flame state: no_flame AO value: 49
Telegram
Erhalten Sie sofortige Telegram-Feueralarmbenachrichtigungen vom Arduino UNO Q Flammen Sensor und fragen Sie den Flammenzustand aus der Ferne ab.
MCU-Skizze: Behalten Sie die gleiche MCU-Skizze aus dem vorherigen Bridge-Abschnitt.
Python Code (Telegram)
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-flame-sensor
*/
from arduino.app_utils import *
import requests
import time
TELEGRAM_BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"
CHAT_ID = "YOUR_CHAT_ID"
last_update_id = 0
def get_updates():
global last_update_id
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/getUpdates"
params = {"offset": last_update_id + 1, "timeout": 5}
try:
response = requests.get(url, params=params, timeout=10)
data = response.json()
if data["ok"]:
return data["result"]
except Exception as e:
print(f"Error getting updates: {e}")
return []
def send_message(chat_id, text):
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
payload = {"chat_id": chat_id, "text": text}
try:
requests.post(url, data=payload, timeout=10)
except Exception as e:
print(f"Error sending message: {e}")
def loop():
# Auto-alert on flame detection
event = Bridge.call("get_event")
if event == "flame_detected":
value = Bridge.call("get_value")
print(f"FLAME DETECTED! AO value: {value}")
send_message(CHAT_ID, f"🔥 FLAME DETECTED! Intensity (AO): {value}")
# Handle Telegram commands
updates = get_updates()
for update in updates:
last_update_id = update["update_id"]
if "message" not in update:
continue
message = update["message"]
chat_id = message["chat"]["id"]
text = message.get("text", "").strip()
print(f"Received: {text}")
if text == "/start":
send_message(chat_id,
"Arduino UNO Q Flame Sensor Bot\n"
"/state - Current state (flame / no_flame)\n"
"/value - Read analog intensity (0-4095)\n"
"Automatic alert when flame is detected!")
elif text == "/state":
result = Bridge.call("get_state")
send_message(chat_id, f"Flame state: {result}")
elif text == "/value":
result = Bridge.call("get_value")
send_message(chat_id, f"AO intensity value: {result}")
else:
send_message(chat_id, "Unknown command. Send /start for help.")
time.sleep(0.3)
App.run(user_loop=loop)
Schnelle Schritte
- Ersetzen Sie YOUR_TELEGRAM_BOT_TOKEN durch Ihr tatsächliches Bot-Token von BotFather.
- Ersetzen Sie YOUR_CHAT_ID durch Ihre Telegram-Chat-ID.
- Fügen Sie diesen Python-Code in die Python-Datei Ihrer App ein (behalten Sie die gleiche MCU-Skizze).
- Klicken Sie auf die Run-Schaltfläche – richten Sie den Sensor auf eine Flamme, um die Telegram-Warnung zu erhalten.
App Lab Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:10:00] Waiting for Telegram messages...
[2026-04-29 09:10:06] FLAME DETECTED! AO value: 2843
[2026-04-29 09:10:12] Received: /state
[2026-04-29 09:10:15] Received: /value
Telegram
12:45
Welcome to Telegram!
ArduinoBot
10:19
Chatting with Arduino...
BotFather
Yesterday
Your bot has been created.
ArduinoBot
bot
OpenClaw
You can adapt the OpenClaw to this tutorial by refering the instruction on Arduino Uno Q - OpenClaw Tutorial
Projektideen
Sie können viele nützliche Projekte mit dem Flammen Sensor und Arduino UNO Q bauen:
- Feueralarm-System: Montieren Sie den Flammen Sensor in einer Küche oder Werkstatt – wenn eine Flamme erkannt wird, sendet die MPU eine dringende Telegram-Warnung mit dem AO-Intensitätswert, damit Sie von überall aus sofort handeln können
- Automatische Brandbekämpfung: Verbinden Sie den Flammen Sensor mit einem Relais-gesteuerten Magnetventil – wenn eine Flamme erkannt wird, öffnet die MCU das Ventil, um Wasser oder Löschmittel freizusetzen, und Python sendet eine Telegram-Benachrichtigung
- Kerzenüberwachung: Platzieren Sie den Sensor in der Nähe einer Kerze in einem unbeaufsichtigten Raum – erhalten Sie eine Telegram-Warnung, wenn die Kerze nach einer bestimmten Zeit noch brennt, oder wenn unerwartet eine neue Flamme auftaucht
- Flammenintensitäts-Protokollierung: Protokollieren Sie AO-Werte und Zeitstempel in eine CSV auf Linux, wenn eine Flamme erkannt wird – senden Sie einen täglichen Telegram-Bericht mit einer Zusammenfassung der Flammenereignisse mit Startzeit, Endzeit und Spitzenintensität
- Multi-Sensor-Brandschutzsystem: Kombinieren Sie den Flammen Sensor mit dem Gassensor-Tutorial – wenn beide gleichzeitig Gefahr erkennen, senden Sie eine "FIRE + GAS LEAK"-Telegram-Warnung und aktivieren Sie einen akustischen Alarm über Relais
Fordern Sie sich selbst heraus
Bereit, noch weiter mit dem Flammen Sensor auf Arduino UNO Q zu gehen? Probieren Sie diese Herausforderungen:
- Einfach: Fügen Sie einen /history-Telegram-Befehl hinzu, der die letzten 5 Flammenereignisse mit Zeitstempeln und Spitzenintensitätswerten aus einer Python-Liste zurückgibt.
- Mittel: Implementieren Sie einen Falschalarmfilter: Die Flamme muss für mindestens 3 aufeinanderfolgende Lesevorgänge (1,5 Sekunden) erkannt werden, bevor die MPU eine Telegram-Warnung sendet – dies verhindert einzelne Fehlalarme von hellen Lichtern.
- Fortgeschritten: Erstellen Sie ein Multi-Zone-Brandüberwachungssystem mit zwei Flammen Sensoren auf verschiedenen digitalen Pins – legen Sie separate Bridge-Funktionen für jede Zone frei, und Telegram-Warnungen, die angeben, welche Zone die Flamme mit individuellen Intensitätsmessungen erkannt hat.