Componenten · 17 min leestijd

Vlamsensor met Arduino: bedrading, code en brandalarm

Gids voor de vlamsensor met Arduino: bedrading, DO- en AO-uitgang, gevoeligheid, bereik en hoek, brandalarm met buzzer, combineren met MQ-2, valse alarmen voorkomen, code voor ESP32 en Pico.

Een vlamsensor is een goedkope module die het infrarode licht van een aansteker, kaars of brandend papier detecteert, en je gebruikt hem met een Arduino in maar een paar regels code. Een vlamsensor met Arduino heeft geen bibliotheek nodig: de DO-pin van de module verandert van toestand zodra hij een vlam ziet, en de AO-pin op versies met 4 pinnen geeft een spanning die meebeweegt met de intensiteit van de vlam. Het is een van de populairste sensoren voor brandalarmen, blusrobots, keukenveiligheid en schoolprojecten.

In deze gids leer je wat er in een vlamsensor zit en waarom hij alleen reageert op licht tussen 760 en 1100 nm, hoe de digitale en analoge uitgang verschillen, hoe je de gevoeligheidspotmeter goed instelt en wat het detectiebereik en de detectiehoek zijn. Daarna bouw je een brandalarm met een buzzer en een led, combineer je de sensor met een MQ-2-gassensor, beperk je in software valse alarmen door bronnen als zonlicht en afstandsbedieningen, stuur je met een ESP32 een Telegram-melding naar je telefoon en laat je dezelfde schakeling draaien op een Raspberry Pi Pico met MicroPython.

Vlamsensormodule (LM393, 3 pinnen)
Vlamsensormodule met 3 pinnen: links de zwarte infraroodontvanger, in het midden de blauwe gevoeligheidspotmeter en de LM393-comparator, en rechts de pinnen VCC, GND en DO met de voedings- en alarmled.

Wat is een vlamsensor en hoe werkt hij?

Het zwarte, ledachtige onderdeel aan het uiteinde van de module is eigenlijk een infraroodfototransistor (op sommige boards een fotodiode); een veelvoorkomend voorbeeld is de YG1006. Zijn zwarte epoxybehuizing filtert het meeste zichtbare licht weg en laat alleen nabij-infrarood licht tussen ongeveer 760 en 1100 nm door, met een piekgevoeligheid rond 940 nm. De bovengrens komt van silicium zelf: met een bandgap van 1,12 eV kan silicium fotonen met een golflengte langer dan ongeveer 1100 nm niet absorberen. Doordat de hete roetdeeltjes in een vlam ook in deze band straling uitzenden, neemt de stroom door de fototransistor toe naarmate een vlam dichterbij komt. Een spanningsdeler op het board zet die stroom om in een spanning, en de LM393-comparator vergelijkt die met de drempel die je met de potmeter instelt om de toestand van de DO-pin te bepalen.

EigenschapWaarde
Gedetecteerde golflengte760–1100 nm (piekgevoeligheid ~940 nm)
DetectiehoekOngeveer 60° (~30° aan weerszijden van de as)
DetectieafstandMeestal tot 80 cm voor een aanstekervlam; meer bij grotere vlammen
Voedingsspanning3,3–5 V
ComparatorLM393; drempel instelbaar met een multiturn-potmeter
UitgangenDO (digitaal, op elk model), AO (analoog, op modellen met 4 pinnen)
DO-logicaGewone blauwe modules: vlam = LOW en de DO-led brandt; KY-026: meestal vlam = HIGH
ReactietijdRuim onder een milliseconde; de fototransistor reageert binnen microseconden
Werktemperatuur van de ontvangerOngeveer −25 tot +85 °C

Verschillende vlamsensorboards doen hetzelfde werk. Modules met 3 pinnen, zoals die op de foto hierboven, hebben alleen een digitale uitgang; modules met 4 pinnen hebben er een analoge uitgang bij. De KY-026 die je misschien kent uit sensorkits werkt op dezelfde manier, maar zijn DO-uitgang is meestal omgekeerd. Blusrobots gebruiken boards met meerdere kanalen en vijf ontvangers in waaiervorm. Een vlamsensor is passief: hij zendt zelf geen licht uit. Daarin verschilt hij van de TCRT5000-infraroodsensor, die zowel een zender als een ontvanger heeft.

ModelPinsKenmerkWanneer kies je hem
Module met 3 pinnenVCC, GND, DOAlleen vlam ja/neeEenvoudig brandalarm, eerste experimenten
Module met 4 pinnenVCC, GND, DO, AODrempeluitgang + vlamintensiteitAlarm met meerdere niveaus, filteren van valse alarmen
KY-026A0, G, +, D0Hetzelfde als de module met 4 pinnen; DO meestal HIGH bij een vlamProjecten die bij sensorkits horen
Module met 5 kanalenVCC, GND en een aparte uitgang per ontvangerBreed gezichtsveld van ongeveer 120°Robots die de richting van de vlam bepalen

Digitale (DO) of analoge (AO) uitgang

De DO-pin geeft een ja/nee-antwoord: hij verandert van toestand zodra het infrarode licht de drempel overschrijdt die je met de potmeter hebt ingesteld. Op gewone blauwe boards is deze pin normaal HIGH, wordt hij LOW zodra hij een vlam ziet en gaat de DO-led branden; op sommige boards, zoals de KY-026, is het andersom. Het eerste wat je dus doet, is je eigen module testen met een aansteker en kijken wat de Serial Monitor laat zien. De AO-pin geeft het ruwe signaal. Op de meeste modules daalt deze waarde naarmate een vlam dichterbij komt: een analogRead-waarde van 900–1020 in een ruimte zonder vlam kan dalen tot een paar honderd met een aansteker in de buurt. De potmeter verandert alleen de DO-drempel en heeft geen invloed op AO.

EigenschapDO (digitaal)AO (analog)
Uitgelezen waardeHIGH of LOW0–1023 op een Arduino Uno
DrempelPotmeter op het boardStel je in via de code
InformatieIs er een vlam of nietVlamintensiteit, ruwe afstand en flikkering
Te gebruiken pinElke digitale pinAnalog pin (ADC)
Het best voorEenvoudig alarm, directe reactie via interruptAlarm met meerdere niveaus, filteren van valse alarmen, richting bepalen

Zo stel je de gevoeligheidspotmeter af

  1. Zet de module onder spanning en plaats de sensor op de plek waar hij gaat werken, gericht op het gebied dat hij moet bewaken; doe deze afstelling altijd in de echte omgeving.
  2. Draai zonder vlam met een klein schroevendraaiertje aan de blauwe potmeter en zoek het punt waar de DO-led wisselt tussen aan en uit.
  3. Draai vanaf dat punt nog een halve tot hele slag verder in de richting waarin de led uit blijft. Zo veroorzaken kleine veranderingen in het omgevingslicht geen alarm.
  4. Houd een aansteker richting de sensor op de grootste afstand die je wilt detecteren en controleer of de led gaat branden. Zo niet, stel de sensor iets gevoeliger af en probeer het opnieuw.
  5. Zorg dat de sensor niet naar een zonnig raam of een gloeilamp kijkt en controleer de instelling een paar uur later nog eens onder ander licht.
De blauwe potmeter op deze modules is meestal een multiturn-trimmer van type 3296 die ongeveer 25 slagen nodig heeft van het ene uiteinde naar het andere. Als je er een paar keer aan draait en er verandert niets, is hij niet kapot; je moet gewoon doordraaien. Een LM393 die heel dicht bij zijn drempel staat, kan snel aan en uit schakelen terwijl de vlam flikkert; dat los je zo meteen op met een vasthoudtijd in de code. Hoe een potmeter werkt, lees je in wat is een potmeter.

Detectiebereik en -hoek

Waarden zoals de 80 cm van fabrikanten gelden voor een standaard aanstekervlam; het echte bereik hangt af van de grootte van de vlam, de potmeterinstelling en het omgevingslicht. Hier geldt een eenvoudige natuurkundige wet: de intensiteit van het licht van een kleine bron neemt af met het kwadraat van de afstand. Verdubbel je de afstand, dan daalt het infrarode licht dat de sensor bereikt tot een kwart. Andersom bekeken kun je een vlam die vier keer zoveel licht uitzendt van twee keer zo ver detecteren, en een vlam die honderd keer sterker is van tien keer zo ver. Daarom wordt een kaarsvlam op kortere afstand gedetecteerd dan een aansteker, terwijl een brandende stapel papier op meerdere meters afstand te detecteren is.

AfstandLicht dat de sensor bereikt (20 cm = 100%)
20 cm100%
40 cm25%
60 cm11%
80 cm6%
1 m4%

De detectiehoek is ongeveer 60 graden, dus de sensor ziet vlammen binnen een kegel van zo'n 30 graden aan weerszijden van zijn as, en het signaal wordt snel zwakker naarmate de vlam naar de rand van die kegel beweegt. De ontvanger heeft lange pootjes, dus je kunt hem voorzichtig in elke richting buigen, maar als je steeds op de plek buigt waar de pootjes in de behuizing komen, breekt hij. Om het gezichtsveld te verkleinen schuif je een matzwarte buis over de ontvanger: een buis met 6 mm binnendiameter en 2 cm lengte beperkt de hoek tot ongeveer 30 graden en houdt zonlicht of lamplicht van opzij tegen. Het gezichtsveld moet net breed genoeg zijn voor het gebied dat je wilt bewaken; alles wat breder is, geeft alleen extra bronnen van valse alarmen.

Vlamsensor aansluiten: Arduino Uno, ESP32 en Pico

AansluitingArduino UnoESP32Raspberry Pi Pico
VCC van de module5V3V33V3(OUT), pin 36
GND van de moduleGNDGNDGND, pin 38
DO van de moduleD2GPIO 27GP15, pin 20
AO van de module (4 pinnen)A0GPIO 34 (ADC1)GP26 / ADC0, pin 31
Actieve buzzer (+)D8GPIO 25GP14, pin 19
Rode led (met 220 Ω)D7GPIO 26GP13, pin 17
De pins van ESP32 en Pico zijn ontworpen voor 3,3 V. Voed de vlamsensor op deze boards via de 3V3-pin, niet via 5V, VIN of VBUS; als de module op 5 V draait, kunnen de DO- en AO-uitgangen 5 V bereiken en de ingangspin beschadigen. Dit is een belangrijk verschil met de MQ-2: de vlamsensor werkt prima op 3,3 V, dus je hebt geen spanningsdeler nodig. Lees altijd de labels VCC en GND op het board voordat je bedraadt; de volgorde van de pins verschilt per model, en een omgekeerde voeding kan de LM393 vernielen.

Stap voor stap: een brandalarm met vlamsensor en Arduino

  1. Sluit de VCC-pin van de module aan op de 5V-pin van de Arduino, GND op GND en DO op D2.
  2. Sluit het lange (+) pootje van de actieve buzzer aan op D8 en het korte pootje op GND.
  3. Sluit het lange pootje van de rode led via een weerstand van 220 Ω aan op D7 en het korte pootje op GND. Gebruik je een andere led, dan bereken je de weerstandswaarde met de led-weerstandscalculator.
  4. Upload de onderstaande code, open de Serial Monitor op 9600 baud en houd kort een aansteker richting de sensor vanaf 20–30 cm afstand.
  5. Als de buzzer klinkt en de led gaat branden, werkt de schakeling; gaat het alarm af zonder vlam en wordt het stil bij een vlam, zet dan FLAME_ACTIVE in de code op HIGH.
C++ (Arduino IDE)
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}

Bij elke ronde leest de code de DO-pin en vergelijkt het resultaat met de constante FLAME_ACTIVE. Dankzij deze constante werkt dezelfde code met blauwe modules die LOW worden bij een vlam en met de KY-026 die HIGH wordt. Zolang er een vlam zichtbaar is, blijft de led aan, terwijl de buzzer elke 150 ms aan en uit gaat voor een opvallend, piepend geluid. Een actieve buzzer heeft een eigen oscillator, dus hij heeft alleen HIGH en LOW nodig; heb je een passieve buzzer, gebruik dan tone() in plaats van digitalWrite, zoals uitgelegd in wat is een buzzer. Er is nog een reden waarom we D2 voor de DO-pin kozen: op de Uno is D2 een van de twee pins die interrupts ondersteunen, dus met attachInterrupt vang je een vlam op zonder te wachten op de rest van de lus.

Analoge meting: vlamintensiteit en ruwe afstand

Heb je een module met 4 pinnen, dan kun je met de AO-uitgang veel meer. Omdat de ruwe waarde in elke omgeving anders is, gebruik je deze methode in plaats van een vaste drempel: meet bij het opstarten, zonder vlam, een basiswaarde en kijk dan hoe ver elke nieuwe meting daarvan afwijkt. De onderstaande code middelt 16 metingen om ruis te verminderen, berekent de afwijking als vlamsterkte en laat ruwweg zien of de vlam dichtbij of ver weg is. Stijgt de AO-waarde van jouw module bij een vlam, zet dan gewoon DROPS_WITH_FLAME op false.

C++ (Arduino IDE)
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}

De drempels 100 en 400 in de code zijn alleen een beginpunt. Om ze voor jouw eigen sensor af te stellen, upload je de code, open je de Serial Monitor en noteer je de vlamsterkte terwijl je een aansteker op 10, 30 en 60 cm houdt; door de omgekeerd kwadratische wet zie je de waarde dichtbij heel snel veranderen en veraf langzaam. Daarom kun je uit de analoge waarde geen exacte afstand in centimeters afleiden: dezelfde waarde kan van een kleine vlam dichtbij komen of van een grote vlam veraf. Hoe de ADC de ruwe waarde maakt, lees je in analoog-digitaalomzetting en de fijnere punten van de Serial Monitor in Arduino Serial Monitor.

Zonlicht en andere bronnen van valse alarmen

Een vlamsensor ziet geen vuur; hij ziet infrarood licht in een bepaalde band, en alles wat in die band licht uitzendt, kan hem activeren. De wet van Wien verklaart welke bronnen problemen geven: de golflengte waarop een heet voorwerp het meest straalt, is ongeveer 2898 / T micrometer (T is de temperatuur in kelvin). De zon en gloeilampen stralen sterk precies in de band van de sensor, terwijl het menselijk lichaam veel te koel is, dus de sensor ziet jou helemaal niet. Daarom heb je voor bewegingsdetectie een PIR-sensor nodig, die naar veel langere golflengten kijkt.

BronOngeveer temperatuurPiekgolflengteEffect op de vlamsensor
Zon5800 K0,5 µmZeer sterk; direct zonlicht of een weerkaatsing in glas kan de sensor verblinden
Gloei- en halogeenlampen2700–3000 K~1 µmSterk; een groot deel van hun licht valt precies in de band van de sensor
Kaars- en aanstekervlam (roetdeeltjes)~1500 K~1,9 µmDe bron die je wilt detecteren; een deel van de straling valt in de band
Gloeiend verwarmingselement, kachel~1100 K~2,6 µmKan van dichtbij een alarm veroorzaken
Tv-afstandsbediening-0,94 µm (smalle band)Activeert hem met korte pulsen
Led- en tl-lampen-Zichtbare bandBijna geen infrarood, meestal geen probleem
Menselijk lichaam310 K~9,3 µmOnzichtbaar voor de sensor

De meeste valse alarmen voorkom je met hardware: plaats de sensor zo dat hij niet naar een raam, een zonnige muur of een gloeilamp kijkt, het liefst naar beneden en de ruimte in gericht, beperk zijn gezichtsveld met een zwarte buis en stel de potmeter af onder echte omgevingsverlichting. Bedenk dat sterk zonlicht niet alleen valse alarmen veroorzaakt, maar de sensor ook kan verblinden door hem te verzadigen: als de AO-waarde in de zon al op zijn minimum staat, kan er niets meer veranderen wanneer er een echte vlam verschijnt. Professionele infraroodvlamdetectoren lossen dit op door te kijken naar de 4,3 µm-band, waar heet koolstofdioxide straalt en zonlicht grotendeels door de atmosfeer wordt geabsorbeerd, door meerdere golflengten te vergelijken en door de flikkering van de vlam te analyseren. Jouw module kan de eerste twee niet, maar flikkeranalyse en tijdsbevestiging kun je in software nabootsen.

Valse alarmen verminderen in software: tijdsbevestiging en flikkeranalyse

Een echte vlam brandt nooit constant; luchtstromen en opstijgende hete gassen laten de helderheid ongeveer 1 tot 20 keer per seconde schommelen. Zonlicht en het licht van een gloeilamp zijn daarentegen op korte termijn vrijwel constant, en de pulsen van een afstandsbediening duren slechts milliseconden. De onderstaande code gebruikt deze verschillen met drie regels: de vlamsterkte moet duidelijk boven de basiswaarde liggen, de waarde moet de laatste seconde meer dan een bepaalde hoeveelheid zijn geschommeld, en beide voorwaarden moeten minstens twee seconden ononderbroken gelden. Daarnaast is elke meting het gemiddelde van 20 samples over 10 ms. Op een net van 50 Hz flikkeren lampen licht 100 keer per seconde; middelen over 10 ms, precies één flikkerperiode, heft deze rimpel op, zodat een lamp niet voor een flikkerende vlam wordt aangezien.

C++ (Arduino IDE)
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}

Doordat de code de tijd bijhoudt met millis() in plaats van delay(), blijft hij meten terwijl het alarm klinkt; de details van deze aanpak staan in millis vs delay. De basiswaarde blijft ook niet vast: als er geen vlam is, schuift hij eenmaal per seconde 5 procent op naar de laatste meting en volgt zo langzaam het omgevingslicht dat overdag verandert. Om een goede FLICKER_LIMIT te vinden, bekijk je in de Serial Monitor de schommeling over één seconde van een constante lichtbron en daarna die van een kaarsvlam, en stel je de drempel tussen die twee in. Deze methode is niet perfect; zonlicht dat door bladeren in de wind schijnt, flikkert ook. Andere technieken zoals voortschrijdend gemiddelde en mediaanfilters vind je in sensordata filteren.

Samen gebruiken met een MQ-2-gassensor

Een vlamsensor en een MQ-2-gassensor dekken elkaars zwakke punten af. De vlamsensor is erg snel, maar ziet alleen vlammen in zijn gezichtsveld en kan door de zon worden voorgelogen. De MQ-2 detecteert rook en brandbare gassen en merkt een brand om de hoek of een smeulend vuur zonder vlam op, maar de rook heeft tijd nodig om hem te bereiken en hij moet bij elke start opwarmen. Gebruik je beide, dan kun je een signaal van één sensor als waarschuwing behandelen en een signaal van beide tegelijk als brand.

MQ-2 gas- en rooksensor
MQ-2 gas- en rooksensor
Buzzer
Buzzer
VlamsensorMQ-2BeslissingReactie
NeeNormalNormalLed en buzzer uit
JaNormalWaarschuwing: kan zonlicht, een lamp of een beginnende brand zijnLed knippert, elke 2 seconden een korte piep
NeeHoogWaarschuwing: rook, een gaslek of een brand buiten het gezichtsveldLed knippert, elke 2 seconden een korte piep
JaHoogBrandLed blijft aan, snel piepende sirene
C++ (Arduino IDE)
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}

Sluit de AO-uitgang van de MQ-2 aan op A1 en voed de module via 5V; de vlamsensor kan op D2 blijven. Stel SMOKE_LIMIT duidelijk boven de waarde die je meet nadat je de sensor een paar minuten in schone lucht hebt laten draaien, zoals beschreven in de MQ-2-gids. De rookvoorwaarde wordt de eerste 60 seconden genegeerd, omdat een koude MQ-2 met een hoge waarde begint. De vasthoudtijd van 300 ms op het vlamsignaal (HOLD_MS) maakt van het korte aan-uitschakelen van de DO-uitgang, veroorzaakt door de flikkerende vlam, één doorlopende detectie. Verplaats je deze combinatie naar een ESP32, wees dan voorzichtig: de MQ-2 heeft 5 V nodig en zijn AO-uitgang kan 5 V bereiken, dus je moet een spanningsdeler op zijn uitgang zetten, terwijl de vlamsensor rechtstreeks op 3V3 draait.

Brandmeldingen naar je telefoon met een ESP32 (Telegram)

Wil je dat het alarm niet alleen de mensen in de ruimte waarschuwt maar ook jou als je weg bent, dan kun je een ESP32 gebruiken. Telegram-bots zijn daarvoor de makkelijkste weg: ze zijn gratis, hebben geen eigen server nodig en het bericht komt direct als melding op je telefoon binnen. De onderstaande code laat de buzzer klinken en stuurt een Telegram-bericht zodra een vlam 1,5 seconde te zien is geweest, en wacht minstens een minuut tussen berichten zodat je telefoon niet volstroomt voor dezelfde brand. Het opzetten van de bot en bediening in twee richtingen met commando's behandelen we uitgebreid in ESP32 Telegram-bot.

  1. Chat in Telegram met @BotFather, stuur het commando /newbot, geef je bot een naam en kopieer de token die je krijgt.
  2. Open een ID-bot zoals @userinfobot en tik op Start; hij antwoordt met je eigen chat-ID.
  3. Zoek je nieuwe bot in Telegram en tik op Start; sla je dit over, dan kan de bot je geen berichten sturen.
  4. Installeer in de Arduino IDE de bibliotheken UniversalTelegramBot en ArduinoJson via de Library Manager.
  5. Vervang de wifinaam, het wachtwoord, de token en het chat-ID in de code door je eigen gegevens, kies ESP32 als board en upload de code.
C++ (Arduino IDE)
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}

De aanroep sendMessage() opent een beveiligde HTTPS-verbinding, dus dat kan een of twee seconden duren; het buzzerpatroon staat in die tijd even stil, en dat is normaal. Bij het opstarten probeert de code maximaal 15 seconden verbinding met wifi te maken; lukt dat niet, dan blijft hij het alarm lokaal uitvoeren en probeert hij een niet verzonden bericht een minuut later opnieuw, zodat de buzzer ook zonder internet blijft klinken. Wil je op een ESP32 ook de AO-uitgang uitlezen, sluit hem dan altijd aan op een ADC1-pin (GPIO 32–39), omdat ADC2-pins niet bruikbaar zijn zolang wifi aan staat; daarom is in de tabel GPIO 34 gekozen. De veilige pins van jouw board zie je in de tool Pinout. Klinkt een actieve 5V-buzzer zwak op een 3,3V-pin, stuur hem dan aan vanaf 5 V met een transistor. Voor een schuur of vakantiehuis zonder wifi kun je hetzelfde alarm een sms laten sturen met een SIM800L GSM-module.

Vlamsensor met Raspberry Pi Pico en MicroPython

Op de Raspberry Pi Pico geldt dezelfde logica. Voed de module via de 3V3(OUT)-pin, sluit DO aan op GP15 en, als je die hebt, AO op GP26. De module heeft zelf een pull-upweerstand op de DO-lijn, dus je hebt de interne pull-up van de Pico niet nodig. De ADC van de Pico is 12 bits, maar read_u16() in MicroPython schaalt het resultaat naar 0–65535, dus het equivalent van de 1023 van de Arduino is hier ongeveer 65535. De code gebruikt een vasthoudtijd van 300 ms die korte onderbrekingen op DO opvangt en een bevestiging van 1,5 seconde:

MicroPython
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)

Als je de code in Thonny uitvoert, zie je de AO-waarde en de alarmtoestand in het Shell-venster; open de Plotter via het menu View om de waarden als grafiek te volgen. Zodat het programma automatisch start als de Pico onder spanning komt, sla je het bestand op de Pico op als main.py. Time.ticks_diff() gebruiken voor de timing is belangrijk, omdat de teller ticks_ms() na een bepaalde waarde terugspringt en een gewone aftrekking op dat moment een verkeerd resultaat geeft.

Projectideeën met de vlamsensor

  • Keukenbrandalarm: Bouw een alarm met een vlamsensor gericht op het kookplaat en een MQ-2, met de logica met twee niveaus van hierboven.
  • Herinnering voor vergeten kookplaat: Wordt er langer dan 30 minuten onafgebroken een vlam gezien, laat dan de buzzer klinken en stuur een bericht naar je telefoon.
  • Blusrobot: Bepaal de richting van de vlam met een sensor met 5 kanalen, rij de robot erheen met een L298N en gelijkstroommotoren en blus de kaars met een mini-waterpomp.
  • Scanner voor vlamrichting: Monteer één sensor op een servomotor, draai van 0 tot 180 graden en toon de hoek met het sterkste signaal.
  • Veiligheidspaneel voor slim huis: Combineer vlam-, gas- en bewegingssensoren op één board; zie Arduino-project voor een slim huis voor details.
  • Werkplaatsbewaker: Verschijnt er bij het soldeerstation een onverwachte vlam, schakel dan via een relais een waarschuwingslamp in.
  • Wedstrijd kaars blussen: Bouw, zoals bij robotica-wedstrijden op school, een robot die in een doolhof zo snel mogelijk een kaars vindt en dooft; een vlamsensor is alles wat je nodig hebt om te beginnen.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
De DO-led brandt altijd en het alarm stopt nooitDe drempel is te gevoelig, of de sensor kijkt naar de zon of een gloeilampDraai zonder vlam de potmeter tot de led uitgaat en richt de sensor weg van de lichtbron
Er gebeurt niets als je een aansteker laat zienDe drempel is te hoog, of de vlam valt buiten het gezichtsveld van 60 graden of is te ver wegDraai de potmeter een paar slagen richting meer gevoeligheid en breng de vlam recht voor de sensor en dichterbij
Het alarm gaat af zonder vlam en stopt bij een vlamDe DO-uitgang van de module is active-HIGH (bijv. KY-026)Zet FLAME_ACTIVE in de code op HIGH
De DO-led flikkert voor een vlamDe comparator zit heel dicht bij zijn drempel en de flikkering van de vlam schakelt de uitgang omGebruik een vasthoudtijd (HOLD_MS) in de code of stel de drempel iets gevoeliger in
De analoge waarde verandert nooitDe module met 3 pinnen heeft geen AO, of de DO-pin zit op de analoge ingangGebruik een module met 4 pinnen en sluit zijn AO-pin aan op de analoge ingang
Op een knop van de afstandsbediening drukken activeert het alarmDe infrarood-led van 940 nm van de tv-afstandsbedieningGeef pas alarm na een tijdsbevestiging van minstens 1–2 seconden
Bij een raam overdag geeft hij valse alarmen of ziet hij de vlam helemaal nietZonlicht activeert of verzadigt de sensorPlaats de sensor uit de zon, gebruik een zwarte buis en voeg flikkeranalyse toe
Op de ESP32 gaat de AO-waarde fout zodra wifi startAO zit op een ADC2-pinSluit AO aan op een ADC1-pin tussen GPIO 32 en 39
De buzzer is erg zwak op een ESP32 of PicoEen actieve 5V-buzzer wordt aangestuurd door een 3,3V-pinGebruik een 3,3V-buzzer of stuur de buzzer vanaf 5 V aan via een transistor
Je kunt de sensor veilig testen zonder een vlam aan te steken: richt een tv-afstandsbediening op een paar centimeter afstand op de sensor en druk op een knop. Als de infrarood-led van 940 nm van de afstandsbediening de DO-led laat knipperen, werken de sensor en de bedrading. Verwar deze module niet met een IR-ontvanger die afstandsbedieningssignalen decodeert: een IR-ontvanger reageert alleen op een signaal dat op 38 kHz is gemoduleerd, terwijl een vlamsensor de ruwe hoeveelheid infrarood licht meet.
Een alarm met een vlamsensor is een leerproject, geen gecertificeerde brandmelder. Gebruik voor de veiligheid van mensen thuis een rookmelder die voldoet aan EN 14604 en beschouw je eigen schakeling als extra systeem ernaast. Gebruik bij het testen alleen een kleine, gecontroleerde vlam zoals een aansteker of kaars, houd brandbare materialen uit de buurt, laat de vlam nooit onbeheerd en doe het experiment met een volwassene als je jong bent. Plaats de sensor niet vlak naast de vlam: de werktemperatuur van de ontvanger is beperkt tot ongeveer 85 °C, en een oververhitte behuizing kan blijvend beschadigd raken.

Een vlamsensor is een goedkoop maar leerzaam onderdeel dat je tegelijk de natuurkunde van infrarood licht, comparatorschakelingen en het bestrijden van valse alarmen bijbrengt. Begin met een eenvoudig DO-alarm en versterk je systeem dan stap voor stap met analoge metingen, flikkeranalyse en een MQ-2; kijk voor een completer beveiligingssysteem eens naar het Arduino-alarmsysteem. In de BlueGrays-app vind je de projecten vlamsensor, alarm met vlam- en gassensor, ESP32 MQ-2-rookmelder en ESP32-alarmsysteem met Telegram-melding, elk met schakelschema's stap voor stap en kant-en-klare code.

Veelgestelde vragen

Hoe ver kan een vlamsensor een vlam detecteren?

De meeste modules detecteren een standaard aanstekervlam tot ongeveer 80 cm; voor een kaarsvlam is de afstand korter. Omdat de lichtintensiteit afneemt met het kwadraat van de afstand, wordt een vier keer sterkere vlam van twee keer zo ver gezien, dus een groot papier- of houtvuur is op meerdere meters te detecteren. De potmeterinstelling en het omgevingslicht hebben ook direct invloed op het bereik.

Heeft zonlicht invloed op een vlamsensor?

Ja. Zonlicht is zeer sterk in de band van 760–1100 nm waar de sensor op reageert; direct zonlicht of een weerkaatsing in glas veroorzaakt valse alarmen en kan de sensor verblinden, zodat hij een echte vlam mist. Plaats de sensor uit de zon, beperk zijn gezichtsveld met een zwarte buis en gebruik tijdsbevestiging en flikkeranalyse in software.

Geeft een vlamsensor LOW of HIGH als hij een vlam detecteert?

Op gewone blauwe LM393-modules is de DO-pin normaal HIGH, wordt hij LOW zodra hij een vlam ziet en gaat de DO-led branden. Op sommige boards, zoals de KY-026, wordt de uitgang HIGH als er een vlam wordt gedetecteerd. Test je eigen module met een aansteker en stel de vergelijking in je code in op de waarde die de Serial Monitor laat zien.

Werkt een vlamsensor op 3,3 V?

Ja, deze modules werken van 3,3 tot 5 V. Op een ESP32 of Raspberry Pi Pico blijven de DO- en AO-uitgangen onder 3,3 V als je de module via de 3V3-pin voedt, zodat je ze rechtstreeks op de pins kunt aansluiten. Voed je de module met 5 V, dan heb je voor deze boards spanningsdelers op de uitgangen nodig.

Hoe stel je de gevoeligheid van een vlamsensor af?

Draai zonder vlam de blauwe multiturn-potmeter op het board naar het punt waar de DO-led net uitgaat en draai hem dan nog een halve slag richting minder gevoeligheid. Test hem daarna met een aansteker op de grootste afstand die je wilt detecteren. De potmeter verandert alleen de DO-drempel; voor AO stel je de drempel zelf in de code in.

Kan een vlamsensor een brandmelder vervangen?

Nee. Een vlamsensor voor hobbygebruik kan worden voorgelogen door zonlicht, gloeilampen en afstandsbedieningen, ziet geen brand buiten zijn gezichtsveld of een smeulend vuur zonder vlam en is niet volgens een norm getest. Gebruik voor de veiligheid van mensen een rookmelder die voldoet aan EN 14604 en beschouw je eigen schakeling als extra waarschuwingssysteem.

Alle projecten bekijken
Een buzzer gebruiken
AR-13Beginner

Een buzzer gebruiken

Heb je je ooit afgevraagd hoe een deurbel of alarm geluid maakt? De Arduino laat een kleine buzzer met korte tussenpozen piepen: piep, pauze, piep, pauze.

4.7(92)
170
Lichtsterkte meten met een LDR
AR-11Beginner

Lichtsterkte meten met een LDR

Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

4.6(83)
143
Een vlamsensor gebruiken
AR-50Gemiddeld
Premium

Een vlamsensor gebruiken

Een kleine bewaker die vuur eerder opmerkt dan jij, in de keuken of de werkplaats.

4.6(33)
44
Alarm met vlam- en gassensor
AR-52Gevorderd
Premium

Alarm met vlam- en gassensor

Een kleine bewaker die je meteen waarschuwt als er gas lekt of ergens een vlam verschijnt.

4.8(52)
67
Een gassensor gebruiken
AR-51Beginner
Premium

Een gassensor gebruiken

Een kleine bewaker die een gaslek in de keuken eerder opmerkt dan jij. De gassensor snuffelt voortdurend aan de lucht; zolang alles goed is blijft de groene led branden, en als het gas in de lucht…

4.6(37)
50
ESP32 MQ-2 gas-/rookmelderalarm
ES-20Gemiddeld

ESP32 MQ-2 gas-/rookmelderalarm

In dit project detecteer je brandbaar gas (LPG, methaan, propaan) en rook met een MQ-2-gassensormodule en speelt een passieve buzzer bij detectie een sirene-achtig alarm af. De digitale drempeluitgang (DO) van de sensor is verbonden met GPIO 4 van de ESP32. Overschrijdt gas of rook de drempel, dan wordt DO LOW en gaat het alarm af. De gevoeligheid stel je in met de potentiometer op de module. De passieve buzzer wordt met tone() aangestuurd voor een sireneffect met twee frequenties.

4.7(29)
44
ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
ES-41Gevorderd
Premium

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)

Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.

9