Capteur de flamme Arduino : câblage, code et alarme incendie

Un capteur de flamme est un module bon marché qui détecte la lumière infrarouge émise par un briquet, une bougie ou un papier en feu, et tu peux l'utiliser avec un Arduino en quelques lignes de code. Pour utiliser un capteur de flamme avec Arduino, aucune bibliothèque n'est nécessaire : la broche DO du module change d'état quand elle voit une flamme, et la broche AO des versions à 4 broches fournit une tension qui varie avec l'intensité de la flamme. C'est l'un des capteurs les plus utilisés pour les alarmes incendie, les robots pompiers, les systèmes de sécurité pour la cuisine et les projets scolaires.

Dans ce guide, tu vas découvrir ce que contient un capteur de flamme et pourquoi il ne réagit qu'à la lumière entre 760 et 1100 nm, ce qui distingue la sortie numérique de la sortie analogique, comment régler correctement le potentiomètre de sensibilité, ainsi que sa portée et son angle de détection. Ensuite, tu construiras une alarme incendie avec un buzzer et une LED, tu associeras le capteur à un capteur de gaz MQ-2, tu réduiras par logiciel les fausses alarmes causées par le soleil ou les télécommandes, tu enverras une notification Telegram sur ton téléphone avec un ESP32 et tu feras tourner le même montage sur un Raspberry Pi Pico en MicroPython.

Qu'est-ce qu'un capteur de flamme et comment fonctionne-t-il ?

La pièce noire qui ressemble à une LED au bout du module est en réalité un phototransistor infrarouge (une photodiode sur certaines cartes) ; le YG1006 en est un exemple courant. Son boîtier en époxy noir filtre l'essentiel de la lumière visible et ne laisse passer que le proche infrarouge, entre environ 760 et 1100 nm, avec une sensibilité maximale vers 940 nm. La limite haute vient du silicium lui-même : avec une bande interdite de 1,12 eV, le silicium ne peut pas absorber les photons de longueur d'onde supérieure à environ 1100 nm. Comme les particules de suie chaude d'une flamme rayonnent aussi dans cette bande, le courant qui traverse le phototransistor augmente à mesure que la flamme s'approche. Un pont diviseur sur la carte transforme ce courant en tension, et le comparateur LM393 la compare au seuil que tu règles avec le potentiomètre pour fixer l'état de la broche DO.

Il existe plusieurs cartes de capteur de flamme qui font le même travail. Les modules à 3 broches, comme celui de la photo, n'ont qu'une sortie numérique ; les modules à 4 broches ajoutent une sortie analogique. Le KY-026, que tu connais peut-être grâce aux kits de capteurs, fonctionne de la même façon, mais sa sortie DO est souvent inversée. Les robots pompiers utilisent des cartes multicanaux avec cinq récepteurs disposés en éventail. Un capteur de flamme est passif, il n'émet donc aucune lumière ; c'est ce qui le distingue du capteur infrarouge TCRT5000, qui possède un émetteur et un récepteur.

Différence entre la sortie numérique (DO) et la sortie analogique (AO)

La broche DO donne une réponse oui/non : elle change d'état lorsque la lumière infrarouge dépasse le seuil que tu as réglé avec le potentiomètre. Sur les cartes bleues courantes, cette broche est normalement à HIGH, passe à LOW en présence d'une flamme et la LED DO s'allume ; sur certaines cartes comme le KY-026, c'est l'inverse. Commence donc par tester ton module avec un briquet et regarde dans le moniteur série quelle valeur tu lis. La broche AO fournit le signal brut. Sur la plupart des modules, cette valeur diminue quand la flamme s'approche : une lecture analogRead de 900–1020 dans une pièce sans flamme peut descendre à quelques centaines avec un briquet tout proche. Le potentiomètre ne modifie que le seuil de DO et n'a aucun effet sur AO.

Comment régler le potentiomètre de sensibilité

1. Alimente le module et place le capteur à l'endroit où il travaillera, orienté vers la zone à surveiller ; fais toujours ce réglage dans l'environnement réel.
2. Sans aucune flamme, tourne le potentiomètre bleu avec un petit tournevis et trouve le point où la LED DO bascule entre allumée et éteinte.
3. À partir de ce point, tourne encore d'un demi-tour à un tour dans le sens où la LED reste éteinte. Ainsi, les petites variations de lumière ambiante ne déclencheront pas l'alarme.
4. Tiens un briquet en direction du capteur à la plus grande distance que tu veux détecter et vérifie que la LED s'allume. Sinon, augmente très légèrement la sensibilité et recommence.
5. Vérifie que le capteur n'est pas tourné vers une fenêtre ensoleillée ou une ampoule à incandescence, puis contrôle à nouveau le réglage quelques heures plus tard sous un autre éclairage.

Portée et angle de détection

Les valeurs comme 80 cm données par les fabricants concernent une flamme de briquet ordinaire ; la portée réelle dépend de la taille de la flamme, du réglage du potentiomètre et de la lumière ambiante. Une loi physique simple s'applique ici : l'intensité lumineuse d'une petite source diminue avec le carré de la distance. Si tu doubles la distance, la lumière infrarouge qui atteint le capteur tombe au quart. Inversement, tu détecteras une flamme quatre fois plus lumineuse à une distance deux fois plus grande, et une flamme cent fois plus puissante à une distance dix fois plus grande. C'est pourquoi une flamme de bougie est détectée de moins loin qu'un briquet, alors qu'un tas de papier en feu l'est à plusieurs mètres.

L'angle de détection est d'environ 60 degrés : le capteur voit donc les flammes dans un cône d'environ 30 degrés de part et d'autre de son axe, et le signal faiblit rapidement quand la flamme se rapproche du bord de ce cône. Le récepteur a de longues pattes, tu peux donc le plier délicatement dans la direction voulue, mais plier sans cesse l'endroit où les pattes entrent dans le boîtier finit par les casser. Pour réduire le champ de vision, glisse un tube noir mat sur le récepteur : un tube de 6 mm de diamètre intérieur et de 2 cm de long ramène l'angle à environ 30 degrés et bloque la lumière du soleil ou des lampes venant de côté. Le champ de vision doit être juste assez large pour couvrir la zone à surveiller ; au-delà, il n'apporte que de nouvelles sources de fausses alarmes.

Branchement du capteur de flamme : Arduino Uno, ESP32 et Pico

Pas à pas : alarme incendie avec capteur de flamme et Arduino

1. Relie la broche VCC du module à la broche 5V de l'Arduino, GND à GND et DO à D2.
2. Relie la patte longue (+) du buzzer actif à D8 et la patte courte à GND.
3. Relie la patte longue de la LED rouge à D7 à travers une résistance de 220 Ω et la patte courte à GND. Pour une autre LED, tu peux calculer la résistance avec le calculateur de résistance pour LED.
4. Téléverse le code ci-dessous, ouvre le moniteur série à 9600 bauds et approche brièvement un briquet du capteur à 20–30 cm.
5. Si le buzzer sonne et que la LED s'allume, le montage fonctionne ; si l'alarme sonne sans flamme et se tait en présence d'une flamme, passe FLAME_ACTIVE à HIGH dans le code.

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}

À chaque passage, le code lit la broche DO et compare le résultat à la constante FLAME_ACTIVE. Grâce à elle, le même code fonctionne avec les modules bleus qui donnent LOW en présence d'une flamme et avec le KY-026 qui donne HIGH. Tant qu'une flamme est visible, la LED reste allumée et le buzzer s'active et se coupe toutes les 150 ms pour produire un bip intermittent qui attire l'attention. Un buzzer actif possède son propre oscillateur et n'a besoin que de HIGH et LOW ; si tu as un buzzer passif, utilise tone() au lieu de digitalWrite, comme expliqué dans qu'est-ce qu'un buzzer. Il y a une autre raison de brancher DO sur D2 : sur l'Uno, D2 fait partie des deux broches qui gèrent les interruptions, tu peux donc capter la flamme avec attachInterrupt sans attendre la fin de la boucle.

Lecture analogique : intensité de la flamme et distance approximative

Avec un module à 4 broches, la sortie AO permet d'aller beaucoup plus loin. Comme la valeur brute change d'un environnement à l'autre, utilise cette méthode plutôt qu'un seuil fixe : au démarrage, sans flamme, mesure une valeur de référence (baseline), puis regarde de combien chaque nouvelle mesure s'en écarte. Le code suivant fait la moyenne de 16 mesures pour réduire le bruit, calcule l'écart comme force de la flamme et indique grossièrement si la flamme est proche ou lointaine. Si la valeur AO de ton module augmente avec la flamme, il suffit de mettre DROPS_WITH_FLAME à 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}

Les seuils de 100 et 400 du code ne sont qu'un point de départ. Pour les adapter à ton capteur, téléverse le code, ouvre le moniteur série et note la force de la flamme en tenant un briquet à 10, 30 et 60 cm ; à cause de la loi de l'inverse du carré, tu verras la valeur changer très vite de près et lentement de loin. C'est pourquoi on ne peut pas déduire une distance exacte en centimètres de la valeur analogique : la même valeur peut venir d'une petite flamme proche ou d'une grande flamme éloignée. Tu peux voir comment l'ADC produit la valeur brute dans conversion analogique-numérique et les subtilités du moniteur série dans Arduino Serial Monitor.

Le soleil et les autres sources de fausses alarmes

Un capteur de flamme ne voit pas le feu, mais la lumière infrarouge d'une bande précise, et tout ce qui émet de la lumière dans cette bande peut le déclencher. La loi de Wien explique quelles sources posent problème : la longueur d'onde à laquelle un corps chaud rayonne le plus vaut environ 2898 / T micromètres (T étant la température en kelvins). Le soleil et les ampoules à incandescence rayonnent fortement en plein dans la bande du capteur, alors que le corps humain est bien trop froid : le capteur ne te voit pas du tout. C'est pour cela que la détection de mouvement exige un capteur PIR, qui travaille sur des longueurs d'onde bien plus grandes.

Tu peux éviter la plupart des fausses alarmes par le matériel : place le capteur pour qu'il ne regarde ni une fenêtre, ni un mur ensoleillé, ni une ampoule à incandescence, idéalement orienté vers le bas et vers l'intérieur de la pièce, réduis son champ de vision avec un tube noir et règle le potentiomètre sous la lumière ambiante réelle. N'oublie pas qu'un fort soleil ne provoque pas seulement de fausses alarmes : il peut aussi aveugler le capteur en le saturant. Si la valeur AO est déjà au minimum au soleil, il ne reste plus rien à faire varier quand une vraie flamme apparaît. Les détecteurs de flamme infrarouges professionnels résolvent ce problème en observant la bande de 4,3 µm, où rayonne le dioxyde de carbone chaud et où l'atmosphère absorbe une grande partie de la lumière solaire, en comparant plusieurs longueurs d'onde et en analysant le scintillement de la flamme. Ton module ne peut pas faire les deux premières choses, mais tu peux imiter par logiciel l'analyse du scintillement et la confirmation dans le temps.

Réduire les fausses alarmes par logiciel : confirmation dans le temps et analyse du scintillement

Une vraie flamme ne brûle jamais de façon régulière ; les courants d'air et les gaz chauds qui montent font varier sa luminosité environ 1 à 20 fois par seconde. La lumière du soleil et celle d'une ampoule à incandescence sont au contraire presque constantes sur de courtes durées, et les impulsions d'une télécommande ne durent que quelques millisecondes. Le code suivant exploite ces différences avec trois règles : la force de la flamme doit être nettement au-dessus de la référence, la valeur doit avoir varié de plus d'une certaine quantité pendant la dernière seconde, et ces deux conditions doivent être réunies sans interruption pendant au moins deux secondes. De plus, chaque mesure est la moyenne de 20 échantillons pris sur 10 ms. Sur un réseau à 50 Hz, les lampes scintillent légèrement 100 fois par seconde ; une moyenne sur 10 ms, soit exactement une période de ce scintillement, efface cette ondulation et la lampe n'est pas prise pour une flamme qui vacille.

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}

Comme le code mesure le temps avec millis() au lieu de delay(), il continue de mesurer même pendant que l'alarme sonne ; tous les détails sont dans millis ou delay. La référence n'est pas figée non plus : en l'absence de flamme, elle se déplace de 5 % vers la dernière mesure une fois par seconde et suit lentement l'évolution de la lumière ambiante au fil de la journée. Pour trouver un bon FLICKER_LIMIT, observe dans le moniteur série la variation sur une seconde d'une source lumineuse stable, puis celle d'une bougie, et place le seuil entre les deux. La méthode n'est pas parfaite ; la lumière du soleil qui passe à travers des feuilles agitées par le vent scintille aussi. Tu trouveras d'autres techniques, comme la moyenne glissante et le filtre médian, dans filtrer les données d'un capteur.

Utilisation avec le capteur de gaz MQ-2

Un capteur de flamme et un capteur de gaz MQ-2 compensent mutuellement leurs faiblesses. Le capteur de flamme est très rapide, mais il ne voit que les flammes de son champ de vision et le soleil peut le tromper. Le MQ-2 détecte la fumée et les gaz inflammables et peut repérer un feu derrière un angle ou un feu qui couve sans flamme, mais la fumée met du temps à l'atteindre et il doit chauffer à chaque mise sous tension. En utilisant les deux, tu peux considérer le signal d'un seul capteur comme un avertissement et le signal simultané des deux comme un incendie.

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}

Relie la sortie AO du MQ-2 à A1 et alimente le module en 5V ; le capteur de flamme peut rester sur D2. Règle SMOKE_LIMIT nettement au-dessus de la valeur lue après quelques minutes de fonctionnement à l'air propre, comme expliqué dans le guide du MQ-2. La condition de fumée est ignorée pendant les 60 premières secondes, car un MQ-2 froid démarre avec une valeur élevée. Le temps de maintien de 300 ms sur le signal de flamme (HOLD_MS) transforme les brèves commutations de la sortie DO, dues au vacillement de la flamme, en une seule détection continue. Si tu transposes cette combinaison sur un ESP32, attention : le MQ-2 a besoin de 5 V et sa sortie AO peut monter à 5 V, il faut donc absolument placer un pont diviseur de tension sur sa sortie, alors que le capteur de flamme fonctionne directement en 3V3.

Alerte incendie sur ton téléphone avec un ESP32 (Telegram)

Pour que l'alarme prévienne non seulement les personnes présentes dans la pièce mais aussi toi quand tu es absent, tu peux utiliser un ESP32. Les bots Telegram sont la solution la plus simple : ils sont gratuits, ne demandent aucun serveur et le message arrive instantanément sous forme de notification sur ton téléphone. Le code suivant fait sonner le buzzer et envoie un message Telegram dès qu'une flamme est vue pendant 1,5 seconde, puis attend au moins une minute entre deux messages pour ne pas inonder ton téléphone pour le même feu. Nous détaillons la création du bot et le contrôle dans les deux sens par commandes dans bot Telegram avec ESP32.

1. Dans Telegram, écris à @BotFather, envoie la commande /newbot, donne un nom à ton bot et copie le token qu'il te fournit.
2. Ouvre un bot d'identification comme @userinfobot et appuie sur Démarrer ; il te renvoie ton propre identifiant de discussion (chat ID).
3. Cherche ton nouveau bot dans Telegram et appuie sur Démarrer (Start) ; sans cela, le bot ne peut pas t'envoyer de messages.
4. Dans l'IDE Arduino, installe les bibliothèques UniversalTelegramBot et ArduinoJson depuis le gestionnaire de bibliothèques.
5. Remplace dans le code le nom du réseau Wi-Fi, le mot de passe, le token et le chat ID par les tiens, choisis l'ESP32 comme carte et téléverse le code.

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}

L'appel à sendMessage() ouvre une connexion HTTPS sécurisée et peut donc prendre une ou deux secondes ; pendant ce temps, le motif du buzzer se fige un instant, c'est normal. Au démarrage, le code tente de se connecter au Wi-Fi pendant 15 secondes au maximum ; sans connexion, l'alarme continue de fonctionner localement et un message non envoyé est retenté une minute plus tard, le buzzer sonne donc même sans internet. Si tu veux aussi lire la sortie AO sur l'ESP32, branche-la toujours sur une broche ADC1 (GPIO 32–39), car les broches ADC2 sont inutilisables quand le Wi-Fi est actif ; c'est pour cela que le tableau utilise GPIO 34. Tu peux voir les broches sûres de ta carte dans l'outil Pinout. Si un buzzer actif 5 V sonne faiblement sur une broche 3,3 V, commande-le en 5 V avec un transistor. Pour un abri de jardin ou une maison de campagne sans Wi-Fi, tu peux construire la même alarme pour qu'elle envoie un SMS avec un module GSM SIM800L.

Capteur de flamme avec Raspberry Pi Pico et MicroPython

Sur le Raspberry Pi Pico, la logique est la même. Alimente le module par la broche 3V3(OUT), relie DO à GP15 et, si tu l'as, AO à GP26. Le module possède déjà sa propre résistance de tirage (pull-up) sur la ligne DO, tu n'as donc pas besoin de celle du Pico. L'ADC du Pico est sur 12 bits, mais en MicroPython read_u16() ramène le résultat sur 0–65535 ; l'équivalent du 1023 de l'Arduino est donc ici d'environ 65535. Le code utilise un temps de maintien de 300 ms qui tolère les brèves coupures sur DO et une confirmation de 1,5 seconde :

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)

Quand tu lances le code dans Thonny, tu vois la valeur AO et l'état de l'alarme dans la fenêtre Shell ; ouvre le Plotter depuis le menu Affichage pour suivre les valeurs sous forme de graphique. Pour que le programme démarre tout seul à la mise sous tension du Pico, enregistre le fichier sur le Pico sous le nom main.py. Utiliser time.ticks_diff() pour mesurer le temps est important, car le compteur de ticks_ms() repart à zéro après une certaine valeur et une simple soustraction donne alors un résultat faux.

Idées de projets avec un capteur de flamme

• Alarme incendie pour la cuisine : Construis une alarme avec un capteur de flamme tourné vers la plaque de cuisson et un MQ-2, en utilisant la logique à deux niveaux présentée plus haut.
• Rappel de feu oublié : Si une flamme est vue sans interruption pendant plus de 30 minutes, le buzzer sonne et un message part vers ton téléphone.
• Robot pompier : Trouve la direction de la flamme avec un capteur à 5 canaux, conduis le robot jusqu'à elle avec un L298N et des moteurs à courant continu et éteins la bougie avec une mini pompe à eau.
• Scanner de direction de flamme : Monte un seul capteur sur un servomoteur, balaie de 0 à 180 degrés et affiche l'angle du signal le plus fort.
• Tableau de sécurité pour maison connectée : Réunis capteurs de flamme, de gaz et de mouvement sur une seule carte ; tous les détails dans projet de maison connectée avec Arduino.
• Gardien d'atelier : Si une flamme inattendue apparaît près de la station de soudure, allume un voyant d'alerte via un relais.
• Concours d'extinction de bougie : Comme dans les concours de robotique scolaires, construis un robot qui trouve et éteint une bougie dans un labyrinthe le plus vite possible ; un capteur de flamme suffit pour commencer.

Erreurs fréquentes et solutions

Le capteur de flamme est un composant bon marché mais très formateur, qui permet d'apprendre à la fois la physique de la lumière infrarouge, les circuits comparateurs et la lutte contre les fausses alarmes. Commence par une alarme simple sur DO, puis renforce ton système pas à pas avec la lecture analogique, l'analyse du scintillement et un MQ-2 ; pour un système de sécurité plus complet, jette un œil à système d'alarme avec Arduino. Dans l'application BlueGrays, tu trouveras les projets d'utilisation du capteur de flamme, d'alarme avec capteurs de flamme et de gaz, de détecteur de fumée MQ-2 avec ESP32 et de système d'alarme ESP32 avec notification Telegram, avec des schémas pas à pas et du code prêt à l'emploi.