ESP32-CAM-projecten: 12 ideeën van beveiligingscamera tot QR-lezer
12 ESP32-CAM-projecten: Telegram-foto's, PIR-beveiligingscamera, timelapse, robotauto en QR-codes lezen, met een tabel over resolutie, voeding en niveau en kant-en-klare code.
ESP32-CAM-projecten combineren de 2-megapixel OV2640-camera, de wifi en de microSD-sleuf van dit board ter grootte van een luciferdoosje: een livestream die je over je thuisnetwerk bekijkt, een foto die op je telefoon verschijnt zodra er beweging wordt gedetecteerd, een timelapse die dagenlang een groeiende plant vastlegt, of een klein beeldverwerkingsexperiment dat een QR-code leest. Het board is goedkoop, maar de resolutie, de voeding en de vaardigheden die elk project vraagt, lopen sterk uiteen. Wie met het verkeerde project begint, strijdt meestal met brownout-fouten of een volgelopen geheugen in plaats van met de camera te werken.
In deze gids vergelijken we 12 projectideeën, van makkelijk tot moeilijk, in één tabel: per project zie je de aanbevolen resolutie, hoe je het van stroom voorziet, welke extra onderdelen je nodig hebt en hoe moeilijk het is. We leggen ook uit hoe de AI-Thinker ESP32-CAM verschilt van de nieuwere ESP32-S3-cameraboards en geven je kant-en-klare code die wakker wordt door een PIR-sensor of een timer en een foto op microSD opslaat. Heb je het board nog nooit gebruikt, rond dan eerst de installatie en je eerste upload af met de ESP32-CAM-gids.

Ken de grenzen van het board voordat je aan een ESP32-CAM-project begint
In het hart van de ESP32-CAM zit een gewone ESP32; wat er een cameraboard van maakt, is het 4 MB PSRAM op het board en de 24-polige flatkabel van de camera. De camera levert beelden direct als JPEG, dus de ESP32 hoeft niet pixel voor pixel te comprimeren. Een JPEG-frame van 1600×1200 is 100–250 KB groot en past alleen in PSRAM. Na de pins die de camera, de SD-kaart en het PSRAM gebruiken, blijven er maar een paar vrije GPIO's over: met de SD-kaart in 1-bit-modus heb je GPIO 12 en 13, en zonder SD-kaart zijn ook GPIO 2, 14 en 15 vrij. Dit pinnentekort bepaalt van meet af aan de opzet van elk project met motoren of meerdere sensoren. De voeding is de andere beperking: het board trekt ongeveer 180 mA met de flitser uit, wifipieken liggen kort veel hoger, en een zwakke voeding laat het board herstarten.
| Kenmerk | AI-Thinker ESP32-CAM | ESP32-S3-cameraboard (bijv. XIAO ESP32S3 Sense) |
|---|---|---|
| Processor | ESP32, dual core, 240 MHz | ESP32-S3, dual core, 240 MHz, vectorinstructies |
| PSRAM | 4 MB | 8 MB (snellere octal-PSRAM) |
| USB | Geen; je hebt een USB-TTL-adapter of ESP32-CAM-MB nodig | Ingebouwde USB-C; direct uploaden |
| Vrije GPIO's | 2 pinnen met SD in 1-bit-modus (GPIO 12, 13) | 5–10 pinnen, afhankelijk van het board |
| Camera | OV2640, 2 MP | OV2640 of OV3660 (afhankelijk van het board) |
| Extra's | microSD, flitser-led | microSD, de meeste hebben een digitale microfoon |
| AI | Gezichtsdetectie is traag en werkt met lage resolutie | Duidelijk sneller met ESP-DL |
| Prijs (ca.) | $6–10 (met programmeerboard) | $15–25 |
| Het meest geschikt voor | Livestream, foto's, Telegram, timelapse | Gezichtsdetectie, audio + video, projecten die veel pinnen nodig hebben |
AI-Thinker of een ESP32-S3-cameraboard?
Voor de meeste projecten in deze lijst is de AI-Thinker ESP32-CAM ruim voldoende. Alles wat je nodig hebt voor livestreamen, losse foto's, Telegram-meldingen en opnemen op microSD zit op dit board, en het is de goedkoopste optie. Het echte verschil zie je bij beeldverwerkingsprojecten. De vectorinstructies van de ESP32-S3 draaien de neurale netwerken uit de ESP-DL-bibliotheek van Espressif vele malen sneller dan de klassieke ESP32, en het 8 MB PSRAM biedt makkelijk ruimte aan grotere modellen en framebuffers. Ingebouwde USB scheelt ook het gedoe met IO0 aan GND leggen bij elke upload. Kortom: wil je gezichtsdetectie, een babyfoon met microfoon of drie à vier sensoren naast de camera, kies dan een cameraboard op basis van de ESP32-S3; wil je foto's maken en versturen of opslaan, dan volstaat de AI-Thinker.
12 ESP32-CAM-projecten: tabel met resolutie, voeding en niveau
| # | Project | Aanbevolen resolutie | Voeding | Extra onderdelen | Niveau |
|---|---|---|---|---|---|
| 1 | Wi-Fi-livestreamcamera | VGA (640×480) | 5 V / 2 A-adapter | Geen | Makkelijk |
| 2 | Directe foto en flits vanaf een webpagina | UXGA (1600×1200) | 5 V / 2 A-adapter | Geen | Makkelijk |
| 3 | Foto naar Telegram bij beweging | SVGA (800×600) | 5 V / 2 A-adapter | PIR-sensor | Gemiddeld |
| 4 | PIR-beveiligingscamera die opneemt op microSD | UXGA | Adapter of 18650 + 5V-boostconverter | PIR, microSD-kaart | Gemiddeld |
| 5 | Timelapsecamera | UXGA of HD | Adapter of 18650 + deep sleep | microSD-kaart | Gemiddeld |
| 6 | Vogelhuisjes- en wildcamera | SVGA | 18650 + zonnepaneel | PIR, NoIR-lens, 850 nm-infraroodleds | Moeilijk |
| 7 | Robotauto met live video | QVGA (320×240) | 2 × 18650 | Motordriver, chassis | Moeilijk |
| 8 | Pan-tilt-baby- en huisdiercamera | VGA | 5 V / 2 A-adapter | 2 × SG90-servo, pan-tilt-beugel | Gemiddeld |
| 9 | QR-codelezer | QVGA, grijstinten | 5 V-adapter | Geen | Gemiddeld |
| 10 | Gezichtsdetectie | QVGA of 240×240 | 5 V / 2 A-adapter | ESP32-S3-board aanbevolen | Moeilijk |
| 11 | Videodeurbel (Home Assistant) | VGA | 5 V / 2 A-adapter | Knop, buzzer | Gemiddeld |
| 12 | Water- of gasmeter uitlezen | SVGA | 5 V-adapter | Behuizing voor een vast beeld | Moeilijk |
De resoluties in de tabel zijn een startpunt. Bij streamingprojecten betekent een lagere resolutie een hogere framerate: je haalt 20–30 frames per seconde bij QVGA, maar zakt naar 2–5 bij UXGA. Bij projecten die foto's opslaan of versturen doet de framerate er niet toe, dus kun je de hoogste resolutie kiezen. Deze 12 items zijn projectideeën, en we geven je wat je nodig hebt om ze echt te bouwen. De ESP32-projecten in de BlueGrays-app leren je de bouwstenen van deze ideeën stap voor stap: ESP32 Motion Alarm System (PIR + Buzzer + LED + Telegram) behandelt bewegingsdetectie en Telegram-meldingen, ESP32 Deep Sleep — Battery Saving behandelt deep sleep, en ESP32 Temperature Logger laat zien hoe je bestanden naar microSD schrijft.
Beginnersprojecten (1–3): livestream, directe foto en Telegram
Project 1 vraagt helemaal geen code van jou: stel in het voorbeeld CameraWebServer in de Arduino IDE het boardmodel in op CAMERA_MODEL_AI_THINKER, vul je wifigegevens in en upload. Typ je het IP-adres uit de Serial Monitor in een browser, dan opent de instellingenpagina; de livestream komt van het adres /stream op poort 81. Zet het board op een vaste plek, zoals een slaapkamer of een garage, en kijk mee over je thuisnetwerk. Project 2 gebruikt het adres /capture van dezelfde server, dat bij elk verzoek één JPEG teruggeeft. Voeg een knop toe aan je eigen webpagina, zet de flitser aan via GPIO 4, maak een paar honderd milliseconden later de foto, en je kunt wanneer je maar wilt in een donkere kast of op het bed van een 3D-printer kijken.
Project 3 is het populairste van de lijst: als een PIR-sensor beweging detecteert, maakt de ESP32-CAM een foto en stuurt die via een Telegram-bot naar je telefoon. Omdat er een beveiligde (HTTPS-)verbinding met de server van Telegram wordt gemaakt en de foto in stukken wordt geüpload, is SVGA of XGA een goede balans tussen snelheid en scherpte. Het opzetten van de bot, het vinden van de chat-ID en de volledige code staan in het artikel ESP32-CAM Telegram-foto. Begin je liever zonder camera, dan bouwt het project ESP32 Motion Alarm System in de BlueGrays-app dezelfde Telegram-logica met een PIR, een buzzer en een led; de foto later toevoegen is eenvoudig.
Opnameprojecten (4–6): PIR-camera, timelapse en vogelhuisje
Project 4 en Project 5 delen dezelfde code: het board wordt wakker, maakt een foto, slaat die op microSD op en gaat terug in deep sleep. Omdat het nooit verbinding maakt met internet, is het veel sneller klaar en werkt het in een tuin of schuur zonder wifi. De code hieronder gebruikt twee wekbronnen tegelijk: ziet de PIR-sensor op GPIO 13 beweging, dan wordt het board meteen wakker en begint de bestandsnaam met pir_; ook zonder beweging wordt het elke 10 minuten wakker en slaat het een timelapseframe op dat met tl_ begint. Hetzelfde board is dus zowel beveiligingscamera als timelapsecamera.
| Onderdeel | ESP32-CAM-pin | Opmerking |
|---|---|---|
| PIR (HC-SR501) VCC | 5V | De module heeft een eigen regelaar en werkt op 5 V |
| PIR OUT | GPIO 13 | De uitgang is 3,3 V en kan direct worden aangesloten; deze pin is vrij met SD in 1-bit-modus |
| PIR GND | GND | Gemeenschappelijke massa |
| microSD-kaart | Sleuf op het board | FAT32-geformatteerd; 1-bit-modus gebruikt alleen GPIO 2, 14 en 15 |
| Voeding | 5V en GND | 5 V / 2 A; een condensator van 470–1000 µF tussen 5V en GND |
1// ESP32-CAM: zamanlayıcı ya da PIR ile uyan, fotoğrafı microSD'ye kaydet, uyu
2// ESP32-CAM: wake on timer or PIR, save a photo to microSD, go back to sleep
3// Kart / Board: AI Thinker ESP32-CAM
4#include "esp_camera.h"
5#include "FS.h"
6#include "SD_MMC.h"
7#include <Preferences.h>
8#include "driver/rtc_io.h"
9
10#define SLEEP_MINUTES 10 // zaman atlamalı çekim aralığı / time-lapse interval
11#define PIR_PIN GPIO_NUM_13 // PIR çıkışı (SD 1-bit modda boş) / PIR output (free in SD 1-bit mode)
12#define FLASH_PIN 4 // flaş LED'i / flash LED
13
14// AI-Thinker kamera pinleri / AI-Thinker camera pins
15#define PWDN_GPIO_NUM 32
16#define RESET_GPIO_NUM -1
17#define XCLK_GPIO_NUM 0
18#define SIOD_GPIO_NUM 26
19#define SIOC_GPIO_NUM 27
20#define Y9_GPIO_NUM 35
21#define Y8_GPIO_NUM 34
22#define Y7_GPIO_NUM 39
23#define Y6_GPIO_NUM 36
24#define Y5_GPIO_NUM 21
25#define Y4_GPIO_NUM 19
26#define Y3_GPIO_NUM 18
27#define Y2_GPIO_NUM 5
28#define VSYNC_GPIO_NUM 25
29#define HREF_GPIO_NUM 23
30#define PCLK_GPIO_NUM 22
31
32Preferences prefs;
33
34bool startCamera() {
35 camera_config_t config = {};
36 config.ledc_channel = LEDC_CHANNEL_0;
37 config.ledc_timer = LEDC_TIMER_0;
38 config.pin_d0 = Y2_GPIO_NUM;
39 config.pin_d1 = Y3_GPIO_NUM;
40 config.pin_d2 = Y4_GPIO_NUM;
41 config.pin_d3 = Y5_GPIO_NUM;
42 config.pin_d4 = Y6_GPIO_NUM;
43 config.pin_d5 = Y7_GPIO_NUM;
44 config.pin_d6 = Y8_GPIO_NUM;
45 config.pin_d7 = Y9_GPIO_NUM;
46 config.pin_xclk = XCLK_GPIO_NUM;
47 config.pin_pclk = PCLK_GPIO_NUM;
48 config.pin_vsync = VSYNC_GPIO_NUM;
49 config.pin_href = HREF_GPIO_NUM;
50 config.pin_sccb_sda = SIOD_GPIO_NUM;
51 config.pin_sccb_scl = SIOC_GPIO_NUM;
52 config.pin_pwdn = PWDN_GPIO_NUM;
53 config.pin_reset = RESET_GPIO_NUM;
54 config.xclk_freq_hz = 20000000;
55 config.pixel_format = PIXFORMAT_JPEG;
56 config.frame_size = FRAMESIZE_UXGA; // 1600x1200, PSRAM gerekir / needs PSRAM
57 config.jpeg_quality = 10; // 0-63, küçük sayı = yüksek kalite / lower = better
58 config.fb_count = 1;
59 config.fb_location = CAMERA_FB_IN_PSRAM;
60 config.grab_mode = CAMERA_GRAB_LATEST;
61 return esp_camera_init(&config) == ESP_OK;
62}
63
64void goToSleep() {
65 digitalWrite(FLASH_PIN, LOW);
66 rtc_gpio_hold_en(GPIO_NUM_4); // uykuda flaş sönük kalsın / keep flash off while asleep
67 // PIR hâlâ HIGH ise bırakmasını bekle (en fazla 10 sn) / wait for PIR to release (max 10 s)
68 unsigned long t0 = millis();
69 while (digitalRead(PIR_PIN) == HIGH && millis() - t0 < 10000) delay(100);
70 esp_sleep_enable_ext0_wakeup(PIR_PIN, 1); // PIR HIGH olunca uyan / wake on PIR HIGH
71 esp_sleep_enable_timer_wakeup((uint64_t)SLEEP_MINUTES * 60ULL * 1000000ULL); // ya da süre dolunca / or on timer
72 Serial.println("Uykuya geciliyor / Going to sleep");
73 Serial.flush();
74 esp_deep_sleep_start();
75}
76
77void setup() {
78 Serial.begin(115200);
79 rtc_gpio_hold_dis(GPIO_NUM_4);
80 pinMode(FLASH_PIN, OUTPUT);
81 digitalWrite(FLASH_PIN, LOW);
82 pinMode(PIR_PIN, INPUT);
83
84 bool byMotion = esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_EXT0;
85 Serial.println(byMotion ? "Uyanma: hareket / Wake: motion" : "Uyanma: zamanlayici / Wake: timer");
86
87 if (!startCamera()) {
88 Serial.println("Kamera baslatilamadi / Camera init failed");
89 goToSleep();
90 }
91 // İlk kareler karanlık olabilir; pozlama otursun diye 3 kare at / discard 3 frames so exposure settles
92 for (int i = 0; i < 3; i++) {
93 camera_fb_t* warm = esp_camera_fb_get();
94 if (warm) esp_camera_fb_return(warm);
95 delay(100);
96 }
97
98 camera_fb_t* fb = esp_camera_fb_get();
99 if (!fb) {
100 Serial.println("Fotograf alinamadi / Capture failed");
101 goToSleep();
102 }
103
104 // SD kartı 1-bit modda aç: GPIO 4, 12 ve 13 boşalır / 1-bit mode frees GPIO 4, 12 and 13
105 if (SD_MMC.begin("/sdcard", true)) {
106 prefs.begin("cam", false);
107 uint32_t n = prefs.getUInt("n", 0) + 1; // sayaç elektrik kesilse de kalır / counter survives power loss
108 prefs.putUInt("n", n);
109 prefs.end();
110 char path[32];
111 snprintf(path, sizeof(path), "/%s%05lu.jpg", byMotion ? "pir_" : "tl_", (unsigned long)n);
112 File file = SD_MMC.open(path, FILE_WRITE);
113 if (file) {
114 file.write(fb->buf, fb->len);
115 file.close();
116 Serial.printf("Kaydedildi / Saved: %s (%u bayt / bytes)\n", path, (unsigned)fb->len);
117 }
118 SD_MMC.end();
119 } else {
120 Serial.println("SD kart yok / No SD card");
121 }
122 esp_camera_fb_return(fb);
123 goToSleep();
124}
125
126void loop() {} // derin uyku nedeniyle hiç çalışmaz / never runs because of deep sleepDe details van de code zijn belangrijk. Omdat de SD-kaart in 1-bit-modus wordt geopend, blijven GPIO 4, 12 en 13 vrij; daardoor kunnen we de PIR op GPIO 13 aansluiten en knippert de flitser-led niet bij elke schrijfactie. De eerste frames van de camera zijn vaak donker of groenig omdat de automatische belichting en witbalans nog niet zijn ingesteld, dus gooit de code drie frames weg en slaat het vierde op. Het bestandsnummer wordt met Preferences in niet-vluchtig geheugen bewaard, zodat oude foto's niet worden overschreven, ook niet na een stroomuitval. De regel rtc_gpio_hold_en houdt GPIO 4 tijdens de slaap vast op LOW; anders kan de flitser tijdens de slaap zwak oplichten. Voordat het board gaat slapen, wacht het maximaal 10 seconden tot de PIR-uitgang weer LOW is; anders zou een sensor die nog HIGH is het board meteen weer wakker maken.
Project 6, een vogelhuisjes- of wildcamera, is dezelfde code met een batterij en nachtzicht erbij. De standaard OV2640-lens heeft een filter dat infraroodlicht tegenhoudt; wil je 's nachts beelden, dan heb je een NoIR-lens zonder IR-filter nodig en 850 nm-infraroodleds, die vogels niet kunnen zien. De batterijberekening verrast: door de regelaar en het PSRAM trekt het AI-Thinker-board zelfs in deep sleep ongeveer 6 mA. Een board dat elke 10 minuten 3–4 seconden wakker blijft, verbruikt gemiddeld zo'n 7 mA, en bijna alles daarvan komt van het slapen; een 18650-cel van 2600 mAh met een 5V-boostconverter gaat ongeveer 9–10 dagen mee. Voor een camera die maandenlang draait, voeg je een klein zonnepaneel toe of gebruik je een timerchip zoals de TPL5110 om de voeding van het board tijdens de slaap volledig af te sluiten.
Projecten die bewegen (7–8): robotauto en pan-tilt-camera
In Project 7 wordt de ESP32-CAM de ogen van een robotauto: je bekijkt het live beeld in de browser van je telefoon en rijdt met knoppen op dezelfde pagina. QVGA houdt de vertraging laag. De vier ingangspinnen van de motordriver gaan naar GPIO 12, 13, 14 en 15, die vrij zijn als je geen SD-kaart gebruikt; voed de motoren uit een apart batterijpakket, niet uit de 5V-lijn van het board. Chassis, driverkeuze en webinterface worden stap voor stap uitgelegd in het artikel ESP32-CAM-robotauto. In Project 8 draaien twee SG90-servo's een pan-tilt-beugel naar links, rechts, omhoog en omlaag; je richt de camera vanaf je telefoon terwijl je de babykamer of je huisdier in de gaten houdt. De camera gebruikt LEDC-timer 0 voor zijn XCLK-signaal, dus geef de servobibliotheek een andere timer; anders valt het beeld uiteen of trillen de servo's.
Beeldverwerkingsprojecten (9–10): QR-codes lezen en gezichtsdetectie
In Project 9 levert de camera ruwe pixels in grijstinten in plaats van JPEG, en een op quirc gebaseerde bibliotheek (bijvoorbeeld ESP32QRCodeReader) scant elk frame op een QR-code. Bij QVGA worden een paar frames per seconde verwerkt; dat is snel genoeg om een code op een doos te scannen om een deur te ontgrendelen of een inventaris bij te houden. Houd de code 15–25 cm van de camera in goed licht; de lens met vaste focus van de OV2640 ziet te dichtbije codes als een waas. Project 10, gezichtsdetectie, is het meest gewenste project en degene die het meest teleurstelt. De oude 2.0.x-releases van de Arduino ESP32-core hadden knoppen voor gezichtsdetectie en -herkenning in het voorbeeld CameraWebServer; nieuwere releases hebben die opties uit het voorbeeld gehaald. De klassieke ESP32 kan bij lage resolutie maar een paar gezichten per seconde controleren, en herkenning is niet betrouwbaar. Voor een serieus gezichtsdetectieproject geven een board op basis van de ESP32-S3 en de ESP-WHO-voorbeelden van Espressif veel betere resultaten.
Smarthomeprojecten (11–12): videodeurbel en meterstand uitlezen
In Project 11 laat een druk op de belknop een buzzer klinken, maakt de ESP32-CAM een foto van je voordeur en komt het beeld op je telefoon binnen. Gebruik je Home Assistant, dan is de schoonste route de component esp32_camera van ESPHome: je beschrijft het board in een paar regels YAML, de camera verschijnt in Home Assistant als entiteit, en je bouwt een automatisering die bij een druk op de knop een snapshot als melding stuurt (ESPHome-installatie). Project 12 maakt een oude mechanische water- of gasmeter slim: de camera zit vast boven de meter, de cijfers in het beeld, verlicht door de flitser-led, worden gelezen door een klein neuraal netwerk dat op het board draait, en de verbruikswaarde gaat via MQTT naar Home Assistant. De kant-en-klare opensourcefirmware AI-on-the-edge-device wordt hier veel voor gebruikt; installeren en configureren gaat veel sneller dan zelf code schrijven.
Veelgemaakte fouten bij ESP32-CAM-projecten en oplossingen
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Brownout detector was triggered, het board blijft herstarten | Zwakke voeding of dunne, lange draden | Gebruik een 5 V / 2 A-adapter en voeg een condensator van 470–1000 µF toe vlak bij de 5V-pin |
| Camera init failed with error 0x105 | Camera niet gevonden: flatkabel zit niet goed of verkeerd model gekozen | Plaats de flatkabel opnieuw en controleer de pindefinities van CAMERA_MODEL_AI_THINKER |
| SD Card Mount Failed | De kaart is geen FAT32 of is te groot | Formatteer de kaart als FAT32, liefst 32 GB of kleiner, probeer de 1-bit-modus |
| Opnamen zijn donker of groenig | De eerste frames zijn genomen voordat de belichting was ingesteld | Gooi 2–3 frames weg voordat je opslaat en zet de flitser aan vóór de opname |
| Livestream bevriest en slaat frames over | Zwakke wifi of hoge resolutie | Ga terug naar VGA of QVGA, zet het board dichter bij de router, schakel over op een externe antenne |
| Batterij is binnen een paar dagen leeg | Het board trekt zelfs in deep sleep ongeveer 6 mA | Verleng het wekinterval, voeg een zonnepaneel toe of sluit de voeding af met een TPL5110 |
Met welk ESP32-CAM-project kun je het best beginnen?
- Je gebruikt het board voor het eerst: begin met Project 1. Als CameraWebServer draait, zijn je voeding, upload en wifi allemaal in orde.
- Je wilt meldingen op je telefoon: ga door naar Project 3; test de bot eerst met een PIR + Telegram-alarm zonder camera en voeg daarna de foto toe.
- Je wilt ergens opnemen zonder internet: gebruik de code hierboven voor Project 4 en 5 en pas het interval en de bestandsnamen aan je wensen aan.
- Je wilt een camera die maandenlang op een batterij draait: plan Project 6 met een zonnepaneel of een timer die de voeding afsluit, en houd rekening met de slaapstroom van het board.
- Je houdt van beweging en besturing: Project 7 en 8; zorg eerst dat een livestream zonder motor werkt en voeg daarna de motordriver of de servo's toe.
- Je bent nieuwsgierig naar beeldverwerking: begin met QR-codes lezen en stap voor gezichtsdetectie over op een board op basis van de ESP32-S3.
Het mooie van de ESP32-CAM is dat je met hetzelfde kleine board in een weekend een werkende beveiligingscamera kunt bouwen en een maand later een apparaat dat beelden verwerkt. Welk project je ook kiest, een stevige 5 V-voeding en de juiste resolutie zijn het halve werk. In de BlueGrays-app vind je ESP32-projecten zoals een bewegingsalarm dat Telegram-meldingen stuurt, deep-sleep-batterijbesparing, datalogging naar microSD, mDNS en over-the-air-updates, elk met schakelschema, onderdelenlijst en kant-en-klare code, zodat je deze bouwstenen kunt combineren tot je eigen cameraproject.
Veelgestelde vragen
Wat kun je met een ESP32-CAM doen?
Je kunt een livestreamcamera voor je thuisnetwerk bouwen, een alarm dat bij beweging een foto naar Telegram stuurt, een beveiligingscamera die op microSD opneemt, een timelapsecamera, een robotauto met live video, een QR-codelezer en een videodeurbel. Omdat het board wifi en een 2 MP-camera combineert, hebben de meeste projecten geen extra modules nodig.
Welke spanning heeft de ESP32-CAM nodig?
De betrouwbaarste manier is een 5 V-voeding die minstens 2 A kan leveren op de 5V-pin van het board aan te sluiten; de regelaar op het board brengt dit omlaag naar 3,3 V. Voeden via de 3V3-pin kan ook, maar de spanningsval als wifi en camera tegelijk draaien, veroorzaakt brownout-fouten.
Hoe lang gaat een ESP32-CAM mee op een batterij?
Een board dat continu streamt, trekt gemiddeld ongeveer 180 mA en draait ongeveer 9 uur op een 18650-cel van 2600 mAh met een 5V-boostconverter. Een board dat tussen foto's in deep sleep wacht, gaat dagen of weken mee, maar omdat het AI-Thinker-board zelfs tijdens de slaap ongeveer 6 mA trekt, zijn maanden aan looptijd alleen mogelijk met een zonnepaneel of een timer die de voeding afsluit.
Kan de ESP32-CAM gezichten herkennen?
Hij kan eenvoudige gezichtsdetectie bij lage resolutie, maar op de klassieke ESP32 is dit traag en is gezichtsherkenning niet betrouwbaar. Nieuwere releases van de Arduino-core hebben de opties voor gezichtsdetectie uit het voorbeeld CameraWebServer gehaald; voor een serieus project passen een cameraboard op basis van de ESP32-S3 en de ESP-WHO-voorbeelden van Espressif beter.
Werkt de ESP32-CAM zonder internet?
Ja. Projecten die foto's op een microSD-kaart opslaan, werken zonder ooit met wifi te verbinden, en het board kan een eigen accesspoint openen (AP-modus) om live video direct naar je telefoon te streamen. Functies zoals Telegram-meldingen of op afstand kijken hebben wel een internetverbinding nodig.
Welke maat microSD-kaart ondersteunt de ESP32-CAM?
De officiële documentatie noemt kaarten tot 4 GB, maar in de praktijk werken met FAT32 geformatteerde kaarten van 8–32 GB meestal prima. Gebruik je de kaart in 1-bit-modus, dan blijven GPIO 4, 12 en 13 vrij en knippert de flitser-led niet bij elke schrijfactie.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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 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.

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

ESP32 asynchrone webserver (met IP-weergave op lcd)
In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.

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/.

ESP32 OTA-update: firmware draadloos installeren (met lcd-scherm)
In dit project leer je nieuwe firmware naar de ESP32 te uploaden via wifi, zonder USB-kabel. Met de ArduinoOTA-bibliotheek wordt de ESP32 zichtbaar op het netwerk en verschijnt hij automatisch als bluegrays-ota onder "Network port" in de Arduino IDE. De eerste upload gaat via USB; daarna zijn alle updates draadloos, een belangrijke functie voor apparaten die op afstand hangen.
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

