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.

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.
| Term | Wat het doet | Voorbeeld |
|---|---|---|
| BotFather | De bot van Telegram om bots te maken en te beheren | /newbot, /setcommands, /revoke |
| Bot token | Het wachtwoord van de bot; je code maakt er verbinding met Telegram mee | 1234567890:AAE... (getal, dubbele punt, lange reeks tekens) |
| Chat ID | Het nummer van de persoon of groep waarnaar een bericht gaat | Persoon: 123456789, groep: -1001234567890 |
| getUpdates | Haalt nieuwe berichten die naar de bot zijn gestuurd op van de server | bot.getUpdates(...) |
| sendMessage | Stuurt een bericht naar de opgegeven chat-ID | bot.sendMessage(CHAT_ID, "Hello") |
| Commando | Een kort bericht dat met / begint en dat de bot begrijpt | /ac, /kapat, /durum |
Waarom Telegram? Vergeleken met andere manieren om meldingen te krijgen
| Methode | Voordelen | Nadelen | Het best voor |
|---|---|---|---|
| Telegram-bot | Gratis, directe meldingen, commando's in twee richtingen, geen open poorten nodig | Geen grafieken of kant-en-klaar dashboard | Alarmen en eenvoudige bediening op afstand |
| Blynk IoT | Kant-en-klare knoppen, meters en grafiekdashboard | Limieten voor berichten en apparaten in het gratis abonnement | Dashboards voor sensormonitoring |
| E-mail (SMTP) | Werkt op elke telefoon, kan lange rapporten bevatten | Vertraagd, lastig om commando's te ontvangen | Dagelijkse rapporten |
| SMS (SIM800L) | Geen wifi of internet nodig | Simkaart en sms-kosten, extra module | Hutten of schuurtjes zonder internet |
| ESP32-webserver | Volledig lokaal en gratis | Meestal alleen bereikbaar vanaf hetzelfde netwerk, geen meldingen | Bedieningspaneel 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
- 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.
- Tik op Start en stuur het commando /newbot.
- BotFather vraagt eerst om de weergavenaam van de bot; typ een naam naar keuze, bijvoorbeeld "Home Alarm".
- 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.
- 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.
- 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.
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:
- 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.
- 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.
- 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.
Stap 3: UniversalTelegramBot en ArduinoJson installeren
- 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?.
- 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.
- 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.
- 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.




| Aansluiting | ESP32 | ESP8266 (NodeMCU) | Raspberry Pi Pico W |
|---|---|---|---|
| PIR VCC | VIN (5V) | VIN (5V) | VBUS (5V) |
| PIR OUT | GPIO 27 | D5 (GPIO 14) | GP16 |
| MQ-2 VCC | VIN (5V) | VIN (5V) | VBUS (5V) |
| MQ-2 AO (via een spanningsdeler van 10 kΩ / 20 kΩ) | GPIO 34 | A0 | GP26 (ADC0) |
| Relais-VCC | VIN (5V) | VIN (5V) | VBUS (5V) |
| Relais-IN | GPIO 26 | D1 (GPIO 5) | GP15 |
| LED | GPIO 2 (ingebouwd) | D4 (ingebouwd, brandt bij LOW) | "LED" (ingebouwd) |
| Alle GND-pinnen | GND | GND | GND |
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:
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.
| Instelling | Wat het doet | Beveiliging | Wanneer gebruiken |
|---|---|---|---|
| client.setCACert(TELEGRAM_CERTIFICATE_ROOT) | Versleutelt de verbinding en controleert de identiteit van de server | Hoog | De aanbevolen instelling, altijd |
| client.setInsecure() | Versleutelt de verbinding maar controleert de identiteit van de server niet | Gemiddeld: merkt een nepserver ertussen niet op | Een snelle test om certificaatproblemen uit te sluiten |
| Geen van beide | Op huidige ESP32-cores komt de verbinding nooit tot stand | Werkt niet | Nooit: 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 X509List | Hoog | NodeMCU 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.
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}| Regel | Wat 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_id | Het ID van de chat waar het bericht vandaan kwam; het antwoord gaat daarheen en de beveiligingscontrole gebruikt het |
| bot.messages[i].text | De 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_LOW | De meeste relaismodules schakelen in bij een LOW-signaal; zet het op false als die van jou bij HIGH inschakelt |
| KONTROL_ARALIGI | Hoe 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.
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}| Instelling | Waarde | Uitleg |
|---|---|---|
| GAZ_ESIK | 1800 | Ruwe ADC-waarde van 0 tot 4095; stel hem in op basis van je meting in schone lucht |
| GAZ_FARK | 200 | De meting moet zoveel onder de drempel zakken voordat "weer normaal" wordt gestuurd; voorkomt dat meldingen heen en weer springen bij de grens |
| HAREKET_BEKLEME | 60000 ms | Laat minstens 60 seconden tussen twee bewegingsmeldingen |
| GAZ_ISINMA | 120000 ms | De MQ-2 meet hoog tijdens het opwarmen; de eerste 2 minuten wordt er niet op gas gecontroleerd |
| KONTROL_ARALIGI | 1000 ms | Hoe vaak Telegram wordt gepolld op nieuwe berichten |
| bot.maxMessageLength | 4000 | Het 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".
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.
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.
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 melding | Oorzaak | Oplossing |
|---|---|---|
| sendMessage geeft false terug, geen fout in de Serial Monitor | De regel setCACert of setInsecure ontbreekt, het token bevat een spatie of de wifi is niet verbonden | Voeg de certificaatregel toe, kopieer het token opnieuw, controleer eerst de wifiverbinding |
| "Forbidden: bot can't initiate conversation with a user" bij een browsertest | Je hebt nooit op Start gedrukt in de bot of je hebt hem geblokkeerd | Open 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 verwijderd | Lees het ID opnieuw uit met getUpdates en schrijf groeps-ID's met het minteken |
| "Unauthorized" | Het token is fout of is vervangen met /revoke | Kopieer het actuele token uit BotFather en upload de code opnieuw |
| Stuurt berichten maar negeert commando's | Een lange delay() in loop(), een verkeerde chat-ID of @bot_name achter het commando in een groep | Gebruik 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 sticker | De bibliotheek leest alleen de eerste 1500 tekens van een antwoord; een lang antwoord kan niet worden verwerkt en hetzelfde bericht blijft terugkomen | Voeg de regel bot.maxMessageLength = 4000; toe in setup() |
| Het board voert oude commando's uit bij het opstarten | Telegram bewaart ongelezen berichten tot 24 uur | Lees 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 computer | Maak voor elk apparaat een aparte bot in BotFather |
| "Too Many Requests: retry after 30" | Berichten worden te kort na elkaar verstuurd | Voeg een afkoelperiode toe; stuur maximaal één bericht per seconde naar dezelfde chat |
| "ArduinoJson.h: No such file or directory" bij het compileren | De bibliotheek ArduinoJson is niet geïnstalleerd | Installeer ArduinoJson via de Library Manager |
| Het board herstart tijdens het versturen van een bericht | De 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 |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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.

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.

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.

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.

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.

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.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

