Tutorial Sensor Api Arduino: Pengkabelan, Kode, dan Alarm Kebakaran

Sensor api (flame sensor) adalah modul murah yang mendeteksi cahaya inframerah dari korek api, lilin, atau kertas yang terbakar, dan kamu bisa memakainya dengan Arduino hanya dengan beberapa baris kode. Memakai sensor api dengan Arduino tidak butuh library: pin DO pada modul berubah status ketika melihat api, dan pin AO pada versi 4 pin memberikan tegangan yang berubah sesuai intensitas api. Sensor ini termasuk yang paling populer untuk alarm kebakaran, robot pemadam api, sistem keamanan dapur, dan proyek sekolah.

Di panduan ini kamu akan mempelajari apa isi sensor api dan mengapa ia hanya bereaksi terhadap cahaya antara 760 dan 1100 nm, apa beda output digital dan analog, cara mengatur potensiometer sensitivitas dengan benar, serta berapa jangkauan dan sudut deteksinya. Setelah itu kamu akan membuat alarm kebakaran dengan buzzer dan LED, menggabungkan sensor dengan sensor gas MQ-2, mengurangi alarm palsu dari sumber seperti sinar matahari dan remote TV lewat software, mengirim notifikasi Telegram ke ponselmu dengan ESP32, dan menjalankan rangkaian yang sama di Raspberry Pi Pico dengan MicroPython.

Apa itu sensor api dan bagaimana cara kerjanya?

Bagian hitam mirip LED di ujung modul sebenarnya adalah fototransistor inframerah (di beberapa board berupa fotodioda); contoh yang umum adalah YG1006. Badan epoksi hitamnya menyaring sebagian besar cahaya tampak dan hanya meloloskan cahaya inframerah dekat sekitar 760 sampai 1100 nm, dengan sensitivitas puncak di sekitar 940 nm. Batas atasnya berasal dari silikon itu sendiri: dengan celah pita (band gap) 1,12 eV, silikon tidak bisa menyerap foton dengan panjang gelombang lebih dari sekitar 1100 nm. Karena partikel jelaga panas di dalam api juga memancar di pita ini, arus yang melewati fototransistor naik ketika api makin dekat. Pembagi tegangan di board mengubah arus itu menjadi tegangan, lalu komparator LM393 membandingkannya dengan ambang yang kamu atur di potensiometer untuk menentukan status pin DO.

Ada beberapa jenis board sensor api yang melakukan pekerjaan yang sama. Modul 3 pin seperti di foto atas hanya punya output digital; modul 4 pin menambahkan output analog. KY-026 yang mungkin kamu kenal dari kit sensor bekerja dengan cara yang sama, tetapi output DO-nya biasanya terbalik. Robot pemadam api memakai board multi-kanal dengan lima penerima yang disusun seperti kipas. Sensor api bersifat pasif, artinya tidak memancarkan cahaya sendiri; inilah yang membedakannya dari sensor inframerah TCRT5000, yang punya pemancar sekaligus penerima.

Output digital (DO) vs analog (AO)

Pin DO memberi jawaban ya/tidak: statusnya berubah ketika cahaya inframerah melewati ambang yang kamu atur di potensiometer. Pada board biru yang umum, pin ini normalnya HIGH, menjadi LOW ketika melihat api, dan LED DO menyala; pada beberapa board seperti KY-026 kebalikannya. Jadi hal pertama yang perlu kamu lakukan adalah menguji modulmu sendiri dengan korek api dan melihat apa yang ditampilkan Serial Monitor. Pin AO memberikan sinyal mentah. Pada kebanyakan modul nilai ini turun ketika api mendekat: nilai analogRead 900–1020 di ruangan tanpa api bisa turun menjadi beberapa ratus ketika ada korek api di dekatnya. Potensiometer hanya mengubah ambang DO dan tidak berpengaruh pada AO.

Cara mengatur potensiometer sensitivitas

1. Nyalakan modul dan letakkan sensor di tempat ia akan bekerja, menghadap arah yang akan diawasinya; selalu lakukan pengaturan ini di lingkungan sebenarnya.
2. Tanpa ada api, putar potensiometer biru dengan obeng kecil dan cari titik di mana LED DO berpindah antara menyala dan mati.
3. Dari titik itu, putar lagi setengah sampai satu putaran penuh ke arah di mana LED tetap mati. Dengan begitu perubahan kecil cahaya sekitar tidak akan memicu alarm.
4. Arahkan korek api ke sensor dari jarak terjauh yang ingin kamu deteksi dan pastikan LED menyala. Kalau tidak menyala, buat pengaturannya sedikit lebih sensitif lalu coba lagi.
5. Pastikan sensor tidak menghadap jendela yang terkena matahari atau lampu pijar, lalu periksa lagi pengaturannya beberapa jam kemudian dengan pencahayaan yang berbeda.

Jangkauan dan sudut deteksi

Angka seperti 80 cm yang diberikan produsen mengacu pada api korek standar; jangkauan sebenarnya bergantung pada ukuran api, pengaturan potensiometer, dan cahaya sekitar. Di sini berlaku hukum fisika sederhana: intensitas cahaya dari sumber kecil turun sebanding dengan kuadrat jarak. Gandakan jaraknya, maka cahaya inframerah yang sampai ke sensor turun menjadi seperempat. Dilihat dari sisi lain, api yang memancarkan cahaya empat kali lebih banyak bisa dideteksi dari jarak dua kali lebih jauh, dan api seratus kali lebih kuat dari jarak sepuluh kali lebih jauh. Itulah sebabnya api lilin terdeteksi pada jarak yang lebih pendek daripada korek api, sedangkan tumpukan kertas yang terbakar bisa dideteksi dari beberapa meter.

Sudut deteksinya sekitar 60 derajat, jadi sensor melihat api di dalam kerucut sekitar 30 derajat ke tiap sisi sumbunya, dan sinyal cepat melemah ketika api bergeser ke tepi kerucut itu. Penerimanya berkaki panjang, jadi kamu bisa menekuknya perlahan agar menghadap ke arah mana pun, tetapi menekuk berulang-ulang titik tempat kaki masuk ke badan akan membuatnya patah. Untuk mempersempit bidang pandang, pasang tabung hitam doff di atas penerima: tabung dengan diameter dalam 6 mm dan panjang 2 cm memotong sudutnya menjadi sekitar 30 derajat dan menghalangi sinar matahari atau cahaya lampu dari samping. Bidang pandang sebaiknya cukup lebar untuk menutupi area yang ingin kamu awasi saja; yang lebih lebar hanya menambah sumber alarm palsu baru.

Pengkabelan sensor api: Arduino Uno, ESP32, dan Pico

Langkah demi langkah: alarm kebakaran dengan sensor api dan Arduino

1. Hubungkan pin VCC modul ke pin 5V Arduino, GND ke GND, dan DO ke D2.
2. Hubungkan kaki panjang (+) buzzer aktif ke D8 dan kaki pendeknya ke GND.
3. Hubungkan kaki panjang LED merah ke D7 lewat resistor 220 Ω dan kaki pendeknya ke GND. Kalau kamu memakai LED lain, nilai resistornya bisa kamu hitung dengan kalkulator resistor LED.
4. Upload kode di bawah, buka Serial Monitor pada 9600 baud, lalu arahkan korek api sebentar ke sensor dari jarak 20–30 cm.
5. Kalau buzzer berbunyi dan LED menyala, rangkaiannya bekerja; kalau alarm berbunyi tanpa api dan diam ketika ada api, ubah FLAME_ACTIVE di kode menjadi HIGH.

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}

Di setiap putaran, kode membaca pin DO dan membandingkan hasilnya dengan konstanta FLAME_ACTIVE. Berkat konstanta ini, kode yang sama bekerja dengan modul biru yang menjadi LOW ketika ada api maupun dengan KY-026 yang menjadi HIGH. Selama api terlihat, LED tetap menyala, sedangkan buzzer menyala-mati setiap 150 ms sehingga menghasilkan bunyi bip yang menarik perhatian. Buzzer aktif punya osilator sendiri, jadi cukup diberi HIGH dan LOW; kalau kamu punya buzzer pasif, pakai tone() alih-alih digitalWrite, seperti dijelaskan di Apa Itu Buzzer?. Ada alasan lain mengapa kami memilih D2 untuk pin DO: di Uno, D2 adalah salah satu dari dua pin yang mendukung interrupt, jadi dengan attachInterrupt kamu bisa menangkap api tanpa menunggu sisa loop selesai.

Pembacaan analog: intensitas api dan perkiraan jarak

Kalau kamu punya modul 4 pin, output AO memungkinkan jauh lebih banyak hal. Karena nilai mentahnya berbeda di setiap lingkungan, pakai metode ini alih-alih ambang tetap: ketika mulai menyala dan tidak ada api, ukur nilai dasar (baseline), lalu lihat seberapa jauh setiap pembacaan baru menyimpang darinya. Kode di bawah merata-ratakan 16 pembacaan untuk mengurangi noise, menghitung penyimpangan itu sebagai kekuatan api, dan memberi tahu kira-kira apakah api dekat atau jauh. Kalau nilai AO modulmu justru naik ketika ada api, cukup atur DROPS_WITH_FLAME menjadi 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}

Ambang 100 dan 400 di kode hanyalah titik awal. Untuk menyesuaikannya dengan sensormu sendiri, upload kode, buka Serial Monitor, dan catat kekuatan api ketika korek api berada di jarak 10, 30, dan 60 cm; karena hukum kuadrat terbalik, kamu akan melihat nilainya berubah sangat cepat di jarak dekat dan lambat di jarak jauh. Itulah sebabnya jarak yang tepat dalam sentimeter tidak bisa dihitung dari nilai analog: nilai yang sama bisa berasal dari api kecil di dekat sensor atau api besar di kejauhan. Cara ADC menghasilkan nilai mentah bisa kamu pelajari di konversi analog ke digital, dan detail Serial Monitor di Serial Monitor Arduino.

Sinar matahari dan sumber alarm palsu lainnya

Sensor api tidak melihat api; ia melihat cahaya inframerah di pita tertentu, dan apa pun yang memancarkan cahaya di pita itu bisa memicunya. Hukum Wien menjelaskan sumber mana yang menimbulkan masalah: panjang gelombang di mana benda panas memancar paling kuat kira-kira 2898 / T mikrometer (T adalah suhu dalam kelvin). Matahari dan bohlam pijar memancar kuat tepat di pita sensor, sedangkan tubuh manusia terlalu dingin, jadi sensor sama sekali tidak bisa melihatmu. Karena itu untuk mendeteksi gerakan dibutuhkan sensor PIR, yang melihat panjang gelombang yang jauh lebih panjang.

Sebagian besar alarm palsu bisa kamu cegah lewat hardware: letakkan sensor agar tidak menghadap jendela, dinding yang terkena matahari, atau lampu pijar, idealnya mengarah ke bawah dan ke dalam ruangan, persempit bidang pandangnya dengan tabung hitam, dan atur potensiometer di bawah pencahayaan sekitar yang sebenarnya. Ingat bahwa sinar matahari yang kuat tidak hanya menimbulkan alarm palsu, tetapi juga bisa membutakan sensor karena membuatnya jenuh: kalau nilai AO sudah turun ke titik minimumnya di bawah matahari, tidak ada lagi yang bisa berubah ketika api sungguhan muncul. Detektor api inframerah profesional mengatasi ini dengan melihat pita 4,3 µm, tempat karbon dioksida panas memancar dan sinar matahari sebagian besar diserap atmosfer, dengan membandingkan beberapa panjang gelombang, dan dengan menganalisis kedipan api. Modulmu tidak bisa melakukan dua cara pertama, tetapi analisis kedipan dan konfirmasi waktu bisa kamu tiru lewat software.

Mengurangi alarm palsu lewat software: konfirmasi waktu dan analisis kedipan

Api sungguhan tidak pernah menyala dengan stabil; aliran udara dan gas panas yang naik membuat kecerahannya berfluktuasi kira-kira 1 sampai 20 kali per detik. Sebaliknya, sinar matahari dan cahaya bohlam pijar hampir konstan dalam waktu singkat, dan pulsa dari remote hanya berlangsung beberapa milidetik. Kode di bawah memanfaatkan perbedaan ini dengan tiga aturan: kekuatan api harus jelas di atas nilai dasar, nilainya harus berfluktuasi lebih dari batas tertentu dalam satu detik terakhir, dan kedua syarat itu harus terpenuhi tanpa terputus selama minimal dua detik. Selain itu, setiap pembacaan adalah rata-rata dari 20 sampel yang diambil selama 10 ms. Pada listrik 50 Hz, lampu sedikit berkedip 100 kali per detik; merata-ratakan selama 10 ms, tepat satu periode kedipan, menghapus riak ini sehingga lampu tidak dikira api yang berkedip.

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}

Karena kode mengatur waktu dengan millis() alih-alih delay(), ia tetap mengukur bahkan ketika alarm sedang berbunyi; detail pendekatan ini ada di millis vs delay. Nilai dasar juga tidak tetap: ketika tidak ada api, nilainya bergeser 5 persen ke arah pembacaan terbaru sekali per detik dan perlahan mengikuti cahaya sekitar yang berubah sepanjang hari. Untuk menemukan FLICKER_LIMIT yang baik, amati ayunan satu detik dari sumber cahaya yang stabil di Serial Monitor, lalu ayunan api lilin, dan atur ambangnya di antara keduanya. Metode ini tidak sempurna; sinar matahari yang menembus dedaunan yang bergoyang tertiup angin juga berkedip. Teknik lain seperti filter rata-rata bergerak (moving average) dan median bisa kamu temukan di menyaring data sensor.

Memakainya bersama sensor gas MQ-2

Sensor api dan sensor gas MQ-2 saling menutupi kelemahan masing-masing. Sensor api sangat cepat, tetapi hanya melihat api di dalam bidang pandangnya dan bisa tertipu oleh matahari. MQ-2 mendeteksi asap dan gas mudah terbakar, dan bisa menyadari kebakaran di balik tikungan atau bara yang membara tanpa api, tetapi asap butuh waktu untuk sampai ke sensor dan sensor ini perlu pemanasan setiap kali dinyalakan. Ketika memakai keduanya, kamu bisa menganggap sinyal dari satu sensor sebagai peringatan dan sinyal dari keduanya sekaligus sebagai kebakaran.

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}

Hubungkan output AO MQ-2 ke A1 dan beri daya modul dari 5V; sensor api tetap di D2. Atur SMOKE_LIMIT jelas di atas nilai yang kamu baca setelah sensor dijalankan beberapa menit di udara bersih, seperti dijelaskan di panduan MQ-2. Syarat asap diabaikan selama 60 detik pertama karena MQ-2 yang masih dingin dimulai dengan pembacaan tinggi. Waktu tahan 300 ms pada sinyal api (HOLD_MS) mengubah output DO yang sebentar-sebentar menyala-mati akibat api yang berkedip menjadi satu deteksi yang terus-menerus. Kalau kombinasi ini kamu pindahkan ke ESP32, hati-hati: MQ-2 butuh 5 V dan output AO-nya bisa mencapai 5 V, jadi kamu wajib memasang pembagi tegangan di outputnya, sedangkan sensor api berjalan langsung dari 3V3.

Notifikasi kebakaran ke ponselmu dengan ESP32 (Telegram)

Agar alarm tidak hanya memperingatkan orang di dalam ruangan tetapi juga kamu ketika sedang pergi, kamu bisa memakai ESP32. Bot Telegram adalah cara termudah untuk ini: gratis, tidak butuh server sendiri, dan pesannya langsung sampai ke ponselmu sebagai notifikasi. Kode di bawah membunyikan buzzer dan mengirim pesan Telegram begitu api terlihat selama 1,5 detik, lalu menunggu minimal satu menit di antara pesan agar ponselmu tidak dibanjiri pesan untuk kebakaran yang sama. Cara menyiapkan bot dan kendali dua arah dengan perintah kami bahas lengkap di bot Telegram ESP32.

1. Di Telegram, mulai obrolan dengan @BotFather, kirim perintah /newbot, beri nama bot-mu, lalu salin token yang diberikannya.
2. Buka bot ID seperti @userinfobot dan ketuk Start; bot itu membalas dengan chat ID milikmu.
3. Cari bot barumu di Telegram dan ketuk Start; kalau langkah ini dilewati, bot tidak bisa mengirim pesan kepadamu.
4. Di Arduino IDE, instal library UniversalTelegramBot dan ArduinoJson dari Library Manager.
5. Ganti nama Wi-Fi, kata sandi, token, dan chat ID di kode dengan milikmu, pilih ESP32 sebagai board, lalu upload kodenya.

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}

Panggilan sendMessage() membuka koneksi HTTPS yang aman, jadi bisa memakan waktu satu atau dua detik; pola bunyi buzzer sempat berhenti sebentar selama itu, dan itu normal. Ketika mulai menyala, kode mencoba terhubung ke Wi-Fi hingga 15 detik; kalau tidak ada koneksi, alarm tetap berjalan secara lokal dan pesan yang belum terkirim dicoba lagi semenit kemudian, jadi buzzer tetap berbunyi meski tanpa internet. Kalau kamu juga ingin membaca output AO di ESP32, selalu hubungkan ke pin ADC1 (GPIO 32–39), karena pin ADC2 tidak bisa dipakai selama Wi-Fi aktif; itulah sebabnya GPIO 34 dipilih di tabel. Pin yang aman di board-mu bisa kamu lihat di alat Pinout. Kalau buzzer aktif 5 V terdengar lemah di pin 3,3 V, kendalikan dari 5 V dengan transistor. Untuk gudang atau rumah liburan tanpa Wi-Fi, kamu bisa membuat alarm yang sama agar mengirim SMS dengan modul GSM SIM800L.

Sensor api dengan Raspberry Pi Pico dan MicroPython

Logika yang sama berlaku di Raspberry Pi Pico. Beri daya modul dari pin 3V3(OUT), hubungkan DO ke GP15 dan, kalau ada, AO ke GP26. Modul punya resistor pull-up sendiri di jalur DO, jadi kamu tidak butuh pull-up internal Pico. ADC Pico 12-bit, tetapi read_u16() di MicroPython menskalakan hasilnya ke 0–65535, jadi padanan 1023 di Arduino di sini sekitar 65535. Kode memakai waktu tahan 300 ms yang menoleransi celah singkat pada DO dan konfirmasi 1,5 detik:

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)

Ketika menjalankan kode di Thonny, kamu akan melihat nilai AO dan status alarm di jendela Shell; buka Plotter dari menu View untuk mengikuti nilainya dalam bentuk grafik. Agar program mulai otomatis ketika Pico dinyalakan, simpan file ke Pico dengan nama main.py. Memakai time.ticks_diff() untuk pengaturan waktu itu penting, karena penghitung ticks_ms() kembali ke nol setelah nilai tertentu dan pengurangan biasa memberi hasil yang salah pada momen itu.

Ide proyek sensor api

• Alarm kebakaran dapur: Buat alarm dengan sensor api yang menghadap kompor dan MQ-2, memakai logika dua tingkat di atas.
• Pengingat kompor yang lupa dimatikan: Kalau api terlihat terus-menerus lebih dari 30 menit, bunyikan buzzer dan kirim pesan ke ponselmu.
• Robot pemadam api: Cari arah api dengan sensor 5 kanal, gerakkan robot ke arahnya dengan L298N dan motor DC, lalu padamkan lilin dengan pompa air mini.
• Pemindai arah api: Pasang satu sensor di motor servo, sapu dari 0 sampai 180 derajat, dan tampilkan sudut dengan sinyal terkuat.
• Panel keamanan rumah pintar: Gabungkan sensor api, gas, dan gerak di satu board; detailnya ada di proyek rumah pintar Arduino.
• Penjaga bengkel: Ketika muncul api tak terduga di dekat stasiun solder, nyalakan lampu peringatan lewat relay.
• Lomba memadamkan lilin: Seperti di kompetisi robotik sekolah, buat robot yang menemukan dan memadamkan lilin di dalam labirin secepat mungkin; untuk memulainya kamu cukup butuh sensor api.

Kesalahan umum dan cara mengatasinya

Sensor api adalah komponen murah tetapi sarat pelajaran yang sekaligus mengajarkan fisika cahaya inframerah, rangkaian komparator, dan cara melawan alarm palsu. Mulailah dengan alarm DO sederhana, lalu perkuat sistemmu langkah demi langkah dengan pembacaan analog, analisis kedipan, dan MQ-2; untuk sistem keamanan yang lebih lengkap, lihat sistem alarm Arduino. Di aplikasi BlueGrays kamu akan menemukan proyek Menggunakan Sensor Api, Alarm Sensor Api dan Gas, Alarm Detektor Gas/Asap MQ-2 ESP32, serta Sistem Alarm Gerakan ESP32 dengan notifikasi Telegram, masing-masing dengan skema rangkaian langkah demi langkah dan kode siap pakai.