Gidsen · 11 min leestijd

ESP32-CAM Telegram: stuur een foto bij bewegingsdetectie

Stuur foto's van een ESP32-CAM naar Telegram: PIR-bedrading en vrije pins, een /foto-commando, flashbesturing, deep sleep voor batterijen, nachtfoto's en volledige code.

Als je een ESP32-CAM Telegram-bot instelt, maakt het board een foto op het moment dat het beweging detecteert en stuurt het die binnen een paar seconden naar je telefoon. Je hoeft geen app te installeren, geen server te huren en geen poort op je router te openen: het board uploadt de foto rechtstreeks naar de servers van Telegram, en Telegram bezorgt hem als directe melding. Via dezelfde bot typ je /foto om op elk moment je voordeur te bekijken, de flash aan of uit te zetten en het alarm uit te schakelen.

In deze gids leer je stap voor stap welke van de weinige vrije pins van de ESP32-CAM je voor een PIR-sensor gebruikt, hoe de foto naar Telegram wordt geüpload, de complete code met commando's en hoe je de flash goed gebruikt. Daarna laat je het board met deep sleep dagenlang op batterijen draaien, maak je nachtfoto's met IR-verlichting en zie je waar deze opzet als beveiligingscamera tekortschiet. Heb je het board nog niet ingesteld en je eerste sketch nog niet geüpload, lees dan eerst De ESP32-CAM gebruiken.

ESP32-CAM-cameramodule voor een Telegram-fotosysteem
ESP32-CAM: een OV2640-camera, een flash-led en Wi-Fi op één board. Met een PIR-sensor kan het bij beweging een foto naar Telegram sturen.

Hoe werkt een ESP32-CAM Telegram-fotosysteem?

De keten heeft vier stappen. De PIR-sensor merkt een verandering in de warmte die een menselijk lichaam afgeeft en trekt zijn OUT-pin naar 3,3 V. Als de ESP32 deze stijgende flank ziet, vraagt hij de OV2640-camera om een JPEG-frame, dat in het 4 MB PSRAM van het board wordt geschreven. Daarna opent de ESP32 een versleutelde HTTPS-verbinding en stuurt hij een POST-verzoek in multipart/form-data-formaat naar het sendPhoto-endpoint van de Telegram Bot API; dat is dezelfde methode die een browser gebruikt als je een bestand uploadt. Telegram voegt de foto toe aan je chat en je telefoon toont een melding. Commando's gaan de andere kant op: elke seconde roept de ESP32 getUpdates aan om te vragen of er nieuwe berichten zijn, en als /foto is binnengekomen, voert hij dezelfde upload uit voor jouw verzoek.

OnderdeelSpecificatieOpmerking
ESP32-CAM (AI-Thinker)OV2640, 4 MB PSRAMDe PSRAM-versie verwerkt XGA-foto's zonder moeite
ESP32-CAM-MB of een USB-TTL-converterCH340 / CP2102Voor het uploaden van code; het board heeft geen USB
PIR-sensorHC-SR501 (5 V) of AM312 (3,3 V)Het OUT-signaal is 3,3 V en gaat rechtstreeks naar de ESP32
Voeding5 V, minimaal 2 AWi-Fi en de flash trekken tegelijk veel stroom
Elco470–1000 µFTussen 5V en GND, vlak bij het board
Optioneel18650-cel + 5V-boostconverter, 850 nm IR-verlichtingVoor batterijgebruik en nachtfoto's

PIR-bedrading en een vrije pin kiezen

De ESP32-CAM heeft 16 pins langs de randen, maar alleen de camera gebruikt al 15 GPIO's en de microSD-sleuf deelt er nog zes meer. Wat overblijft, zijn meestal bootpins (strapping) of pins die nodig zijn voor de seriële poort. Omdat dit project geen SD-kaart gebruikt, zijn de SD-lijnen vrij, en de veiligste daarvan is GPIO 13: hij beïnvloedt het opstarten niet, heeft een interne pull-downweerstand en kan, omdat het een RTC-pin is, het board uit deep sleep wekken. De tabel hieronder vergelijkt ook de andere kandidaten.

PinZonder SD-kaartWekt uit deep sleep?Opmerking
GPIO 13VrijJa (ext0)De beste keuze voor de PIR
GPIO 14VrijJaKan bij het opstarten even een PWM-signaal geven; prima als ingang
GPIO 15VrijJaStrapping-pin; als je hem LOW houdt, zijn de bootmeldingen stil
GPIO 2VrijJaStrapping-pin; mag niet HIGH zijn tijdens het uploaden
GPIO 12VrijJaAls hij bij het opstarten HIGH is, start het board niet; gebruik hem niet
GPIO 4Flash-ledJaGereserveerd voor de flash; gebruik hem niet voor iets anders
GPIO 3 (U0R)Serial RXNeeAlleen als je de seriële poort niet nodig hebt
GPIO 16PSRAMNeeGebruik hem nooit
PIR-pinESP32-CAM-pinBeschrijving
VCC5VDe HC-SR501 heeft minimaal 4,5 V nodig; gebruik 3V3 voor een AM312
OUTGPIO 133,3 V bij beweging, 0 V zonder beweging
GNDGNDGemeenschappelijke massa
De pin op het board met het label VCC is geen ingang maar de uitgang van de 3,3 V-regelaar; voed de PIR of het board altijd met 5 V op de 5V-pin. Sluit de PIR nooit aan op GPIO 12: als de sensor bij het opstarten HIGH geeft, probeert de ESP32 zijn flashgeheugen op de verkeerde spanning te laten draaien en start het board helemaal niet.

Draai van de twee trimmers op de HC-SR501 die van de tijd (Tx) naar de kortste stand (helemaal linksom, ongeveer 3 seconden); de code regelt de wachttijd. Laat de trigger-jumper in de stand H (herhaald triggeren) staan en stel de gevoeligheid in op iets tussen 3 en 7 meter, naar behoefte. Na het inschakelen heeft de sensor ongeveer een minuut nodig om aan zijn omgeving te wennen en triggert hij in die tijd willekeurig, daarom negeert de code de eerste 60 seconden. Details over hoe de sensor werkt vind je in PIR-bewegingssensor.

De Telegram-bot instellen: token en chat-ID

  1. Open @BotFather in Telegram, typ /newbot en geef je bot een naam en een gebruikersnaam die eindigt op bot.
  2. Kopieer de token die BotFather je geeft en die eruitziet als 1234567890:AAE...; die komt in de regel BOT_TOKEN van de code.
  3. Om je eigen gebruikersnummer te vinden stuur je /start naar @userinfobot; de Id-waarde die hij terugstuurt is je CHAT_ID.
  4. Open je eigen bot en stuur één keer /start; Telegram laat bots niemand berichten sturen met wie ze nog nooit hebben gesproken.
  5. Installeer in de Library Manager van Arduino IDE de bibliotheken UniversalTelegramBot (Brian Lough) en ArduinoJson.
  6. Kies onder Tools > Board de optie AI Thinker ESP32-CAM en zorg dat het Partition Scheme op Huge APP (3MB No OTA/1MB SPIFFS) staat.
De token is het wachtwoord van je bot: verwijder die regel altijd voordat je je code deelt of ergens uploadt. Denk je dat de token is uitgelekt, vraag dan met het commando /revoke in BotFather een nieuwe aan. Het maken van de bot, de chat-ID en het certificaat behandelen we uitgebreider in ESP32 Telegram-bot.

Een foto naar Telegram sturen: hoe werkt sendPhotoByBinary?

De functie sendPhotoByBinary() in de bibliotheek UniversalTelegramBot uploadt de foto net als een bestand. Eerst stuurt hij de requestheader en het chat-ID-veld, daarna vraagt hij de gegevens op bij drie kleine functies die jij levert: veriVarMi() geeft aan of er nog een stuk te versturen is, sonrakiTampon() geeft het geheugenadres van de gegevens en tamponBoyu() geeft aan hoeveel bytes het zijn. Omdat de framebuffer van de camera al één JPEG is, geeft de code de hele foto in één keer door en wist hij de vlag. Een foto van 1024×768 bij kwaliteit 12 is 50–120 KB, afhankelijk van de scène, en wordt bij een goede Wi-Fi-verbinding in 1–2 seconden geüpload. Telegram accepteert foto's tot 10 MB, dus je komt nooit in de buurt van de groottelimiet; de echte beperking is de uploadtijd.

Volledige code: het /foto-commando, flashbesturing en een bewegingsalarm

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <UniversalTelegramBot.h>
4#include <ArduinoJson.h>
5#include <time.h>
6#include "esp_camera.h"
7
8const char* WIFI_SSID = "AgAdi";          // Wi-Fi adın (yalnız 2,4 GHz) / your Wi-Fi name (2.4 GHz only)
9const char* WIFI_PASS = "Sifre123";       // Wi-Fi şifren / your Wi-Fi password
10#define BOT_TOKEN "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"   // BotFather'ın verdiği token / token from BotFather
11#define CHAT_ID   "123456789"             // yalnız bu ID'ye yanıt verilir / only this ID gets answers
12
13// AI-Thinker ESP32-CAM kamera pinleri / AI-Thinker ESP32-CAM camera pins
14#define PWDN_GPIO_NUM     32
15#define RESET_GPIO_NUM    -1
16#define XCLK_GPIO_NUM      0
17#define SIOD_GPIO_NUM     26
18#define SIOC_GPIO_NUM     27
19#define Y9_GPIO_NUM       35
20#define Y8_GPIO_NUM       34
21#define Y7_GPIO_NUM       39
22#define Y6_GPIO_NUM       36
23#define Y5_GPIO_NUM       21
24#define Y4_GPIO_NUM       19
25#define Y3_GPIO_NUM       18
26#define Y2_GPIO_NUM        5
27#define VSYNC_GPIO_NUM    25
28#define HREF_GPIO_NUM     23
29#define PCLK_GPIO_NUM     22
30
31#define FLAS_LED   4                          // beyaz flaş LED'i / white flash LED
32#define PIR_PIN   13                          // PIR OUT (SD kart kullanılmıyor) / PIR OUT (no SD card)
33
34const unsigned long PIR_ISINMA = 60000;       // PIR ilk 60 sn dengelenir / the PIR settles in the first 60 s
35const unsigned long BEKLEME = 30000;          // iki hareket fotoğrafı arası en az 30 sn / at least 30 s between motion photos
36const unsigned long KONTROL_ARALIGI = 1000;   // Telegram'a saniyede bir sor / poll Telegram once per second
37
38WiFiClientSecure client;
39UniversalTelegramBot bot(BOT_TOKEN, client);
40
41camera_fb_t *fb = nullptr;                    // gönderilecek kare / the frame being sent
42bool veriBekliyor = false;                    // kütüphanenin geri çağırma bayrağı / flag for the library callbacks
43bool alarmKurulu = true;                      // hareket alarmı açık mı / is the motion alarm armed
44bool flasAcik = false;                        // fotoğrafta flaş kullanılsın mı / use the flash for photos
45bool pirOnceki = false;
46unsigned long sonFoto = 0;
47unsigned long sonKontrol = 0;
48
49bool kameraBaslat() {
50  camera_config_t config = {};
51  config.ledc_channel = LEDC_CHANNEL_0;
52  config.ledc_timer   = LEDC_TIMER_0;
53  config.pin_d0 = Y2_GPIO_NUM;
54  config.pin_d1 = Y3_GPIO_NUM;
55  config.pin_d2 = Y4_GPIO_NUM;
56  config.pin_d3 = Y5_GPIO_NUM;
57  config.pin_d4 = Y6_GPIO_NUM;
58  config.pin_d5 = Y7_GPIO_NUM;
59  config.pin_d6 = Y8_GPIO_NUM;
60  config.pin_d7 = Y9_GPIO_NUM;
61  config.pin_xclk     = XCLK_GPIO_NUM;
62  config.pin_pclk     = PCLK_GPIO_NUM;
63  config.pin_vsync    = VSYNC_GPIO_NUM;
64  config.pin_href     = HREF_GPIO_NUM;
65  config.pin_sccb_sda = SIOD_GPIO_NUM;
66  config.pin_sccb_scl = SIOC_GPIO_NUM;
67  config.pin_pwdn     = PWDN_GPIO_NUM;
68  config.pin_reset    = RESET_GPIO_NUM;
69  config.xclk_freq_hz = 20000000;             // 20 MHz kamera saati / 20 MHz camera clock
70  config.pixel_format = PIXFORMAT_JPEG;
71
72  if (psramFound()) {
73    config.frame_size   = FRAMESIZE_XGA;      // 1024x768: net ve hızlı gönderilir / sharp and quick to send
74    config.jpeg_quality = 12;                 // küçük = daha kaliteli / lower = better quality
75    config.fb_count     = 2;
76    config.fb_location  = CAMERA_FB_IN_PSRAM;
77    config.grab_mode    = CAMERA_GRAB_LATEST;
78  } else {
79    config.frame_size   = FRAMESIZE_SVGA;     // PSRAM yoksa 800x600 / 800x600 without PSRAM
80    config.jpeg_quality = 12;
81    config.fb_count     = 1;
82    config.fb_location  = CAMERA_FB_IN_DRAM;
83    config.grab_mode    = CAMERA_GRAB_WHEN_EMPTY;
84  }
85  return esp_camera_init(&config) == ESP_OK;
86}
87
88// sendPhotoByBinary için üç geri çağırma: kareyi tek parça verir
89// Three callbacks for sendPhotoByBinary: they hand over the frame in one piece
90bool veriVarMi() {
91  if (veriBekliyor) {
92    veriBekliyor = false;
93    return true;
94  }
95  return false;
96}
97byte *sonrakiTampon() { return fb ? fb->buf : nullptr; }
98int tamponBoyu() { return fb ? fb->len : 0; }
99
100String saat() {                               // "14:05:31" biçiminde saat / time as "14:05:31"
101  struct tm t;
102  if (!getLocalTime(&t, 100)) return "--:--:--";
103  char buf[9];
104  strftime(buf, sizeof(buf), "%H:%M:%S", &t);
105  return String(buf);
106}
107
108bool fotoGonder(const String& chatId, const String& yazi) {
109  if (flasAcik) {
110    digitalWrite(FLAS_LED, HIGH);             // flaşı yak / flash on
111    delay(150);                               // pozlama yeni ışığa uysun / let exposure adapt
112  }
113  fb = esp_camera_fb_get();                   // tampondaki eski kareyi at / discard the stale frame
114  if (fb) esp_camera_fb_return(fb);
115  fb = esp_camera_fb_get();                   // asıl fotoğraf / the real photo
116  digitalWrite(FLAS_LED, LOW);                // flaşı söndür / flash off
117
118  if (!fb) {
119    bot.sendMessage(chatId, "Kamera hatası / camera error");
120    return false;
121  }
122  bot.sendMessage(chatId, yazi);              // önce kısa bildirim / a quick notification first
123  veriBekliyor = true;
124  String cevap = bot.sendPhotoByBinary(chatId, "image/jpeg", fb->len,
125                                       veriVarMi, nullptr, sonrakiTampon, tamponBoyu);
126  Serial.printf("Foto / photo: %u bayt / bytes\n", fb->len);
127  esp_camera_fb_return(fb);                   // kareyi sürücüye geri ver / give the frame back
128  fb = nullptr;
129  return cevap.indexOf("\"ok\":true") >= 0;  // Telegram başarıyı böyle bildirir / how Telegram reports success
130}
131
132void mesajlariIsle(int adet) {
133  for (int i = 0; i < adet; i++) {
134    String chatId = bot.messages[i].chat_id;
135    String metin  = bot.messages[i].text;
136    if (chatId != CHAT_ID) continue;          // yabancılara yanıt yok / never answer strangers
137
138    int at = metin.indexOf('@');              // gruptaki "/foto@bot_adi" -> "/foto" / "/foto@bot_name" -> "/foto"
139    if (at > 0) metin = metin.substring(0, at);
140
141    if (metin == "/start") {
142      String yardim = "/foto - fotoğraf çek / take a photo\n";
143      yardim += "/flas - flaşı aç ya da kapat / toggle the flash\n";
144      yardim += "/alarm - hareket alarmını aç ya da kapat / arm or disarm\n";
145      yardim += "/durum - son durum / status";
146      bot.sendMessage(chatId, yardim);
147    } else if (metin == "/foto") {
148      if (!fotoGonder(chatId, "Fotoğraf / photo " + saat())) {
149        bot.sendMessage(chatId, "Gönderilemedi / send failed");
150      }
151    } else if (metin == "/flas") {
152      flasAcik = !flasAcik;
153      bot.sendMessage(chatId, flasAcik ? "Flaş AÇIK / flash ON" : "Flaş KAPALI / flash OFF");
154    } else if (metin == "/alarm") {
155      alarmKurulu = !alarmKurulu;
156      bot.sendMessage(chatId, alarmKurulu ? "Alarm KURULU / ARMED" : "Alarm KAPALI / DISARMED");
157    } else if (metin == "/durum") {
158      String s = "Alarm: " + String(alarmKurulu ? "KURULU / ARMED" : "KAPALI / DISARMED");
159      s += "\nFlaş / flash: " + String(flasAcik ? "AÇIK / ON" : "KAPALI / OFF");
160      s += "\nWi-Fi: " + String(WiFi.RSSI()) + " dBm";
161      bot.sendMessage(chatId, s);
162    }
163  }
164}
165
166void setup() {
167  Serial.begin(115200);
168  pinMode(FLAS_LED, OUTPUT);
169  digitalWrite(FLAS_LED, LOW);
170  pinMode(PIR_PIN, INPUT_PULLDOWN);           // PIR bağlı değilken pin boşta kalmasın / keep the pin defined without a PIR
171
172  if (!kameraBaslat()) {
173    Serial.println("Kamera baslatilamadi / camera init failed");
174    delay(3000);
175    ESP.restart();
176  }
177
178  WiFi.mode(WIFI_STA);
179  WiFi.begin(WIFI_SSID, WIFI_PASS);
180  while (WiFi.status() != WL_CONNECTED) delay(500);
181  Serial.println(WiFi.localIP());
182
183  configTzTime("<+03>-3", "pool.ntp.org");    // Türkiye saati (UTC+3) / Turkey time (UTC+3)
184  client.setCACert(TELEGRAM_CERTIFICATE_ROOT); // api.telegram.org kök sertifikası / root certificate
185  bot.sendMessage(CHAT_ID, "Kamera hazır, /start yaz / camera ready, send /start");
186}
187
188void loop() {
189  bool pir = digitalRead(PIR_PIN);
190  // Yalnız yükselen kenarda, ısınmadan sonra ve bekleme süresi dolunca
191  // Only on a rising edge, after warm-up and once the cooldown has passed
192  if (pir && !pirOnceki && alarmKurulu && millis() > PIR_ISINMA && millis() - sonFoto > BEKLEME) {
193    sonFoto = millis();
194    fotoGonder(CHAT_ID, "Hareket algılandı! / Motion detected! " + saat());
195  }
196  pirOnceki = pir;
197
198  if (millis() - sonKontrol > KONTROL_ARALIGI) {
199    int adet = bot.getUpdates(bot.last_message_received + 1);
200    while (adet) {
201      mesajlariIsle(adet);
202      adet = bot.getUpdates(bot.last_message_received + 1);
203    }
204    sonKontrol = millis();
205  }
206}
OnderdeelWat het doet
kameraBaslat()Start de camera op XGA (1024×768) met twee framebuffers als er PSRAM is, anders op SVGA (800×600)
fotoGonder()Zet de flash aan als dat gevraagd wordt, gooit het verouderde frame weg en pakt een nieuw, stuurt eerst een kort bericht en daarna de foto
mesajlariIsle()Antwoordt alleen op de commando's /start, /foto, /flas, /alarm en /durum die van CHAT_ID komen
PIR-deel van loop()Controleert de stijgende flank, de opwarmtijd van 60 s en de afkoeltijd van 30 s
Telegram-deel van loop()Vraagt één keer per seconde om nieuwe berichten en verwerkt wachtende berichten na elkaar

De code let op de stijgende flank van de PIR, niet op het niveau: ook als de sensor 3 seconden HIGH blijft, wordt er maar één foto gemaakt. De afkoeltijd van 30 seconden voorkomt dat iemand die door de kamer loopt je telefoon met tientallen foto's per minuut overspoelt en dat Telegram meer dan één bericht per seconde naar dezelfde chat afknijpt. Omdat elke ophaalactie een HTTPS-verzoek is, kan de aanroep van getUpdates de loop ongeveer een halve seconde ophouden; doordat de uitgang van de HC-SR501 minstens 3 seconden HIGH blijft, wordt er in de tussentijd geen beweging gemist. Als het board altijd aan staat, zitten er meestal 2–4 seconden tussen de beweging en de aankomst van de foto op je telefoon.

Flashbesturing: wanneer gebruik je hem?

De witte led aan de voorkant wordt aangestuurd via een transistor op GPIO 4 en trekt bij volle helderheid meer dan 100 mA uit de voeding. De code laat de flash alleen branden op het moment van de foto en wacht ongeveer 150 ms; omdat de automatische belichting van de camera een paar frames nodig heeft om zich aan het nieuwe licht aan te passen, wordt ook het eerste frame in de buffer weggegooid. De flash werkt tot 1–2 meter; een deur of tuin die verder weg is, wordt niet verlicht. Als je door glas fotografeert, zet de flash dan uit, anders zie je op de foto alleen de felle reflectie op het glas. Wil je een zwakkere flash, dan kun je PWM op GPIO 4 toepassen; de schuifregelaar LED Intensity in het voorbeeld CameraWebServer doet precies dat. Bedenk dat een witte flash die 's nachts afgaat ook verraadt waar de camera staat; voor onopvallend toezicht past de IR-sectie hieronder beter.

Batterij sparen met deep sleep

Een ESP32-CAM met Wi-Fi aan trekt voortdurend 150–200 mA, waardoor een 18650-cel van 2600 mAh in een halve dag leeg is. Als je op batterijen draait, moet het board bijna al zijn tijd in deep sleep doorbrengen en alleen wakker worden als de PIR triggert. In de onderstaande code is GPIO 13 de wekbron ext0: zodra de PIR-uitgang HIGH wordt, start het board opnieuw op, maakt eerst de foto, verbindt dan met Wi-Fi, verstuurt de foto en gaat weer slapen. De volgorde is belangrijk: de Wi-Fi-verbinding duurt een paar seconden, en door de foto te maken vóór het verbinden leg je het exacte moment van de beweging vast.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <UniversalTelegramBot.h>
4#include <ArduinoJson.h>
5#include "esp_camera.h"
6#include "driver/rtc_io.h"
7
8const char* WIFI_SSID = "AgAdi";
9const char* WIFI_PASS = "Sifre123";
10#define BOT_TOKEN "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
11#define CHAT_ID   "123456789"
12
13// AI-Thinker ESP32-CAM kamera pinleri / AI-Thinker ESP32-CAM camera pins
14#define PWDN_GPIO_NUM     32
15#define RESET_GPIO_NUM    -1
16#define XCLK_GPIO_NUM      0
17#define SIOD_GPIO_NUM     26
18#define SIOC_GPIO_NUM     27
19#define Y9_GPIO_NUM       35
20#define Y8_GPIO_NUM       34
21#define Y7_GPIO_NUM       39
22#define Y6_GPIO_NUM       36
23#define Y5_GPIO_NUM       21
24#define Y4_GPIO_NUM       19
25#define Y3_GPIO_NUM       18
26#define Y2_GPIO_NUM        5
27#define VSYNC_GPIO_NUM    25
28#define HREF_GPIO_NUM     23
29#define PCLK_GPIO_NUM     22
30
31#define FLAS_LED   4                          // flaş LED'i (RTC pini) / flash LED (RTC pin)
32#define PIR_PIN   13                          // PIR OUT, ext0 ile uyandırır / PIR OUT, wakes via ext0
33
34RTC_DATA_ATTR int hareketSayisi = 0;          // uykuda korunur / survives deep sleep
35
36WiFiClientSecure client;
37UniversalTelegramBot bot(BOT_TOKEN, client);
38camera_fb_t *fb = nullptr;
39bool veriBekliyor = false;
40
41bool veriVarMi() {
42  if (veriBekliyor) {
43    veriBekliyor = false;
44    return true;
45  }
46  return false;
47}
48byte *sonrakiTampon() { return fb ? fb->buf : nullptr; }
49int tamponBoyu() { return fb ? fb->len : 0; }
50
51bool kameraBaslat() {
52  camera_config_t config = {};
53  config.ledc_channel = LEDC_CHANNEL_0;
54  config.ledc_timer   = LEDC_TIMER_0;
55  config.pin_d0 = Y2_GPIO_NUM;
56  config.pin_d1 = Y3_GPIO_NUM;
57  config.pin_d2 = Y4_GPIO_NUM;
58  config.pin_d3 = Y5_GPIO_NUM;
59  config.pin_d4 = Y6_GPIO_NUM;
60  config.pin_d5 = Y7_GPIO_NUM;
61  config.pin_d6 = Y8_GPIO_NUM;
62  config.pin_d7 = Y9_GPIO_NUM;
63  config.pin_xclk     = XCLK_GPIO_NUM;
64  config.pin_pclk     = PCLK_GPIO_NUM;
65  config.pin_vsync    = VSYNC_GPIO_NUM;
66  config.pin_href     = HREF_GPIO_NUM;
67  config.pin_sccb_sda = SIOD_GPIO_NUM;
68  config.pin_sccb_scl = SIOC_GPIO_NUM;
69  config.pin_pwdn     = PWDN_GPIO_NUM;
70  config.pin_reset    = RESET_GPIO_NUM;
71  config.xclk_freq_hz = 20000000;
72  config.pixel_format = PIXFORMAT_JPEG;
73  config.frame_size   = psramFound() ? FRAMESIZE_XGA : FRAMESIZE_SVGA;
74  config.jpeg_quality = 12;
75  config.fb_count     = 1;                    // tek kare yeter / one frame is enough
76  config.fb_location  = psramFound() ? CAMERA_FB_IN_PSRAM : CAMERA_FB_IN_DRAM;
77  config.grab_mode    = CAMERA_GRAB_WHEN_EMPTY;
78  return esp_camera_init(&config) == ESP_OK;
79}
80
81void uyu() {
82  // PIR çıkışı LOW'a dönmeden uyursan kart hemen yeniden uyanır
83  // If you sleep while the PIR output is still HIGH, the board wakes straight away
84  unsigned long t = millis();
85  while (digitalRead(PIR_PIN) == HIGH && millis() - t < 30000) delay(100);
86
87  digitalWrite(FLAS_LED, LOW);
88  rtc_gpio_hold_en(GPIO_NUM_4);               // flaş uykuda sönük kalsın / keep the flash off while asleep
89  esp_sleep_enable_ext0_wakeup(GPIO_NUM_13, 1);   // GPIO 13 HIGH olunca uyan / wake when GPIO 13 goes HIGH
90  Serial.println("Uyku / sleep");
91  Serial.flush();
92  esp_deep_sleep_start();
93}
94
95void setup() {
96  Serial.begin(115200);
97  rtc_gpio_hold_dis(GPIO_NUM_4);              // flaş pinini serbest bırak / release the flash pin
98  rtc_gpio_deinit(GPIO_NUM_13);               // pini yeniden normal GPIO yap / make the pin a normal GPIO again
99  pinMode(FLAS_LED, OUTPUT);
100  digitalWrite(FLAS_LED, LOW);
101  pinMode(PIR_PIN, INPUT);
102
103  if (esp_sleep_get_wakeup_cause() != ESP_SLEEP_WAKEUP_EXT0) {
104    Serial.println("Ilk acilis: PIR 60 sn isiniyor / first boot: PIR warming up 60 s");
105    delay(60000);
106    uyu();
107  }
108  hareketSayisi++;
109
110  // 1) Fotoğrafı hemen çek, Wi-Fi'yi sonra aç: an kaçmasın
111  // 1) Take the photo at once and start Wi-Fi later, so the moment is not lost
112  if (kameraBaslat()) {
113    for (int i = 0; i < 3; i++) {             // ilk kareler karanlık ya da yeşil olur / first frames are dark or green
114      fb = esp_camera_fb_get();
115      if (fb) esp_camera_fb_return(fb);
116    }
117    fb = esp_camera_fb_get();
118  }
119
120  // 2) Wi-Fi'ye bağlan, en fazla 15 sn bekle / connect to Wi-Fi, wait at most 15 s
121  WiFi.mode(WIFI_STA);
122  WiFi.begin(WIFI_SSID, WIFI_PASS);
123  unsigned long t0 = millis();
124  while (WiFi.status() != WL_CONNECTED && millis() - t0 < 15000) delay(100);
125
126  // 3) Gönder ve uyu / send and go back to sleep
127  if (WiFi.status() == WL_CONNECTED) {
128    client.setCACert(TELEGRAM_CERTIFICATE_ROOT);
129    bot.sendMessage(CHAT_ID, "Hareket / motion #" + String(hareketSayisi));
130    if (fb) {
131      veriBekliyor = true;
132      bot.sendPhotoByBinary(CHAT_ID, "image/jpeg", fb->len,
133                            veriVarMi, nullptr, sonrakiTampon, tamponBoyu);
134    } else {
135      bot.sendMessage(CHAT_ID, "Kamera hatası / camera error");
136    }
137  }
138  if (fb) esp_camera_fb_return(fb);
139  Serial.printf("Uyanik kalma / awake: %lu ms\n", millis());
140  uyu();
141}
142
143void loop() {
144}

In de code zitten vier details die je makkelijk mist. Ten eerste wacht het board tot de PIR-uitgang weer LOW is voordat het gaat slapen; als je slaapt terwijl het signaal nog HIGH is, wordt het board meteen wakker en blijft het in een lus hangen. Ten tweede vergrendelt rtc_gpio_hold_en() de flashpin tijdens de slaap op LOW; zonder deze regel zweeft GPIO 4 en gloeit de flash zwakjes tijdens de slaap, waardoor de batterij leegloopt en de aandacht wordt getrokken. Ten derde maakt rtc_gpio_deinit() na het wakker worden van GPIO 13 weer een gewone ingang, anders kan digitalRead() hem verkeerd uitlezen. Ten vierde overleeft de teller met RTC_DATA_ATTR de slaap, zodat elk bericht je vertelt om de hoeveelste beweging het gaat. Alle slaapstanden en wekbronnen komen aan bod in ESP32 deep sleep.

ScenarioGemiddelde stroom (batterijzijde)Met een 18650 van 2600 mAh
Altijd aan, Wi-Fi verbonden (eerste sketch)≈ 290 mA≈ 9 uur
Deep sleep + 20 bewegingen per dag≈ 11 mA≈ 10 dagen
Power-latchschakeling (board volledig uit) + 20 bewegingen per dag≈ 0,7 mA≈ 4–5 maanden (theoretisch)

De waarden in de tabel gaan ervan uit dat de 5V-boostconverter met een rendement van 85% werkt. Hoewel de ESP32-chip zelf in deep sleep maar ongeveer 10 µA gebruikt, trekt het ESP32-CAM-board tijdens de slaap door de regelaar, het PSRAM en de camera nog steeds zo'n 6 mA, en dat bepaalt echt de levensduur van de batterij. Elke wekcyclus duurt 6–10 seconden: opstarten, camera, Wi-Fi-verbinding en twee HTTPS-verzoeken. Wil je maanden doorlooptijd, dan heb je een power-latch-schakeling nodig die de voeding van het board met een MOSFET volledig afsluit, het board inschakelt als de PIR triggert en het board zichzelf laat uitschakelen als het klaar is. Je eigen scenario reken je uit met de Batterijduur-calculator, en voor veelvuldig herstarten zie je ESP32 brownout.

Nachtfoto's: flash, IR-leds en camera-instellingen

Standaard ESP32-CAM-lenzen bevatten een vast IR-cutfilter dat infrarood licht blokkeert; daarom zien kleuren er overdag natuurlijk uit, maar blijft een scène die alleen met IR wordt verlicht donker. Er zijn twee manieren om in het donker te zien: de witte flash, of IR-verlichting met een lens zonder filter. OV2640-modules die als night vision of 850 nm worden verkocht, hebben dit filter niet; kleuren worden overdag roze, maar een scène die met 850 nm IR-leds wordt verlicht, zie je duidelijk in zwart-wit. 940 nm-leds zijn volledig onzichtbaar, maar de OV2640 is bij die golflengte veel minder gevoelig, waardoor het beeld merkbaar donkerder wordt. Voed de IR-verlichting met een aparte 5 V- of 12 V-voeding; kant-en-klare boards met een lichtsensor gaan vanzelf aan als het donker wordt. Wil je het vanaf een GPIO bedienen, gebruik dan een MOSFET en sluit de leds nooit rechtstreeks aan op de pin.

C++ (Arduino IDE)
1#include "esp_camera.h"
2void setup() {
3// esp_camera_init() başarılı olduktan sonra / after esp_camera_init() succeeds
4sensor_t *s = esp_camera_sensor_get();
5s->set_gainceiling(s, GAINCEILING_32X);   // karanlıkta daha yüksek kazanç / more gain in the dark
6s->set_aec2(s, 1);                        // DSP pozlaması: gece modu / DSP exposure: night mode
7s->set_ae_level(s, 2);                    // pozlamayı artır (-2..2) / raise exposure (-2..2)
8s->set_whitebal(s, 1);                    // otomatik beyaz dengesi / auto white balance
9s->set_special_effect(s, 2);              // 2 = siyah-beyaz: IR'de renk zaten bozulur / 2 = grayscale: IR spoils colour anyway
10}
11void loop() {}

Deze instellingen verhogen het versterkingsplafond en de belichtingstijd van de sensor. De prijs is dat de framesnelheid in het donker daalt, een bewegend persoon wazig wordt en de hoge versterking korrel aan het beeld toevoegt. Licht blijft de effectiefste manier om een nachtfoto te verbeteren; zelfs een zwakke IR-verlichting geeft een helderder resultaat dan de versterking hoger zetten. Je kunt de code direct na de aanroep van kameraBaslat() toevoegen en, als je wilt, het omgevingslicht met een LDR meten en automatisch schakelen tussen dag- en nachtinstellingen.

De beperkingen als beveiligingscamera

  • Hij neemt geen video op: Dit systeem stuurt alleen stilstaande foto's. Voor continu opnemen of beelden terugkijken heb je een echte beveiligingscamera nodig.
  • Er is vertraging: 2–4 seconden als het board aan staat, 6–10 seconden als het uit deep sleep wakker wordt; iemand die snel voorbijloopt, is misschien al uit beeld.
  • Een PIR kijkt niet door glas: Glas laat infrarode warmtestraling niet door. Een sensor achter een raam detecteert geen beweging buiten, maar zonlicht en radiatoren kunnen hem nog steeds ten onrechte laten triggeren.
  • Hij hangt af van internet: Als Wi-Fi of internet uitvalt, wordt de foto niet verstuurd. Voor kritisch gebruik biedt het opslaan van de foto op een SD-kaart een back-up.
  • Hij heeft geen fysieke bescherming: Het board is makkelijk te verwijderen of uit te schakelen en buiten heeft het last van vocht en zonlicht; gebruik je het buiten, dan heb je een afgesloten behuizing en een voeding nodig die tegen de temperatuur kan.
  • De beeldkwaliteit is beperkt: De OV2640 van 2 MP is niet goed genoeg om gezichten te herkennen of kentekens te lezen vanaf een paar meter; groothoeklenzen vergroten het beeld maar verminderen de details.
  • Privacyregels: Richt de camera op je eigen terrein; controleer de wettelijke regels waar je woont voordat je de tuin van een buur, gedeelde ruimtes of de straat filmt.

Projectideeën met ESP32-CAM en Telegram

  • Deurbelcamera: Sluit de deurbelknop aan op GPIO 13, zodat een druk op de knop je deurmat fotografeert en naar je stuurt; zie hoe je een knop aansluit voor de bedrading.
  • Brievenbusmelding: Monteer een reedschakelaar op het klepje, zodat het openen ervan het board wekt en een foto stuurt van wat erin zit.
  • Vogelhuisje of huisdiercamera: Maak een foto bij beweging en kijk overdag mee met /foto.
  • Ogen voor een alarmsysteem: Laat een Arduino-alarmsysteem de ESP32-CAM een signaal geven als het afgaat, zodat die de scène fotografeert.
  • Planten- en kasbewaking: Word één keer per uur wakker via een timer om een foto te sturen en stuur je metingen naar een dashboard met MQTT en Home Assistant.
  • Gezinsgroep: Voeg de bot toe aan een Telegram-groep en gebruik de ID van de groep, zodat de foto iedereen tegelijk bereikt.

Veelvoorkomende problemen en oplossingen

SymptoomWaarschijnlijke oorzaakOplossing
Het bericht komt aan, maar de foto nietHet frame is te groot, PSRAM staat uit of de upload is afgebrokenKies het board AI Thinker ESP32-CAM, verlaag de resolutie naar SVGA, verbeter het Wi-Fi-signaal
De bot reageert op geen enkel commandoVerkeerde token of CHAT_ID, of je hebt nooit /start naar de bot gestuurdKopieer de token opnieuw, controleer je ID met @userinfobot, stuur /start naar je bot
Er komen bewegingsfoto's zonder redenDe PIR pikt het signaal van de Wi-Fi-antenne of een warmtebron opZet de PIR 10–20 cm van het board, plaats 100 nF tussen VCC en GND, richt de sensor niet op de zon of radiatoren
Het board wordt direct na het slapengaan weer wakkerDe PIR-uitgang is nog HIGH op het moment van slapenWacht tot de pin weer LOW is voordat je gaat slapen, zet de tijdtrimmer van de HC-SR501 op minimum
De flash gloeit zwakjes tijdens de slaapGPIO 4 blijft zwevenSchrijf LOW en roep rtc_gpio_hold_en(GPIO_NUM_4) aan voordat je gaat slapen
De foto is donker of groenachtigDe eerste frames direct na het starten van de cameraPak 2–3 frames en gooi ze weg vóór de echte foto
Het board herstart tijdens het versturen van een fotoBrownout: de voeding kan de stroom voor Wi-Fi en flash niet bijhoudenGebruik een 5 V / 2 A-adapter, korte draden en een condensator van 470–1000 µF tussen 5V en GND
Bij het versturen naar een groep begint de groeps-ID met een minteken (bijvoorbeeld -1001234567890); schrijf hem samen met het teken in de regel CHAT_ID. Om ervoor te zorgen dat de bot groepsberichten kan lezen, moet je misschien /setprivacy in BotFather uitzetten of commando's sturen als /foto@bot_name; de code haalt deze achtervoegsels al weg.

In combinatie met Telegram verandert de ESP32-CAM een goedkoop board in een slim oog dat foto's naar je telefoon stuurt. Bouw het systeem eerst met de always-on-sketch en stel de PIR af, en ga daarna over op de deep sleep-versie als je dat nodig hebt. In de BlueGrays-app vind je het Telegram-bewegingsalarm met PIR, buzzer en led, ESP32 deep sleep en automatische verlichting met een PIR, elk met bedradingsschema's stap voor stap en kant-en-klare code.

Veelgestelde vragen

Hoe stuur ik een foto van een ESP32-CAM naar Telegram?

Je maakt met BotFather een bot aan om een token te krijgen, installeert de bibliotheek UniversalTelegramBot en uploadt de framebuffer van de camera met de functie sendPhotoByBinary() naar het sendPhoto-endpoint van Telegram. De bibliotheek verstuurt de foto via HTTPS in multipart-formaat, zoals een bestandsupload in een browser. In de code hoef je alleen de Wi-Fi-gegevens, de token en je eigen chat-ID aan te passen.

Op welke pin sluit ik een PIR-sensor aan op de ESP32-CAM?

Als je geen SD-kaart gebruikt, is GPIO 13 de veiligste keuze: hij beïnvloedt het opstarten niet en kan, als RTC-pin, het board uit deep sleep wekken. Sluit VCC van de PIR aan op de 5V-pin, GND op GND en OUT op GPIO 13. Vermijd GPIO 12; als die bij het opstarten HIGH is, start het board niet.

Hoe lang gaat een ESP32-CAM mee op een batterij?

Met Wi-Fi de hele tijd aan gaat een 18650-cel van 2600 mAh ongeveer 9 uur mee. Gebruik je deep sleep en word je alleen bij beweging wakker, dan stijgt dat naar ongeveer 10 dagen; zelfs slapend trekt het board zo'n 6 mA door de regelaar en het PSRAM. Voor maanden doorlooptijd heb je een power-latchschakeling nodig die de voeding van het board volledig afsluit.

Kan de ESP32-CAM 's nachts zien?

Het IR-cutfilter op standaardmodules blokkeert infrarood licht, dus in het donker krijg je alleen een beeld tot 1–2 meter met de witte flash. Met een OV2640-module zonder filter (night vision) en een 850 nm IR-verlichting kun je in het donker heldere zwart-witfoto's maken. Het versterkingsplafond in de camera-instellingen verhogen helpt ook, maar voegt korrel aan het beeld toe.

Kan de ESP32-CAM video naar Telegram sturen?

In de praktijk niet. De ESP32-CAM levert losse JPEG-frames en heeft niet de rekenkracht of het geheugen om die om te zetten in een MP4-video. Meerdere foto's achter elkaar sturen of de livestream op je thuisnetwerk bekijken met CameraWebServer zijn realistischer opties.

Kan de foto naar meer dan één persoon worden gestuurd?

Ja. Als je de bot aan een Telegram-groep toevoegt en de ID van de groep, die met een minteken begint, als CHAT_ID gebruikt, bereikt de foto iedereen in de groep tegelijk. Je kunt ook meerdere chat-ID's in een array in de code zetten en de foto naar elk daarvan om de beurt sturen; elke verzending is een aparte upload, dus het duurt langer.

Alle projecten bekijken
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
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 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
ES-33Gevorderd
Premium

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)

De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.

4.3(10)
16
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
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
ESP32 mDNS: het apparaat bereiken via bluegrays-esp.local (met lcd-scherm)
ES-29Gevorderd
Premium

ESP32 mDNS: het apparaat bereiken via bluegrays-esp.local (met lcd-scherm)

In dit project voegen we een mDNS-service (Multicast DNS) toe aan de ESP32, zodat je het apparaat bereikt met een leesbare hostnaam zoals bluegrays-esp.local in plaats van een IP-adres. Ook als het IP-adres dat DHCP uitdeelt verandert, reageert het apparaat altijd op dezelfde naam. Met een kleine webserver op het board bedien je de LED vanuit je browser op http://bluegrays-esp.local/.

4.8(14)
23
Bewegingsmelder met bewegingssensor
AR-24Beginner
Premium

Bewegingsmelder met bewegingssensor

Een eenvoudige bewaker die laat weten wanneer iemand de kamer binnenkomt. De bewegingssensor merkt de warmte op die het menselijk lichaam afgeeft; de Arduino houdt de led aan zolang er beweging is en…

4.6(47)
67