Gidsen · 15 min leestijd

ESP32 Telegram-bot: meldingen, led en relais bedienen

Bouw een ESP32 Telegram-bot: BotFather-token, chat-ID, UniversalTelegramBot instellen, bewegings- en gasmeldingen, relais bedienen met commando's en alleen antwoord aan jou.

Met een ESP32 Telegram-bot kan het ESP32-board bij jou thuis berichten naar je telefoon sturen en commando's uitvoeren die jij terugstuurt. Is er beweging bij de deur of gas in de keuken, dan krijg je meteen een melding in je zak; typ "/ac" en een relais schakelt een lamp in, typ "/kapat" en hij gaat weer uit. Je hoeft geen eigen telefoon-app te schrijven, geen poort op je router open te zetten en niet voor een clouddienst te betalen: de gratis Bot API van Telegram en de ingebouwde wifi van de ESP32 zijn genoeg.

In deze gids bouw je vanaf nul een werkend systeem: je maakt een bot met BotFather en haalt het token op, zoekt je eigen chat-ID op, installeert de bibliotheken UniversalTelegramBot en ArduinoJson en stuurt je eerste bericht vanaf de ESP32. Daarna voeg je bewegings- en gasmeldingen toe met een PIR-sensor en een MQ-2-gassensor, plus led- en relaisbediening via Telegram-commando's. We behandelen ook hoe je de bot alleen op jouw ID laat reageren, de certificaatinstelling, de verschillen op de ESP8266 en de Raspberry Pi Pico W en de meest voorkomende fouten, stuk voor stuk.

ESP32-developmentboard dat werkt als Telegram-bot
Dankzij de ingebouwde wifi maakt de ESP32 rechtstreeks verbinding met de Telegram-server; een extra module of gateway is niet nodig.

Wat is een ESP32 Telegram-bot en hoe werkt hij?

Op Telegram is een bot een speciaal account dat door een programma wordt bestuurd in plaats van door een persoon; in ons project draait de ESP32 dat programma. De ESP32 en je telefoon maken nooit rechtstreeks verbinding met elkaar; ze praten allebei met de Telegram-server. Als je op je telefoon "/ac" naar de bot typt, wacht het bericht op de server. Elke seconde stuurt de ESP32 een versleuteld HTTPS-verzoek (getUpdates) naar api.telegram.org met de vraag "zijn er nieuwe berichten voor mij?", haalt het bericht op en voert het uit. Om een melding te sturen doet hij een sendMessage-verzoek in de andere richting. Omdat de ESP32 de verbinding altijd zelf opent, heb je geen port forwarding of vast IP-adres op je router nodig; het board werkt op elk 2,4 GHz-wifinetwerk met internet.

TermWat het doetVoorbeeld
BotFatherDe bot van Telegram om bots te maken en te beheren/newbot, /setcommands, /revoke
Bot tokenHet wachtwoord van de bot; je code maakt er verbinding met Telegram mee1234567890:AAE... (getal, dubbele punt, lange reeks tekens)
Chat IDHet nummer van de persoon of groep waarnaar een bericht gaatPersoon: 123456789, groep: -1001234567890
getUpdatesHaalt nieuwe berichten die naar de bot zijn gestuurd op van de serverbot.getUpdates(...)
sendMessageStuurt een bericht naar de opgegeven chat-IDbot.sendMessage(CHAT_ID, "Hello")
CommandoEen kort bericht dat met / begint en dat de bot begrijpt/ac, /kapat, /durum

Waarom Telegram? Vergeleken met andere manieren om meldingen te krijgen

MethodeVoordelenNadelenHet best voor
Telegram-botGratis, directe meldingen, commando's in twee richtingen, geen open poorten nodigGeen grafieken of kant-en-klaar dashboardAlarmen en eenvoudige bediening op afstand
Blynk IoTKant-en-klare knoppen, meters en grafiekdashboardLimieten voor berichten en apparaten in het gratis abonnementDashboards voor sensormonitoring
E-mail (SMTP)Werkt op elke telefoon, kan lange rapporten bevattenVertraagd, lastig om commando's te ontvangenDagelijkse rapporten
SMS (SIM800L)Geen wifi of internet nodigSimkaart en sms-kosten, extra moduleHutten of schuurtjes zonder internet
ESP32-webserverVolledig lokaal en gratisMeestal alleen bereikbaar vanaf hetzelfde netwerk, geen meldingenBedieningspaneel in huis

Kortom: Telegram is de makkelijkste en goedkoopste optie voor projecten in de trant van "laat me weten als er iets gebeurt en doe dit als ik een commando stuur". Wil je sensorgegevens op grafieken volgen, dan past de Blynk ESP32-tutorial misschien beter bij je; heb je meldingen nodig op een plek zonder wifi, bekijk dan de gids over de SIM800L GSM-module.

Stap 1: een bot maken met BotFather en het token ophalen

  1. Open Telegram op je telefoon of computer, typ BotFather in het zoekvak en kies het officiële account met het blauwe vinkje naast de naam. Pas op voor nepaccounts met een vergelijkbare naam.
  2. Tik op Start en stuur het commando /newbot.
  3. BotFather vraagt eerst om de weergavenaam van de bot; typ een naam naar keuze, bijvoorbeeld "Home Alarm".
  4. Daarna vraagt hij om een gebruikersnaam. Die moet uniek zijn, mag alleen Latijnse letters, cijfers en underscores bevatten en moet eindigen op bot, bijvoorbeeld my_home_alarm_bot. Is hij al bezet, voeg dan een cijfer aan het eind toe en probeer opnieuw.
  5. BotFather antwoordt met "Done! Congratulations on your new bot." plus de link naar je bot en het token. Het token ziet eruit als 1234567890:AAE...: een getal, een dubbele punt en een lange reeks tekens. Kopieer het helemaal en bewaar het op een veilige plek.
  6. Tik op de link die BotFather stuurde om je bot te openen en druk op Start. Deze stap is essentieel: bots op Telegram kunnen niet als eerste een bericht naar een gebruiker sturen, dus jij moet het gesprek altijd beginnen.
Het token is de sleutel van je bot: wie het in handen krijgt, kan de berichten lezen die naar je bot worden gestuurd, berichten in zijn naam versturen en de commando's voor je ESP32 onderscheppen voordat hij ze zelf ontvangt. Deel code met het token nooit op forums, in screenshots of in een openbare GitHub-repository. Denk je dat het gelekt is, gebruik dan het commando /revoke in BotFather om het oude token in te trekken, vraag een nieuw token op en upload je code opnieuw.

Stap 2: je Telegram chat-ID vinden

Het bottoken beantwoordt de vraag "welke bot?", terwijl de chat-ID antwoord geeft op "wie krijgt het bericht?". Elke Telegram-gebruiker, groep en elk kanaal heeft een vast numeriek ID, dat niet hetzelfde is als je gebruikersnaam met @. Er zijn drie makkelijke manieren om je eigen chat-ID te vinden:

  1. Met een ID-bot: zoek op Telegram een ID-bot zoals @userinfobot en druk op Start; die stuurt je nummer op de regel Id. Deze bots zijn niet van jou, ze tonen alleen je ID.
  2. Met je browser: stuur eerst een willekeurig bericht naar je eigen bot. Open daarna api.telegram.org/botTOKEN/getUpdates in de browser van je computer (plak je eigen token in plaats van TOKEN en laat het woord "bot" ervoor staan). In de tekst die verschijnt is het getal in "chat":{"id":123456789 je chat-ID. Toont de pagina een lege resultatenlijst, stuur de bot dan opnieuw een bericht en laad de pagina opnieuw.
  3. Met de ESP32: zodra je de commandocode hieronder uploadt, wordt het ID van iedereen die niet is geautoriseerd op een regel "unauthorized ID" naar de Serial Monitor geschreven. Wil je een familielid toevoegen, laat die dan de bot een bericht sturen en lees het nummer daar af.
Gebruik je de bot in een familiegroep, voeg hem dan toe aan de groep, plaats daar een bericht en bekijk de getUpdates-pagina opnieuw: groeps-ID's beginnen met een minteken en supergroep-ID's met -100. Het minteken vergeten is de meest voorkomende oorzaak van de fout "chat not found". In de standaard privacymodus leest de bot de groepschat niet; hij ziet alleen commando's die met / beginnen en aan hem gericht zijn, en dat is alles wat een commandogestuurde bot nodig heeft.

Stap 3: UniversalTelegramBot en ArduinoJson installeren

  1. Als het ESP32-boardpakket nog niet in de Arduino IDE is geïnstalleerd, doe dat dan eerst; de stappen staan in Wat is de ESP32?.
  2. Open Tools › Manage Libraries, typ UniversalTelegramBot in het zoekvak en installeer de bibliotheek van Brian Lough. De code in deze gids is gecompileerd met UniversalTelegramBot 1.3.0, ArduinoJson 7 en versie 2.0.11 van het ESP32-boardpakket.
  3. Vraagt het installatieprogramma naar afhankelijkheden, kies dan Install all; doet het dat niet, zoek dan in hetzelfde venster naar ArduinoJson en installeer de bibliotheek van Benoit Blanchon apart.
  4. Onder File › Examples › UniversalTelegramBot › ESP32 vind je kant-en-klare voorbeelden zoals FlashLED; de code in deze gids is een vereenvoudigde versie daarvan met extra beveiliging.

UniversalTelegramBot is geschreven in de stijl van ArduinoJson versie 6, maar compileert prima met ArduinoJson 7. Heb je compilerwaarschuwingen aangezet in de Arduino IDE, dan zie je regels als "'DynamicJsonDocument' is deprecated: use JsonDocument instead"; dat zijn waarschuwingen, geen fouten, en het programma werkt gewoon. Als je problemen hebt met het installeren van bibliotheken, bekijk dan de gids Een Arduino-bibliotheek toevoegen.

Onderdelen en bedrading

Voor het complete project heb je een ESP32-developmentboard, een HC-SR501 PIR-bewegingssensor, een MQ-2-gassensormodule, een 5V-relaismodule, een weerstand van 10 kΩ en een van 20 kΩ, een breadboard en jumperdraden nodig. Voor de led gebruiken we de ingebouwde blauwe led van de ESP32 op GPIO 2. Om de eerste twee stappen uit te proberen heb je alleen de ESP32 en een USB-kabel nodig; de sensoren kun je later toevoegen.

ESP32
ESP32
PIR HC-SR501
PIR HC-SR501
MQ-2
MQ-2
Relaismodule
Relaismodule
AansluitingESP32ESP8266 (NodeMCU)Raspberry Pi Pico W
PIR VCCVIN (5V)VIN (5V)VBUS (5V)
PIR OUTGPIO 27D5 (GPIO 14)GP16
MQ-2 VCCVIN (5V)VIN (5V)VBUS (5V)
MQ-2 AO (via een spanningsdeler van 10 kΩ / 20 kΩ)GPIO 34A0GP26 (ADC0)
Relais-VCCVIN (5V)VIN (5V)VBUS (5V)
Relais-INGPIO 26D1 (GPIO 5)GP15
LEDGPIO 2 (ingebouwd)D4 (ingebouwd, brandt bij LOW)"LED" (ingebouwd)
Alle GND-pinnenGNDGNDGND
De pinnen van de ESP32, ESP8266 en Pico werken op 3,3 V. Wordt de MQ-2-module op 5 V gevoed, dan kan de AO-uitgang oplopen tot 5 V, dus bouw een spanningsdeler: verbind AO via 10 kΩ met de analoge pin en de analoge pin via 20 kΩ met GND. Daarmee gaat 5 V terug naar ongeveer 3,3 V. Schakel je met het relais een belasting op 230 V-net, bedraad het dan altijd met de stekker uit het stopcontact en vraag hulp aan een volwassene; details staan in Wat is een relaismodule?.

Let ook op de voeding: alleen al het verwarmingselement van de MQ-2 trekt ongeveer 150 mA en de relaisspoel zo'n 70 mA, terwijl de ESP32 bij het versturen over wifi kortstondig pieken tot 250 mA kan halen. Een USB-poort van een computer kan dat totaal niet altijd leveren en het board kan herstarten precies op het moment dat hij een bericht verstuurt. Gebruik een 5V-adapter van minstens 1 A en een goede kabel; houdt het probleem aan, lees dan ESP32 Brownout en Guru Meditation. Alle pins van je board zie je in de tool Pinout.

Eerste test: een bericht van de ESP32 naar Telegram sturen

Voordat we naar de sensoren gaan, controleren we het token en de chat-ID met de eenvoudigst mogelijke sketch. Vervang in de code hieronder de regels met de wifinaam, het wachtwoord, BOT_TOKEN en CHAT_ID door je eigen gegevens en upload de code naar het board. Open daarna de Serial Monitor op 115200 baud:

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <UniversalTelegramBot.h>
4#include <ArduinoJson.h>
5
6const char* WIFI_SSID = "AgAdi";          // Wi-Fi adın (yalnız 2,4 GHz) / your Wi-Fi name (2.4 GHz only)
7const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifren / your Wi-Fi password
8#define BOT_TOKEN "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"   // BotFather'ın verdiği token / token from BotFather
9#define CHAT_ID   "123456789"             // kendi Telegram ID'n / your own Telegram ID
10
11WiFiClientSecure client;                  // şifreli (HTTPS) bağlantı / encrypted (HTTPS) connection
12UniversalTelegramBot bot(BOT_TOKEN, client);
13
14void setup() {
15  Serial.begin(115200);
16  WiFi.mode(WIFI_STA);
17  WiFi.begin(WIFI_SSID, WIFI_PASS);
18  Serial.print("Wi-Fi'ye baglaniyor / connecting to Wi-Fi");
19  while (WiFi.status() != WL_CONNECTED) {
20    delay(500);
21    Serial.print(".");
22  }
23  Serial.println();
24  Serial.println(WiFi.localIP());
25
26  client.setCACert(TELEGRAM_CERTIFICATE_ROOT);   // api.telegram.org kök sertifikası / root certificate of api.telegram.org
27
28  if (bot.sendMessage(CHAT_ID, "Merhaba! ESP32 çevrimiçi / Hello! ESP32 is online")) {
29    Serial.println("Mesaj gonderildi / message sent");
30  } else {
31    Serial.println("Mesaj gonderilemedi / message failed");
32  }
33}
34
35void loop() {
36}

Binnen een paar seconden hoort je bot je "Hello! ESP32 is online" te sturen op Telegram en de Serial Monitor hoort "Mesaj gonderildi / message sent" te tonen. sendMessage() geeft true terug als het bericht is afgeleverd; zie je "message failed", dan ligt het probleem bij de wifiverbinding, het token, de chat-ID of de certificaatinstelling. Open voordat je de code de schuld geeft api.telegram.org/botTOKEN/getMe in je browser: met een geldig token zie je "ok":true en de naam van je bot, met een fout token zie je "Unauthorized".

Certificaatinstelling: setCACert of setInsecure?

Telegram accepteert alleen HTTPS, daarom gebruikt de code WiFiClientSecure in plaats van een gewone WiFiClient. Over een versleutelde verbinding moet de ESP32 controleren of de server waarmee hij praat echt api.telegram.org is; hij doet dat door het servercertificaat te verifiëren aan de hand van het rootcertificaat bovenaan de keten. UniversalTelegramBot levert dit rootcertificaat kant-en-klaar mee als TELEGRAM_CERTIFICATE_ROOT. De certificaatketen van Telegram loopt tot Go Daddy Root Certificate Authority - G2, dat geldig is tot eind 2037; schakelt Telegram ooit over naar een andere certificaatverstrekker, dan heeft ook de bibliotheek een update nodig.

InstellingWat het doetBeveiligingWanneer gebruiken
client.setCACert(TELEGRAM_CERTIFICATE_ROOT)Versleutelt de verbinding en controleert de identiteit van de serverHoogDe aanbevolen instelling, altijd
client.setInsecure()Versleutelt de verbinding maar controleert de identiteit van de server nietGemiddeld: merkt een nepserver ertussen niet opEen snelle test om certificaatproblemen uit te sluiten
Geen van beideOp huidige ESP32-cores komt de verbinding nooit tot standWerkt nietNooit: er wordt geen bericht verstuurd en er verschijnt geen fout in de Serial Monitor
ESP8266: setTrustAnchors(&cert)Het ESP8266-equivalent; het certificaat wordt doorgegeven als X509ListHoogNodeMCU en Wemos D1 Mini; heeft de juiste tijd nodig

Een led en een relais bedienen met Telegram-commando's (/ac, /kapat)

Nu maken we de bot tweerichtings. De code hieronder vraagt Telegram één keer per seconde om nieuwe berichten; is de tekst /ac (Turks voor "aan"), dan schakelt hij het relais en de led in, /kapat ("uit") schakelt ze uit, /durum ("status") meldt de huidige toestand en /start stuurt de lijst met commando's. Je kunt de commando's hernoemen naar /on en /off, maar houd er rekening mee dat Telegram-commando's alleen kleine Latijnse letters, cijfers en underscores mogen bevatten en maximaal 32 tekens lang mogen zijn. Een commando met letters met accenten, zoals "/aç", wordt niet herkend als aantikbaar commando.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <UniversalTelegramBot.h>
4#include <ArduinoJson.h>
5
6const char* WIFI_SSID = "AgAdi";
7const char* WIFI_PASS = "Sifre123";
8#define BOT_TOKEN "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
9#define CHAT_ID   "123456789"                 // yalnız bu ID'ye yanıt verilir / only this ID gets answers
10
11const int LED_PIN  = 2;                       // çoğu DevKit'te dahili LED / onboard LED on most DevKits
12const int ROLE_PIN = 26;                      // röle modülünün IN pini / relay module IN pin
13const bool ROLE_AKTIF_LOW = true;             // çoğu modül LOW'da çeker / most modules switch on with LOW
14
15const unsigned long KONTROL_ARALIGI = 1000;   // Telegram'a saniyede bir sor / ask Telegram once per second
16unsigned long sonKontrol = 0;
17bool roleAcik = false;
18
19WiFiClientSecure client;
20UniversalTelegramBot bot(BOT_TOKEN, client);
21
22void roleYaz(bool acik) {
23  roleAcik = acik;
24  if (ROLE_AKTIF_LOW) digitalWrite(ROLE_PIN, acik ? LOW : HIGH);
25  else                digitalWrite(ROLE_PIN, acik ? HIGH : LOW);
26  digitalWrite(LED_PIN, acik ? HIGH : LOW);   // LED röle durumunu gösterir / LED mirrors the relay
27}
28
29void mesajlariIsle(int adet) {
30  for (int i = 0; i < adet; i++) {
31    String chatId = bot.messages[i].chat_id;
32    String metin  = bot.messages[i].text;
33
34    // Güvenlik: tanımadığın kişiye cevap verme / security: never answer strangers
35    if (chatId != CHAT_ID) {
36      Serial.println("Yetkisiz ID / unauthorized ID: " + chatId);
37      continue;
38    }
39
40    int at = metin.indexOf('@');              // gruptaki "/ac@bot_adi" -> "/ac" / "/ac@bot_name" in groups -> "/ac"
41    if (at > 0) metin = metin.substring(0, at);
42
43    if (metin == "/start") {
44      String yardim = "Merhaba " + bot.messages[i].from_name + "!\n";
45      yardim += "/ac - röleyi aç / relay ON\n";
46      yardim += "/kapat - röleyi kapat / relay OFF\n";
47      yardim += "/durum - son durum / status";
48      bot.sendMessage(chatId, yardim);
49    } else if (metin == "/ac") {
50      roleYaz(true);
51      bot.sendMessage(chatId, "Röle AÇIK / relay ON");
52    } else if (metin == "/kapat") {
53      roleYaz(false);
54      bot.sendMessage(chatId, "Röle KAPALI / relay OFF");
55    } else if (metin == "/durum") {
56      bot.sendMessage(chatId, roleAcik ? "Röle AÇIK / relay ON" : "Röle KAPALI / relay OFF");
57    } else {
58      bot.sendMessage(chatId, "Bilinmeyen komut, /start yaz / unknown command, send /start");
59    }
60  }
61}
62
63void setup() {
64  Serial.begin(115200);
65  pinMode(LED_PIN, OUTPUT);
66  pinMode(ROLE_PIN, OUTPUT);
67  roleYaz(false);                             // açılışta röle kapalı / relay off at boot
68
69  WiFi.mode(WIFI_STA);
70  WiFi.begin(WIFI_SSID, WIFI_PASS);
71  while (WiFi.status() != WL_CONNECTED) delay(500);
72  Serial.println(WiFi.localIP());
73
74  client.setCACert(TELEGRAM_CERTIFICATE_ROOT);
75  bot.sendMessage(CHAT_ID, "Bot hazır, /start yaz / bot ready, send /start");
76}
77
78void loop() {
79  if (millis() - sonKontrol > KONTROL_ARALIGI) {
80    int adet = bot.getUpdates(bot.last_message_received + 1);   // yeni mesaj var mı? / any new messages?
81    while (adet) {
82      mesajlariIsle(adet);
83      adet = bot.getUpdates(bot.last_message_received + 1);
84    }
85    sonKontrol = millis();
86  }
87}
RegelWat het doet
bot.getUpdates(bot.last_message_received + 1)Vraagt de berichten na het laatst verwerkte bericht op en geeft terug hoeveel er binnenkwamen; de +1 voorkomt dat hetzelfde bericht terugkomt
bot.messages[i].chat_idHet ID van de chat waar het bericht vandaan kwam; het antwoord gaat daarheen en de beveiligingscontrole gebruikt het
bot.messages[i].textDe binnengekomen tekst; we vergelijken het commando hiermee
metin.indexOf('@')Knipt het deel @bot_name af dat Telegram in groepen aan commando's toevoegt
ROLE_AKTIF_LOWDe meeste relaismodules schakelen in bij een LOW-signaal; zet het op false als die van jou bij HIGH inschakelt
KONTROL_ARALIGIHoe vaak er wordt gepolld; 1000 ms reageert snel, 3000–5000 ms belast het netwerk minder

Beveiliging: laat de bot alleen op jouw ID reageren

Gebruikersnamen van bots op Telegram zijn openbaar en doorzoekbaar. Als iemand my_home_alarm_bot raadt of in een screenshot ziet en hem /ac stuurt, gehoorzaamt een ESP32 zonder controle dat commando ook. Daarom is de belangrijkste regel in de code de controle chatId != CHAT_ID. Je chat-ID hoeft niet geheim te zijn; de bescherming komt van Telegram zelf, dat controleert wie elk bericht heeft gestuurd, en niemand kan het ID van iemand anders vervalsen. Vreemden helemaal niet antwoorden is ook een bewuste keuze: zolang de bot zwijgt, kan niemand zelfs maar zien dat hij draait.

  • Gebruik een toegestane lijst: bewaar de geautoriseerde ID's in een array, negeer elk ander bericht en voeg familieleden één voor één toe.
  • Controleer de persoon in groepen: in een groep is de chat-ID het ID van de groep; moeten alleen bepaalde mensen commando's kunnen sturen, vergelijk dan from_id in plaats van chat_id.
  • Bewaar het token in een apart bestand: zet het token en het wifiwachtwoord in een bestand zoals secrets.h en laat dat bestand weg als je je code deelt.
  • Sla oude commando's over: een /ac die tijdens een stroomstoring is verstuurd, mag niet op een onverwacht moment worden uitgevoerd als het board terugkomt; de opschoning bij het opstarten in de volledige code regelt dat.
  • Veilige begintoestand: start elke keer dat het board opstart met het relais uit; dit is erg belangrijk bij belastingen zoals kachels of pompen.
  • Laat kritieke taken niet aan de bot alleen over: bedenk bij zaken als een deurslot of een boiler wat een fout commando kan aanrichten en voeg een bevestigingsbericht of een tijdslimiet toe.

Beweging- en gasalarm: een compleet project dat Telegram-meldingen stuurt

Nu zetten we de onderdelen samen. De code hieronder stuurt je een melding met tijdstempel via Telegram wanneer de PIR-sensor beweging detecteert en wanneer de MQ-2-gasmeting de drempel overschrijdt. Tegelijk luistert hij naar de commando's /ac, /kapat, /alarm_ac, /alarm_kapat en /durum, toont hij een knoppenmenu onderaan het scherm om aan te tikken als je /start typt en voegt hij de commando's toe aan de Menu-knop van Telegram. Voor de details van elke sensor, zie de gidsen over de PIR-bewegingssensor en de MQ-2-gassensor.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <UniversalTelegramBot.h>
4#include <ArduinoJson.h>
5#include <time.h>
6
7const char* WIFI_SSID = "AgAdi";
8const char* WIFI_PASS = "Sifre123";
9#define BOT_TOKEN "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
10#define CHAT_ID   "123456789"                  // bildirimlerin gideceği ID / the ID that receives alerts
11
12// Komut verebilecek kişiler; aile üyesi eklemek için: { CHAT_ID, "222222222" }
13// People allowed to send commands; to add a family member: { CHAT_ID, "222222222" }
14const char* YETKILI[] = { CHAT_ID };
15const int YETKILI_SAYISI = sizeof(YETKILI) / sizeof(YETKILI[0]);
16
17const int LED_PIN  = 2;                        // dahili LED / onboard LED
18const int ROLE_PIN = 26;                       // röle modülü IN / relay module IN
19const int PIR_PIN  = 27;                       // PIR sensörü OUT / PIR sensor OUT
20const int GAZ_PIN  = 34;                       // MQ-2 AO, gerilim bölücü üzerinden / MQ-2 AO through a voltage divider
21const bool ROLE_AKTIF_LOW = true;              // çoğu modül LOW'da çeker / most modules switch on with LOW
22
23const int GAZ_ESIK = 1800;                     // temiz havadaki değere göre ayarla / tune it from your clean-air reading
24const int GAZ_FARK = 200;                      // histerezis payı / hysteresis margin
25const unsigned long HAREKET_BEKLEME = 60000;   // iki hareket bildirimi arası en az 60 sn / at least 60 s between motion alerts
26const unsigned long GAZ_ISINMA = 120000;       // MQ-2 ilk 2 dakika ısınır / MQ-2 warms up for the first 2 minutes
27const unsigned long KONTROL_ARALIGI = 1000;    // Telegram'a saniyede bir sor / poll Telegram once per second
28
29WiFiClientSecure client;
30UniversalTelegramBot bot(BOT_TOKEN, client);
31
32bool alarmKurulu = true;                       // hareket alarmı açık mı / is the motion alarm armed
33bool roleAcik = false;
34bool gazVar = false;
35unsigned long sonKontrol = 0;
36unsigned long sonHareket = 0;
37
38String saat() {                                // "14:05:31" biçiminde saat / time as "14:05:31"
39  struct tm t;
40  if (!getLocalTime(&t, 100)) return "--:--:--";
41  char buf[9];
42  strftime(buf, sizeof(buf), "%H:%M:%S", &t);
43  return String(buf);
44}
45
46bool yetkiliMi(const String& id) {
47  for (int i = 0; i < YETKILI_SAYISI; i++) {
48    if (id == YETKILI[i]) return true;
49  }
50  return false;
51}
52
53void roleYaz(bool acik) {
54  roleAcik = acik;
55  if (ROLE_AKTIF_LOW) digitalWrite(ROLE_PIN, acik ? LOW : HIGH);
56  else                digitalWrite(ROLE_PIN, acik ? HIGH : LOW);
57}
58
59String durumMetni() {
60  String s = "Röle / relay: ";
61  s += roleAcik ? "AÇIK / ON" : "KAPALI / OFF";
62  s += "\nAlarm: ";
63  s += alarmKurulu ? "KURULU / ARMED" : "KAPALI / DISARMED";
64  s += "\nGaz / gas: " + String(analogRead(GAZ_PIN));
65  s += "\nWi-Fi: " + String(WiFi.RSSI()) + " dBm";
66  return s;
67}
68
69void mesajlariIsle(int adet) {
70  for (int i = 0; i < adet; i++) {
71    String chatId = bot.messages[i].chat_id;
72    String metin  = bot.messages[i].text;
73
74    if (!yetkiliMi(chatId)) {                  // yabancıya sessiz kal / stay silent to strangers
75      Serial.println("Yetkisiz ID / unauthorized ID: " + chatId);
76      continue;
77    }
78    int at = metin.indexOf('@');               // "/ac@bot_adi" -> "/ac"
79    if (at > 0) metin = metin.substring(0, at);
80
81    if (metin == "/ac") {
82      roleYaz(true);
83      bot.sendMessage(chatId, "Röle AÇIK / relay ON");
84    } else if (metin == "/kapat") {
85      roleYaz(false);
86      bot.sendMessage(chatId, "Röle KAPALI / relay OFF");
87    } else if (metin == "/alarm_ac") {
88      alarmKurulu = true;
89      bot.sendMessage(chatId, "Hareket alarmı kuruldu / motion alarm armed");
90    } else if (metin == "/alarm_kapat") {
91      alarmKurulu = false;
92      bot.sendMessage(chatId, "Hareket alarmı kapatıldı / motion alarm disarmed");
93    } else if (metin == "/durum") {
94      bot.sendMessage(chatId, durumMetni());
95    } else {                                   // /start ve diğer her şey: tuş menüsü / /start and anything else: button menu
96      String klavye = "[[\"/ac\",\"/kapat\"],[\"/alarm_ac\",\"/alarm_kapat\"],[\"/durum\"]]";
97      bot.sendMessageWithReplyKeyboard(chatId, "Komut seç / choose a command", "", klavye, true);
98    }
99  }
100}
101
102void setup() {
103  Serial.begin(115200);
104  pinMode(LED_PIN, OUTPUT);
105  pinMode(ROLE_PIN, OUTPUT);
106  pinMode(PIR_PIN, INPUT);
107  roleYaz(false);                              // açılışta röle kapalı / relay off at boot
108
109  WiFi.mode(WIFI_STA);
110  WiFi.begin(WIFI_SSID, WIFI_PASS);
111  while (WiFi.status() != WL_CONNECTED) {
112    delay(500);
113    Serial.print(".");
114  }
115  Serial.println(WiFi.localIP());
116
117  client.setCACert(TELEGRAM_CERTIFICATE_ROOT); // api.telegram.org kök sertifikası / root certificate of api.telegram.org
118  bot.maxMessageLength = 4000;                 // büyük mesajlarda takılmayı önler / prevents hanging on big messages
119  configTime(3 * 3600, 0, "pool.ntp.org");     // Türkiye UTC+3; kendi saat dilimini yaz / Turkey is UTC+3, set your own zone
120
121  // Telegram'daki Menü düğmesi; komutlar küçük harf, Türkçe karakter yok
122  // The Menu button in Telegram; commands are lowercase with no special letters
123  bot.setMyCommands("[{\"command\":\"ac\",\"description\":\"Röleyi aç\"},"
124                    "{\"command\":\"kapat\",\"description\":\"Röleyi kapat\"},"
125                    "{\"command\":\"alarm_ac\",\"description\":\"Hareket alarmını kur\"},"
126                    "{\"command\":\"alarm_kapat\",\"description\":\"Hareket alarmını kapat\"},"
127                    "{\"command\":\"durum\",\"description\":\"Durumu göster\"}]");
128
129  // Kart kapalıyken gelen eski komutları atla / skip old commands sent while the board was off
130  while (bot.getUpdates(bot.last_message_received + 1)) { }
131
132  bot.sendMessage(CHAT_ID, "Sistem açıldı / system started " + saat());
133}
134
135void loop() {
136  unsigned long simdi = millis();
137
138  // 1) Hareket alarmı / motion alarm
139  if (alarmKurulu && digitalRead(PIR_PIN) == HIGH && simdi - sonHareket > HAREKET_BEKLEME) {
140    sonHareket = simdi;
141    digitalWrite(LED_PIN, HIGH);
142    bot.sendMessage(CHAT_ID, "Hareket algılandı! / motion detected! " + saat());
143    digitalWrite(LED_PIN, LOW);
144  }
145
146  // 2) Gaz alarmı: ısınmadan sonra, susturulamaz / gas alarm: after warm-up, cannot be muted
147  if (simdi > GAZ_ISINMA) {
148    int gaz = analogRead(GAZ_PIN);             // 0-4095
149    if (!gazVar && gaz > GAZ_ESIK) {
150      gazVar = true;
151      bot.sendMessage(CHAT_ID, "GAZ ALARMI! / GAS ALARM! " + String(gaz) + " " + saat());
152    } else if (gazVar && gaz < GAZ_ESIK - GAZ_FARK) {
153      gazVar = false;
154      bot.sendMessage(CHAT_ID, "Gaz normale döndü / gas back to normal: " + String(gaz));
155    }
156  }
157
158  // 3) Telegram komutları / Telegram commands
159  if (simdi - sonKontrol > KONTROL_ARALIGI && WiFi.status() == WL_CONNECTED) {
160    int adet = bot.getUpdates(bot.last_message_received + 1);
161    while (adet) {
162      mesajlariIsle(adet);
163      adet = bot.getUpdates(bot.last_message_received + 1);
164    }
165    sonKontrol = millis();
166  }
167}
InstellingWaardeUitleg
GAZ_ESIK1800Ruwe ADC-waarde van 0 tot 4095; stel hem in op basis van je meting in schone lucht
GAZ_FARK200De meting moet zoveel onder de drempel zakken voordat "weer normaal" wordt gestuurd; voorkomt dat meldingen heen en weer springen bij de grens
HAREKET_BEKLEME60000 msLaat minstens 60 seconden tussen twee bewegingsmeldingen
GAZ_ISINMA120000 msDe MQ-2 meet hoog tijdens het opwarmen; de eerste 2 minuten wordt er niet op gas gecontroleerd
KONTROL_ARALIGI1000 msHoe vaak Telegram wordt gepolld op nieuwe berichten
bot.maxMessageLength4000Het langste antwoord dat de bibliotheek leest; de standaardwaarde is 1500

De twee alarmen in de code werken met opzet verschillend. Het bewegingsalarm wordt beschermd door een afkoelperiode: een PIR-sensor gaat steeds opnieuw af zolang iemand door de kamer loopt, en zonder afkoelperiode zou je telefoon vol komen te staan met tientallen berichten per minuut. Omdat de timer van de afkoelperiode bij nul begint, kan de eerste melding op zijn vroegst 60 seconden nadat het board is gestart binnenkomen, wat ook past bij de ongeveer één minuut die een PIR-sensor nodig heeft om na het inschakelen te stabiliseren. Het gasalarm gebruikt in plaats daarvan hysterese: het waarschuwt één keer wanneer de meting de drempel overschrijdt, meldt pas "weer normaal" als de waarde 200 eenheden eronder zakt en kan om veiligheidsredenen niet worden gedempt met /alarm_kapat. Ook Telegram staat te frequente berichten niet toe: probeer je meer dan één bericht per seconde naar dezelfde chat te sturen, of meer dan 20 per minuut naar een groep, dan krijg je de fout "Too Many Requests: retry after".

Stel GAZ_ESIK in door te meten, niet door te gokken: laat het board 5–10 minuten in schone lucht draaien, stuur /durum op Telegram en noteer de gaswaarde die terugkomt. Zet de drempel een paar honderd eenheden boven die waarde. Ook de variabele bot.longPoll is het waard om te kennen: geef hem een waarde zoals 20 en getUpdates wacht tot 20 seconden op een nieuw bericht, zodat commando's direct worden beantwoord, maar loop() zit al die tijd vast en de sensoren worden niet gelezen. Laat longPoll in alarmprojecten op 0 staan.
De MQ-2 is een sensor om mee te leren en te knutselen, geen gecertificeerde gasmelder, en er komt geen melding binnen als de wifi of het internet uitvalt. Gebruik hem nooit als enige bescherming tegen gaslekken in huis; installeer een commerciële melder die aan de normen voldoet en beschouw dit project als extra waarschuwingssysteem daarnaast.

Telegram-bot op de ESP8266 (NodeMCU)

Dezelfde bibliotheek werkt ook op ESP8266 NodeMCU- en Wemos D1 Mini-boards; de commando- en alarmlogica is precies hetzelfde en alleen het verbindingsgedeelte verandert. Je gebruikt ESP8266WiFi.h in plaats van WiFi.h, geeft het rootcertificaat als X509List door aan setTrustAnchors() en omdat de ESP8266 de geldigheidsdata van het certificaat controleert, moet de tijd via NTP worden opgehaald voordat je verbinding maakt. Zonder tijd mislukt elke verbinding zonder melding. De ingebouwde led van de NodeMCU zit op pin D4 en brandt bij LOW, en er is maar één analoge ingang, A0.

C++ (Arduino IDE)
1#include <ESP8266WiFi.h>
2#include <WiFiClientSecure.h>
3#include <UniversalTelegramBot.h>
4#include <ArduinoJson.h>
5#include <time.h>
6
7const char* WIFI_SSID = "AgAdi";
8const char* WIFI_PASS = "Sifre123";
9#define BOT_TOKEN "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
10#define CHAT_ID   "123456789"
11
12X509List cert(TELEGRAM_CERTIFICATE_ROOT);      // ESP8266'da kök sertifika böyle verilir / how ESP8266 takes the root certificate
13WiFiClientSecure client;
14UniversalTelegramBot bot(BOT_TOKEN, client);
15
16void setup() {
17  Serial.begin(115200);
18  configTime(0, 0, "pool.ntp.org");            // sertifika kontrolü için saat şart / the clock is needed to check the certificate
19  client.setTrustAnchors(&cert);
20
21  WiFi.mode(WIFI_STA);
22  WiFi.begin(WIFI_SSID, WIFI_PASS);
23  while (WiFi.status() != WL_CONNECTED) delay(500);
24
25  time_t simdi = time(nullptr);                // NTP saatini bekle / wait for the NTP time
26  while (simdi < 24 * 3600) {
27    delay(100);
28    simdi = time(nullptr);
29  }
30  bot.sendMessage(CHAT_ID, "ESP8266 çevrimiçi / ESP8266 is online");
31}
32
33void loop() {
34}

Telegram-bot met de Raspberry Pi Pico W en MicroPython

De Raspberry Pi Pico W heeft geen aparte bibliotheek nodig; je kunt verzoeken rechtstreeks naar de Telegram Bot API sturen met de requests-module van MicroPython. De code hieronder stuurt een melding als er beweging wordt gedetecteerd, schakelt met de commando's /ac en /kapat het relais op GP15 en de ingebouwde led van het board en antwoordt alleen op jouw chat-ID. Flash een actuele MicroPython op de Pico W met Thonny en sla de code op als main.py. De requests-module van MicroPython versleutelt de verbinding maar controleert het servercertificaat niet, dus het beveiligingsniveau is hetzelfde als setInsecure() op de ESP32.

MicroPython
1import network, time
2import requests
3from machine import Pin
4
5WIFI_SSID = "AgAdi"                    # Wi-Fi adın / your Wi-Fi name
6WIFI_PASS = "Sifre123"                 # Wi-Fi şifren / your Wi-Fi password
7TOKEN = "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
8CHAT_ID = 123456789                    # sayı olarak yaz / write it as a number
9API = "https://api.telegram.org/bot" + TOKEN
10
11led = Pin("LED", Pin.OUT)              # Pico W dahili LED / Pico W onboard LED
12role = Pin(15, Pin.OUT, value=1)       # aktif LOW röle kapalı başlar / active-LOW relay starts off
13pir = Pin(16, Pin.IN)                  # PIR OUT
14
15wlan = network.WLAN(network.STA_IF)
16wlan.active(True)
17wlan.connect(WIFI_SSID, WIFI_PASS)
18while not wlan.isconnected():
19    time.sleep(0.5)
20print("IP:", wlan.ifconfig()[0])
21
22def gonder(metin):
23    try:
24        r = requests.post(API + "/sendMessage", json={"chat_id": CHAT_ID, "text": metin})
25        r.close()
26    except Exception as e:
27        print("Gonderilemedi / send failed:", e)
28
29def yeni_mesajlar(offset):
30    try:
31        r = requests.get(API + "/getUpdates?timeout=0&limit=5&offset=%d" % offset)
32        sonuc = r.json().get("result", [])
33        r.close()
34        return sonuc
35    except Exception as e:
36        print("Okunamadi / read failed:", e)
37        return []
38
39# Kart kapalıyken gelen eski komutları atla / skip old commands sent while the board was off
40offset = 0
41eski = yeni_mesajlar(offset)
42while eski:
43    offset = eski[-1]["update_id"] + 1
44    eski = yeni_mesajlar(offset)
45
46gonder("Pico W çevrimiçi / Pico W is online")
47son_hareket = time.ticks_ms()          # ilk 60 sn PIR dengelenir / the PIR settles in the first 60 s
48
49while True:
50    if pir.value() and time.ticks_diff(time.ticks_ms(), son_hareket) > 60000:
51        son_hareket = time.ticks_ms()
52        gonder("Hareket algılandı! / motion detected!")
53
54    for u in yeni_mesajlar(offset):
55        offset = u["update_id"] + 1
56        mesaj = u.get("message", {})
57        if mesaj.get("chat", {}).get("id") != CHAT_ID:     # yalnız sana yanıt ver / answer only you
58            continue
59        komut = mesaj.get("text", "").split("@")[0]
60        if komut == "/ac":
61            role.value(0)              # aktif LOW: 0 = açık / active LOW: 0 = on
62            led.on()
63            gonder("Röle AÇIK / relay ON")
64        elif komut == "/kapat":
65            role.value(1)
66            led.off()
67            gonder("Röle KAPALI / relay OFF")
68        elif komut == "/durum":
69            gonder("Röle / relay: " + ("AÇIK / ON" if role.value() == 0 else "KAPALI / OFF"))
70    time.sleep(1)

Projectideeën voor een ESP32 Telegram-bot

  • Deur- en raamalarm: gebruik een reedschakelaar of een PIR-sensor om je telefoon een bericht te laten krijgen bij beweging terwijl er niemand thuis is.
  • Beveiligingscamera met foto's: maak met een ESP32-CAM een foto bij bewegingsdetectie en stuur die naar Telegram; de stappen staan in de gids ESP32-CAM Telegram.
  • Kamer- en kassenmonitor: krijg een waarschuwing als de temperatuur die een DHT11 meet een grens overschrijdt en vraag de actuele waarde op met /durum.
  • Herinnering voor het water geven aan planten: krijg een melding als een bodemvochtsensor droog meet en laat de pomp een paar seconden draaien met een commando zoals /sula ("water").
  • Brandwaarschuwing: combineer een vlamsensor met de MQ-2 om beide gevaren tegelijk in de gaten te houden.
  • Brievenbussensor op batterij: houd de ESP32 in deep sleep, maak hem wakker als het klepje opengaat, stuur één bericht en ga weer slapen.
  • Stopcontact op afstand: schakel met /ac en /kapat via een relais een bureaulamp of een ventilator vanaf elke plek ter wereld.

Veelvoorkomende fouten bij een ESP32 Telegram-bot en oplossingen

Symptoom of meldingOorzaakOplossing
sendMessage geeft false terug, geen fout in de Serial MonitorDe regel setCACert of setInsecure ontbreekt, het token bevat een spatie of de wifi is niet verbondenVoeg de certificaatregel toe, kopieer het token opnieuw, controleer eerst de wifiverbinding
"Forbidden: bot can't initiate conversation with a user" bij een browsertestJe hebt nooit op Start gedrukt in de bot of je hebt hem geblokkeerdOpen de bot in Telegram en druk op Start; deblokkeer hem als je hem hebt geblokkeerd
"Bad Request: chat not found"Verkeerde chat-ID, ontbrekend minteken in een groeps-ID, of de bot is uit de groep verwijderdLees het ID opnieuw uit met getUpdates en schrijf groeps-ID's met het minteken
"Unauthorized"Het token is fout of is vervangen met /revokeKopieer het actuele token uit BotFather en upload de code opnieuw
Stuurt berichten maar negeert commando'sEen lange delay() in loop(), een verkeerde chat-ID of @bot_name achter het commando in een groepGebruik millis() om te wachten, knip het @-deel af, controleer de regel "unauthorized ID" in de Serial Monitor
De bot werd helemaal stil na een foto of stickerDe bibliotheek leest alleen de eerste 1500 tekens van een antwoord; een lang antwoord kan niet worden verwerkt en hetzelfde bericht blijft terugkomenVoeg de regel bot.maxMessageLength = 4000; toe in setup()
Het board voert oude commando's uit bij het opstartenTelegram bewaart ongelezen berichten tot 24 uurLees openstaande berichten bij het opstarten en gooi ze weg
"Conflict: terminated by other getUpdates request"Hetzelfde token draait tegelijk op twee apparaten, of in een script op je computerMaak voor elk apparaat een aparte bot in BotFather
"Too Many Requests: retry after 30"Berichten worden te kort na elkaar verstuurdVoeg een afkoelperiode toe; stuur maximaal één bericht per seconde naar dezelfde chat
"ArduinoJson.h: No such file or directory" bij het compilerenDe bibliotheek ArduinoJson is niet geïnstalleerdInstalleer ArduinoJson via de Library Manager
Het board herstart tijdens het versturen van een berichtDe voeding kan de stroompiek tijdens het zenden over wifi niet aan (brownout)Een adapter van 1 A, een korte kabel van goede kwaliteit en een condensator van 100–470 µF tussen 3V3 en GND
Houd bij het oplossen van problemen een vaste volgorde aan: controleer eerst in de Serial Monitor dat de wifi verbonden is, test dan het token met getMe en de chat-ID met sendMessage in je browser en kijk als laatste naar de code. Voor een browsertest open je gewoon api.telegram.org/botTOKEN/sendMessage?chat_id=123456789&text=test; Telegram geeft de reden van elke fout in gewone tekst op de regel description. Kom je vast te zitten bij de wifistap, bekijk dan de gids ESP32 maakt geen verbinding met wifi.

Met een token, een chat-ID en een paar regels code is je ESP32 een kleine assistent geworden die verslag doet over je huis en jouw commando's uitvoert. Je kunt dezelfde opzet uitbreiden met temperatuur-, waterstand- of deursensoren en de meldingen naar een familiegroep sturen. In de BlueGrays-app vind je stap voor stap, met schakelschema's en code, het ESP32-bewegingsalarmsysteem dat Telegram-meldingen stuurt met een PIR, buzzer en led, het MQ-2-gas- en rookmelderalarm en de ESP32-wifiprojecten.

Veelgestelde vragen

Is een ESP32 Telegram-bot gratis?

Ja. Een bot maken op Telegram, de Bot API gebruiken en berichten versturen is helemaal gratis en er is geen maandelijks berichtenquotum. Er zijn alleen snelheidslimieten: ongeveer één bericht per seconde naar dezelfde chat en 20 berichten per minuut naar een groep. Voor projecten thuis zijn die limieten ruim voldoende.

Hoe vind ik mijn Telegram chat-ID?

De makkelijkste manier is op Telegram op Start te drukken in een ID-bot zoals @userinfobot; die stuurt je je ID-nummer. Je kunt ook je eigen bot een bericht sturen, api.telegram.org/botTOKEN/getUpdates in je browser openen en de id-waarde in het gedeelte "chat" lezen. Groeps-ID's beginnen met een minteken.

Waarom stuurt mijn ESP32 geen berichten naar Telegram?

De meest voorkomende oorzaken zijn dat je nooit op Start hebt gedrukt in de bot, een verkeerde chat-ID, een spatie in het token of een ontbrekende regel setCACert of setInsecure in de code. Je kunt het token en de chat-ID los van je code testen door de adressen getMe en sendMessage in een browser te openen. Zorg er ook voor dat het board met een 2,4 GHz-wifinetwerk is verbonden.

Kan iemand anders mijn Telegram-bot bedienen?

Gebruikersnamen van bots zijn openbaar, dus als je geen ID-controle aan je code toevoegt, kan iedereen die de bot vindt hem commando's sturen. Elke binnenkomende chat-ID vergelijken met die van jezelf en de rest negeren voorkomt dit, omdat Telegram controleert wie de afzender is. Deel ook het token nooit; is het gelekt, vervang het dan met /revoke in BotFather.

Kan ik een Telegram-bot maken met de ESP8266?

Ja. De bibliotheek UniversalTelegramBot werkt ook op ESP8266-boards zoals de NodeMCU en Wemos D1 Mini. Het rootcertificaat wordt als X509List doorgegeven aan setTrustAnchors() en de tijd moet via NTP worden opgehaald voordat je verbinding maakt. De ESP8266 heeft minder geheugen, dus de ESP32 kan beter met lange berichten overweg.

Kan de ESP32 foto's naar Telegram sturen?

Ja. Met de functie sendPhotoByBinary() van de bibliotheek kun je een frame dat een ESP32-CAM heeft opgenomen rechtstreeks naar Telegram sturen. Een ESP32 zonder camera kan op dezelfde manier een afbeelding versturen die op een sd-kaart staat, of met sendPhoto() het adres van een online afbeelding. Systemen die een foto sturen bij bewegingsdetectie behoren tot de populairste beveiligingsprojecten.

Alle projecten bekijken
Led laten knipperen met ESP32
ES-1Beginner

Led laten knipperen met ESP32

Leert je het basisgebruik van een GPIO-uitgang met de ESP32. Door een led via een digitale pin aan en uit te zetten krijgen we een knippereffect. Dit is de ESP32-versie van het klassieke blinkproject op de Arduino UNO; de basiscommando's in de Arduino-omgeving zijn hetzelfde, maar de pinindeling en de 3,3 V-GPIO-niveaus van de ESP32 verschillen van die van de Arduino UNO.

4.7(37)
108
Ingebouwde led van de ESP32 laten knipperen
ES-4Beginner

Ingebouwde led van de ESP32 laten knipperen

De ingebouwde blauwe led op de ESP32 DevKit V1 laten knipperen. Geen externe componenten nodig! Het eerste project dat je moet proberen als je een ESP32 koopt. GPIO 2 is verbonden met de ingebouwde led.

4.8(29)
54
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
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 slimme verlichting (PIR + LDR + relais + OLED)
ES-37Gevorderd
Premium

ESP32 slimme verlichting (PIR + LDR + relais + OLED)

Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.

4.3(6)
11
Automatische verlichting met de ESP32 en een PIR-bewegingssensor
ES-19Gemiddeld
Premium

Automatische verlichting met de ESP32 en een PIR-bewegingssensor

In dit project detecteert een HC-SR501 PIR-bewegingssensor iemand die de kamer binnenkomt en zet een led automatisch aan. Met millis() houd je bij hoe lang de led aan blijft: elke HIGH-meting vernieuwt het tijdstip van de laatste beweging en de led gaat minstens 10 seconden na de laatste HIGH uit. De code wacht bovendien in elke lus 50 ms met delay(50), dus de lus is niet volledig non-blocking. Handig voor trappen, gangen, badkamers of kastverlichting.

4.4(24)
38
ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
ES-25Gevorderd

ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)

In dit project verbinden we de ESP32 in Station-modus (STA) veilig en foutbestendig met het wifinetwerk thuis. We zetten de SSID en het wachtwoord in een apart bestand secrets.h zodat ze niet in Git lekken, bouwen een automatisch herverbindingsmechanisme en tonen het RSSI-signaalniveau en het IP-adres op een I2C-lcd-scherm. De ingebouwde led werkt als statusindicator. Het is een verbindingsmanager van productieniveau.

4.4(21)
38