Alev Sensörü Arduino: Bağlantı, Kod ve Yangın Alarmı Yapımı

Alev sensörü, bir çakmak, mum ya da kâğıt alevinin yaydığı kızılötesi ışığı algılayan ve Arduino ile yalnızca birkaç satır kodla kullanılabilen ucuz bir modüldür. Arduino'da alev sensörü kullanmak için kütüphane gerekmez: modülün DO pini alev gördüğünde durum değiştirir, 4 pinli modellerdeki AO pini ise alevin şiddetiyle değişen bir gerilim verir. Yangın alarmı, yangın söndüren robot, mutfak güvenlik sistemi ve okul projeleri için en çok tercih edilen sensörlerden biridir.

Bu yazıda alev sensörünün içinde ne olduğunu ve neden yalnızca 760–1100 nm aralığındaki ışığa duyarlı olduğunu, dijital ve analog çıkışın farkını, hassasiyet potansiyometresinin doğru ayarını, algılama menzilini ve açısını öğreneceksin. Ardından buzzer ve LED'li bir yangın alarmı kuracak, sensörü MQ-2 gaz sensörüyle birleştirecek, güneş ışığı ve kumanda gibi kaynakların yol açtığı yanlış alarmları yazılımla azaltacak, ESP32 ile telefonuna Telegram bildirimi gönderecek ve aynı devreyi Raspberry Pi Pico'da MicroPython ile çalıştıracaksın.

Alev sensörü nedir, nasıl çalışır?

Modülün ucundaki siyah, LED'e benzeyen parça aslında bir kızılötesi fototransistördür (bazı kartlarda fotodiyot); yaygın örneklerinden biri YG1006'dır. Siyah epoksi gövde görünür ışığın büyük kısmını süzer ve yalnızca yaklaşık 760–1100 nm arasındaki yakın kızılötesi ışığı geçirir; duyarlılığın en yüksek olduğu nokta 940 nm civarıdır. Aralığın üst sınırı silisyumun kendisinden gelir: silisyumun 1,12 eV'luk bant aralığı, dalga boyu yaklaşık 1100 nm'den uzun fotonları soğuramaz. Alevdeki sıcak is parçacıkları bu bantta da ışıma yaptığı için fototransistörden geçen akım alev yaklaştıkça artar. Kart üzerindeki gerilim bölücü bu akımı gerilime çevirir, LM393 karşılaştırıcı da bu gerilimi potansiyometreyle ayarladığın eşik gerilimiyle karşılaştırarak DO pininin durumunu belirler.

Piyasada aynı işi yapan birkaç farklı alev sensörü kartı bulunur. Yukarıdaki fotoğraftaki gibi 3 pinli modüllerde yalnızca dijital çıkış vardır; 4 pinli modüllerde buna analog çıkış da eklenir. Sensör setlerinden tanıdığın KY-026 aynı mantıkla çalışır, ancak DO çıkışının yönü çoğu zaman terstir. Yangın söndüren robotlarda ise beş alıcıyı yelpaze gibi dizen çok kanallı kartlar kullanılır. Alev sensörü pasif bir sensördür, yani kendisi ışık yaymaz; bu yönüyle hem verici hem alıcı içeren TCRT5000 kızılötesi sensörden ayrılır.

Dijital (DO) ve analog (AO) çıkış farkı

DO pini bir evet/hayır cevabıdır: kızılötesi ışık, potansiyometreyle ayarladığın eşiği geçtiğinde durumu değişir. Yaygın mavi kartlarda bu pin normalde HIGH'tır, alev görünce LOW olur ve DO LED'i yanar; KY-026 gibi bazı kartlarda ise tam tersi olur. Bu yüzden ilk iş olarak kendi modülünü bir çakmakla dene ve Seri Monitör'de hangi değeri okuduğuna bak. AO pini ise ham sinyali verir. Çoğu modülde alev yaklaştıkça bu değer düşer: alevsiz bir odada 900–1020 arasında olan analogRead değeri, yakındaki bir çakmakla birkaç yüze kadar inebilir. Potansiyometre yalnızca DO eşiğini değiştirir, AO değerini etkilemez.

Hassasiyet potansiyometresi nasıl ayarlanır?

1. Modülü beslemeye bağla ve sensörü çalışacağı yere, bakacağı yöne yerleştir; ayarı her zaman gerçek ortamda yap.
2. Ortamda alev yokken mavi potansiyometreyi küçük bir tornavidayla çevir ve DO LED'inin yandığı ile söndüğü sınır noktasını bul.
3. Bu noktadan, LED'in sönük kaldığı yöne doğru yarım ya da bir tur daha çevir. Böylece ortam ışığındaki küçük değişimler alarm vermez.
4. Bir çakmağı algılamak istediğin en uzak mesafede sensöre doğru tut ve LED'in yandığını kontrol et. Yanmıyorsa ayarı çok az hassaslaştır ve tekrar dene.
5. Sensörün güneş alan bir pencereye ya da akkor bir lambaya bakmadığından emin ol ve ayarı birkaç saat sonra, farklı ışık koşullarında yeniden kontrol et.

Algılama menzili ve açısı

Üreticilerin verdiği 80 cm gibi değerler standart bir çakmak alevi içindir; gerçek menzil alevin büyüklüğüne, potansiyometre ayarına ve ortam ışığına bağlıdır. Burada fiziğin basit bir kuralı işler: küçük bir kaynaktan gelen ışığın şiddeti uzaklığın karesiyle azalır. Mesafeyi iki katına çıkarırsan sensöre ulaşan kızılötesi ışık dörtte birine iner. Tersinden bakarsak, dört kat daha fazla ışık yayan bir alevi iki kat uzaktan, yüz kat daha güçlü bir alevi ise on kat uzaktan algılayabilirsin. Bu yüzden bir mum alevi çakmaktan daha yakında, yanan bir kâğıt yığını ise birkaç metreden algılanır.

Algılama açısı yaklaşık 60 derecedir; yani sensör kendi ekseninin iki yanındaki yaklaşık 30 derecelik bir koni içindeki alevleri görür ve alev koninin kenarına yaklaştıkça sinyal hızla zayıflar. Alıcının bacakları uzun olduğu için onu istediğin yöne nazikçe bükebilirsin, ama bacakların gövdeye girdiği yeri sürekli eğip bükmek onu kırar. Görüş alanını daraltmak istiyorsan alıcının üzerine siyah, mat bir boru geçir: 6 mm iç çaplı ve 2 cm uzunluğunda bir boru açıyı kabaca 30 dereceye indirir ve yandan gelen güneş ya da lamba ışığını keser. Görüş alanı izlemek istediğin bölgeyi tam kapsayacak kadar geniş olmalı; daha genişi yalnızca yeni yanlış alarm kaynakları demektir.

Alev sensörü bağlantısı: Arduino Uno, ESP32 ve Pico

Adım adım: Arduino ile alev sensörlü yangın alarmı

1. Modülün VCC pinini Arduino'nun 5V pinine, GND pinini GND'ye, DO pinini D2'ye bağla.
2. Aktif buzzer'ın uzun (+) bacağını D8'e, kısa bacağını GND'ye bağla.
3. Kırmızı LED'in uzun bacağını 220 Ω'luk bir dirençle D7'ye, kısa bacağını GND'ye bağla. Farklı bir LED kullanıyorsan direnç değerini LED direnci hesaplama aracıyla bulabilirsin.
4. Aşağıdaki kodu yükle, Seri Monitör'ü 9600 baud hızında aç ve çakmağı 20–30 cm uzaktan kısa bir süre sensöre doğru tut.
5. Buzzer ötüp LED yanıyorsa devre çalışıyor demektir; alev yokken alarm çalıp alev varken susuyorsa koddaki FLAME_ACTIVE değerini HIGH yap.

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}

Kod her döngüde DO pinini okur ve sonucu FLAME_ACTIVE sabitiyle karşılaştırır. Bu sabit sayesinde aynı kod hem alevde LOW veren mavi modüllerle hem de HIGH veren KY-026 ile çalışır. Alev görüldüğü sürece LED yanar, buzzer ise 150 ms aralıklarla açılıp kapanarak dikkat çekici, kesik kesik bir ses çıkarır. Aktif buzzer kendi osilatörünü içerdiği için yalnızca HIGH ve LOW ile çalışır; elinde pasif buzzer varsa digitalWrite yerine tone() kullanmalısın, farkı buzzer nedir yazısında anlattık. DO pinini D2'ye bağlamamızın bir nedeni daha var: D2, Uno'da kesme (interrupt) destekleyen iki pinden biridir; yani attachInterrupt ile alevi döngünün geri kalanını beklemeden yakalayabilirsin.

Analog okuma: alev şiddeti ve yaklaşık uzaklık

4 pinli bir modülün varsa AO çıkışıyla çok daha fazlasını yapabilirsin. Ham değer her ortamda farklı olduğu için sabit bir eşik yerine şu yöntemi kullan: açılışta, ortamda alev yokken bir taban değeri (baseline) ölç, sonra her ölçümün bu tabandan ne kadar saptığına bak. Aşağıdaki kod 16 ölçümün ortalamasını alarak gürültüyü azaltır, sapmayı alev gücü olarak hesaplar ve alevin yakın mı uzak mı olduğunu kabaca söyler. AO değeri alevle birlikte yükselen bir modülün varsa DROPS_WITH_FLAME sabitini false yapman yeterlidir.

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}

Koddaki 100 ve 400 eşikleri yalnızca bir başlangıç noktasıdır. Kendi sensörüne göre ayarlamak için kodu yükle, Seri Monitör'ü aç ve çakmağı 10, 30 ve 60 cm uzaklıkta tutarak alev gücünü not et; ters kare kuralı yüzünden değerin yakında çok hızlı, uzakta ise yavaş değiştiğini göreceksin. Bu nedenle analog değerden santimetre cinsinden kesin bir mesafe çıkarmak mümkün değildir: aynı değer, yakındaki küçük bir alevden de uzaktaki büyük bir alevden de gelebilir. ADC'nin ham değeri nasıl ürettiğini analog-dijital dönüşüm, Seri Monitör'ün inceliklerini ise Arduino Serial Monitor yazısında bulabilirsin.

Güneş ışığı ve diğer yanlış alarm kaynakları

Alev sensörü ateşi değil, belirli bir banttaki kızılötesi ışığı görür; o bantta ışık yayan her şey onu tetikleyebilir. Hangi kaynağın sorun çıkaracağını Wien yasası anlatır: sıcak bir cismin en çok ışıdığı dalga boyu yaklaşık 2898 / T mikrometredir (T, kelvin cinsinden sıcaklık). Güneş ve akkor ampuller tam da sensörün bandında güçlü ışıma yapar; insan vücudu ise çok soğuk olduğu için sensör seni hiç görmez. Hareket algılamak için çok daha uzun dalga boylarına bakan PIR sensörünün gerekmesi bu yüzdendir.

Yanlış alarmların çoğunu donanımla önleyebilirsin: sensörü pencereye, güneş alan bir duvara ya da akkor bir lambaya bakmayacak şekilde, mümkünse aşağıya ve iç mekâna doğru yerleştir, görüş açısını siyah bir boruyla daralt ve potansiyometreyi gerçek ortam ışığında ayarla. Unutma ki güçlü güneş ışığı yalnızca yanlış alarm üretmez, sensörü doyurarak kör de eder: AO değeri güneşte zaten en alt seviyeye inmişse gerçek bir alev geldiğinde değişecek bir şey kalmaz. Profesyonel kızılötesi alev dedektörleri bu sorunu, sıcak karbondioksitin yaydığı ve güneş ışığının atmosferde büyük ölçüde emildiği 4,3 µm bandına bakarak, birden çok dalga boyunu karşılaştırarak ve alevin titreşimini analiz ederek çözer. Senin modülün ilk ikisini yapamaz, ama titreşim analizini ve süre doğrulamasını yazılımla taklit edebilirsin.

Yazılımla yanlış alarmı azaltmak: süre doğrulaması ve titreşim analizi

Gerçek bir alev hiçbir zaman sabit yanmaz; hava akımı ve yükselen sıcak gazlar yüzünden parlaklığı saniyede yaklaşık 1 ile 20 kez dalgalanır. Güneşin ve akkor ampulün ışığı ise kısa süreler içinde neredeyse sabittir, kumandanın darbeleri de yalnızca milisaniyeler sürer. Aşağıdaki kod bu farkları üç kuralla kullanır: alev gücü tabandan belirgin şekilde yüksek olmalı, değer son bir saniyede belirli bir miktardan fazla dalgalanmış olmalı ve bu iki koşul en az iki saniye kesintisiz sürmeli. Ayrıca her ölçüm, 10 ms boyunca alınan 20 okumanın ortalamasıdır. 50 Hz şebekede lambaların ışığı saniyede 100 kez hafifçe titrer; tam bir titreşim periyodu olan 10 ms'lik ortalama bu dalgalanmayı siler ve lamba, alev gibi titreyen bir kaynak sanılmaz.

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}

Kod delay() yerine millis() ile zaman tuttuğu için alarm çalarken bile ölçüm almaya devam eder; bu yaklaşımın ayrıntıları millis ve delay farkı yazısında. Taban değeri de sabit kalmaz: alev yokken saniyede bir, yeni ölçüme doğru yüzde 5 kayar ve gün içinde değişen ortam ışığını yavaşça takip eder. FLICKER_LIMIT değerini bulmak için Seri Monitör'de önce sabit bir ışık kaynağının, sonra bir mum alevinin bir saniyelik dalgalanmasını izle ve eşiği ikisinin arasına koy. Bu yöntem kusursuz değildir; rüzgârda sallanan yaprakların arasından gelen güneş ışığı da titrer. Hareketli ortalama ve medyan filtre gibi diğer teknikleri sensör verisini filtreleme yazısında bulabilirsin.

MQ-2 gaz sensörü ile birlikte kullanım

Alev sensörü ile MQ-2 gaz sensörü birbirinin eksiğini kapatır. Alev sensörü çok hızlıdır ama yalnızca görüş alanındaki alevi görür ve güneşle kandırılabilir. MQ-2 ise dumanı ve yanıcı gazları algılar; köşenin arkasındaki ya da alevsiz, için için yanan bir yangını da fark edebilir, ama dumanın sensöre ulaşması zaman alır ve her açılışta ön ısınma ister. İkisini birlikte kullandığında tek bir sensörün verdiği sinyali uyarı, ikisinin aynı anda verdiği sinyali ise yangın olarak değerlendirebilirsin.

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}

MQ-2'nin AO çıkışını A1'e bağla ve modülü 5V'tan besle; alev sensörü D2'de kalabilir. Koddaki SMOKE_LIMIT değerini, MQ-2 yazısında anlattığımız gibi sensörü birkaç dakika temiz havada çalıştırıp okuduğun değerin belirgin şekilde üstüne koy. İlk 60 saniye boyunca duman koşulu yok sayılır, çünkü ısınmamış bir MQ-2 yüksek bir değerle başlar. Alev sinyalindeki 300 ms'lik tutma süresi (HOLD_MS) ise alev titrerken DO çıkışının kısa süreli açılıp kapanmasını tek bir kesintisiz algılamaya dönüştürür. Bu kombinasyonu ESP32'ye taşıyacaksan dikkat: MQ-2 5 V ister ve AO çıkışı 5 V'a kadar çıkabilir, bu yüzden onun çıkışına mutlaka bir gerilim bölücü koymalısın; alev sensörü ise doğrudan 3V3 ile çalışır.

ESP32 ile telefona yangın bildirimi (Telegram)

Alarmın yalnızca odadakileri değil, evde olmayan seni de uyarması için ESP32 kullanabilirsin. Telegram botları bunun en kolay yoludur: ücretsizdir, sunucu kurmayı gerektirmez ve mesaj anında telefonuna bildirim olarak düşer. Aşağıdaki kod alev 1,5 saniye boyunca görülünce buzzer'ı çalıştırır ve Telegram'a mesaj gönderir; aynı yangın için telefonun mesaj yağmuruna tutulmasın diye iki mesaj arasında en az bir dakika bekler. Botun kurulumunu ve komutlarla iki yönlü kontrolü ESP32 Telegram botu yazısında ayrıntılı anlattık.

1. Telegram'da @BotFather ile konuş, /newbot komutunu gönder, botuna bir ad ver ve sana verdiği token'ı kopyala.
2. @userinfobot gibi bir kimlik botunu bul ve Başlat'a bas; bot sana kendi sohbet kimliğini (chat ID) gönderir.
3. Kendi botunu Telegram'da bul ve Başlat'a (Start) bas; bunu yapmazsan bot sana mesaj gönderemez.
4. Arduino IDE'de Kütüphane Yöneticisi'nden UniversalTelegramBot ve ArduinoJson kütüphanelerini kur.
5. Koddaki Wi-Fi adını, şifreyi, token'ı ve chat ID'yi kendi bilgilerinle değiştir, kart olarak ESP32'yi seç ve kodu yükle.

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}

sendMessage() çağrısı güvenli bir HTTPS bağlantısı kurduğu için bir iki saniye sürebilir; bu sırada buzzer'ın deseni kısa bir süre donar, bu normaldir. Kod açılışta Wi-Fi'ye en fazla 15 saniye bağlanmaya çalışır, bağlantı yoksa alarmı yerel olarak çalıştırmaya devam eder ve gönderilemeyen mesajı bir dakika sonra yeniden dener; yani internet olmasa bile buzzer susmaz. AO çıkışını da okumak istersen ESP32'de onu mutlaka bir ADC1 pinine (GPIO 32–39) bağla, çünkü ADC2 pinleri Wi-Fi açıkken kullanılamaz; tablodaki GPIO 34 bu yüzden seçildi. Kartının güvenli pinlerini Pinout aracında görebilirsin. 5 V'luk bir aktif buzzer 3,3 V'luk pinde cılız öterse onu bir transistörle 5 V'tan sür. Wi-Fi olmayan bir depo ya da bağ evi için aynı alarmı SIM800L GSM modülüyle SMS gönderecek şekilde de kurabilirsin.

Raspberry Pi Pico ve MicroPython ile alev sensörü

Raspberry Pi Pico'da da aynı mantık geçerlidir. Modülü 3V3(OUT) pininden besle, DO'yu GP15'e, varsa AO'yu GP26'ya bağla. Modülün DO hattında kendi çekme (pull-up) direnci bulunduğu için Pico'nun dahili pull-up direncine gerek yoktur. Pico'nun ADC'si 12 bittir, ancak MicroPython'daki read_u16() sonucu 0–65535 aralığına ölçekler; yani Arduino'daki 1023'ün karşılığı burada yaklaşık 65535'tir. Kod, DO'daki kısa kesintileri tolere eden 300 ms'lik bir tutma süresi ve 1,5 saniyelik bir doğrulama kullanır:

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)

Thonny'de kodu çalıştırdığında AO değerini ve alarm durumunu kabuk (Shell) penceresinde görürsün; Görünüm menüsünden Çizici'yi (Plotter) açarsan değerleri grafik olarak izleyebilirsin. Programın Pico'ya güç verildiğinde kendiliğinden başlaması için dosyayı Pico'ya main.py adıyla kaydet. Zaman ölçümünde time.ticks_diff() kullanmak önemlidir, çünkü ticks_ms() sayacı belirli bir değerden sonra başa döner ve doğrudan çıkarma işlemi o anda yanlış sonuç verir.

Alev sensörü ile proje fikirleri

• Mutfak yangın alarmı: Ocağa bakan bir alev sensörü ve bir MQ-2 ile yukarıdaki iki kademeli mantığı kullanan bir alarm kur.
• Unutulan ocak uyarısı: Alev 30 dakikadan uzun süre kesintisiz görülürse buzzer çalsın ve telefona mesaj gitsin.
• Yangın söndüren robot: 5 kanallı sensörle alevin yönünü bul, robotu L298N ve DC motorlarla aleve sür ve mini su pompasıyla mumu söndür.
• Alev yönü tarayıcı: Tek bir sensörü bir servo motorun üzerine koy, 0–180 derece tara ve en güçlü sinyalin geldiği açıyı ekrana yaz.
• Akıllı ev güvenlik paneli: Alev, gaz ve hareket sensörlerini tek bir kartta topla; ayrıntılar Arduino akıllı ev projesi yazısında.
• Atölye bekçisi: Lehim istasyonunun çevresinde beklenmedik bir alev görülünce bir röle üzerinden ikaz lambasını yak.
• Mum söndürme yarışması: Okul robot yarışmalarındaki gibi labirentte mumu en kısa sürede bulup söndüren bir robot yap; alev sensörü bunun için yeterli bir başlangıçtır.

Sık yapılan hatalar ve çözümleri

Alev sensörü; kızılötesi ışığın fiziğini, karşılaştırıcı devreleri ve yanlış alarmla mücadeleyi aynı anda öğreten ucuz ama öğretici bir parçadır. Basit bir DO alarmıyla başla, sonra analog okuma, titreşim analizi ve MQ-2 ile sistemini adım adım güçlendir; daha kapsamlı bir güvenlik sistemi için Arduino alarm sistemi yazısına göz at. BlueGrays uygulamasında alev sensörü kullanımı, alev ve gaz sensörü alarmı, ESP32 ile MQ-2 duman dedektörü ve Telegram bildirimli ESP32 alarm sistemi projelerini devre şemaları ve hazır kodlarıyla adım adım bulabilirsin.