Arduino UNO Q - Capteur de Flamme
Un capteur de flamme détecte les rayonnements infrarouges du feu et produit un signal numérique (flamme/pas de flamme) et un signal analogique (intensité de la flamme). Sur Arduino UNO Q, l'ADC 12 bits donne des lectures d'intensité plus fines. Avec Bridge et Telegram, vous recevez des alertes d'incendie instantanées sur votre téléphone.
Dans ce tutoriel, vous apprendrez :
- Ce qu'est un capteur de flamme et comment il fonctionne
- Comment câbler le capteur de flamme sur le MCU Arduino UNO Q
- Comment lire les sorties numérique (DO) et analogique (AO)
- Comment utiliser Bridge pour exposer l'état de la flamme et les événements au côté Linux (Python)
- Comment recevoir des alertes urgentes d'incendie depuis le capteur de flamme Arduino UNO Q via Telegram
- Comment utiliser OpenClaw sur Arduino UNO Q avec le capteur de flamme
※ Note:
Le capteur de flamme détecte les rayonnements infrarouges. Utilisez-le pour la détection précoce d'incendie et comme partie d'un système de sécurité — associez-le toujours à des alarmes incendie appropriées et des équipements de sécurité. Ne vous fiez jamais à ce seul capteur pour des applications de sécurité vitale.
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
À Propos du Capteur de Flamme
Le capteur de flamme contient une photodiode infrarouge sensible aux longueurs d'onde infrarouges spécifiques produites par les flammes. Il comprend un potentiomètre intégré pour ajuster le seuil de détection numérique.
Brochage
- Broche VCC : Alimentation 3,3V à 5V
- Broche GND : Masse
- Broche DO : Sortie numérique — HIGH = pas de flamme, LOW = flamme détectée. La sensibilité est réglée par le potentiomètre intégré.
- Broche AO : Sortie analogique — valeur plus élevée = plus d'infrarouge/flamme, valeur plus faible = moins de flamme
Indicateurs LED
- PWR-LED : Indicateur d'alimentation
- DO-LED : S'allume quand une flamme est détectée (broche DO LOW)
Fonctionnement
- Broche DO : Le potentiomètre définit un seuil. Quand le niveau infrarouge dépasse le seuil, DO passe à LOW (flamme détectée). Ajustez le potentiomètre jusqu'à ce que la DO-LED se déclenche de façon fiable près d'une flamme.
- Broche AO : Produit une tension analogique continue proportionnelle à l'intensité infrarouge. Sur Arduino UNO Q, cela est lu comme une valeur 12 bits (0–4095) — des valeurs plus élevées signifient plus d'infrarouge/flamme.
※ Note:
Les capteurs de flamme répondent à toute source infrarouge puissante, pas seulement au feu. La lumière solaire directe ou les LED infrarouges peuvent aussi déclencher le capteur. Protégez le capteur de la lumière solaire directe pour éviter les fausses alarmes.
Schéma de Câblage
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
| Broche Capteur de Flamme | MCU Arduino UNO Q |
|---|---|
| VCC | 5V |
| GND | GND |
| DO | D2 |
| AO | A0 |
Comment Programmer pour le Capteur de Flamme
- Configurez la broche DO comme entrée numérique :
pinMode(DO_PIN, INPUT);
- Lisez les deux sorties :
int do_state = digitalRead(DO_PIN); // HIGH = pas de flamme, LOW = flamme
int ao_value = analogRead(AO_PIN); // 0-4095, plus élevé = plus de flamme
- Vérifiez la flamme depuis la sortie numérique :
if (do_state == LOW) {
Serial.print("FLAMME DÉTECTÉE! Intensité (AO): ");
Serial.println(ao_value);
}
Code Arduino UNO Q
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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);
}
Étapes Rapides
Première utilisation de l'Arduino UNO Q ? Suivez le tutoriel Démarrer avec Arduino UNO Q avant de continuer.
- Connecter : Câblez le capteur de flamme sur le MCU Arduino UNO Q comme indiqué dans le schéma de câblage.
- Ouvrir Arduino App Lab : Créez une nouvelle application nommée FlameSensor.
- Coller le programme : Collez le code MCU dans sketch/sketch.ino.
- 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
- Téléverser : Cliquez sur le bouton Exécuter dans Arduino App Lab.
- Tenez une bougie ou un briquet allumé à proximité du capteur (avec précaution) pour tester la détection.
Sortie de la Console App Lab
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] AO: 120 DO: No Flame
[2026-04-29 09:00:04] AO: 3200 DO: FLAME DETECTED!
Bridge : Linux + MCU
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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;
}
}
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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)
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Flame Sensor Bridge ready
[2026-04-29 09:00:02] AO: 120 DO: No Flame
[2026-04-29 09:00:04] AO: 3200 DO: FLAME DETECTED!
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:02] No flame. AO: 120
[2026-04-29 09:00:04] 🔥 FLAME DETECTED! AO: 3200
Telegram
Recevez des alertes d'incendie urgentes via Telegram dès qu'une flamme est détectée.
Programme MCU : Conservez le même programme MCU de la section Bridge précédente.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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)
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Monitoring for flames...
[2026-04-29 09:00:05] 🔥 FLAME DETECTED! Intensity: 3200
Telegram
12:45
Welcome to Telegram!
ArduinoBot
10:19
Chatting with Arduino...
BotFather
Yesterday
Your bot has been created.
ArduinoBot
bot
Intégration d'OpenClaw
Vous pouvez adapter OpenClaw à ce tutoriel en vous référant aux instructions du tutoriel Arduino UNO Q - OpenClaw.
Idées de Projets
- Système d'Alarme Incendie : Déclenchez une sirène ou envoyez une alerte Telegram urgente dès qu'une flamme est détectée dans une pièce surveillée
- Détection de Barbecue : Montez le capteur au-dessus d'un barbecue pour surveiller si le feu est allumé et envoyer une notification quand les braises s'éteignent
- Surveillance de Cheminée : Détectez si la cheminée brûle activement et alertez via Telegram si elle s'éteint inopinément
- Protection de Laboratoire : Installez dans un laboratoire de chimie pour une détection précoce d'incendie avec alertes instantanées
Mettez-Vous au Défi
- Facile : Ajoutez un buzzer qui sonne quand une flamme est détectée (en parallèle avec l'alerte Telegram).
- Moyen : Ajoutez une commande /seuil <valeur> sur Telegram pour ajuster le seuil de détection analogique à distance.
- Avancé : Combinez avec un capteur de gaz MQ2 pour une alarme de sécurité combinée incendie + gaz avec journalisation dans un fichier Linux.