ESP32-CAM-tutorial: installatie, programmeren, livestream en SD-kaart
ESP32-CAM programmeren: AI-Thinker-pinout, uploaden met ESP32-CAM-MB of USB-TTL, CameraWebServer, PSRAM, 0x105 en brownout oplossen, flitsled, foto's op SD.
De ESP32-CAM is een betaalbaar Wi-Fi-camerabord dat, ondanks zijn formaat van slechts 27 × 40 mm, een ESP32-processor, een OV2640-camera van 2 megapixel, een microSD-kaartsleuf en een witte flitsled bevat. Op zichzelf maakt hij verbinding met je thuisnetwerk, streamt hij live video naar een browser, maakt hij foto's en slaat hij die op een SD-kaart op of verstuurt hij ze via internet. Het is dé keuze voor beveiligingscamera's, deurbelcamera's, time-lapses van plantengroei en robotauto's met video. Maar omdat er geen USB-aansluiting op zit, begin je anders dan bij de ESP32-boards die je misschien gewend bent.
In deze gids leer je de pinout van de AI-Thinker ESP32-CAM kennen, hoe je hem programmeert met de ESP32-CAM-MB-adapter of een USB-TTL-adapter (inclusief de IO0-GND-verbinding), hoe je met het kant-en-klare voorbeeld CameraWebServer een live beeld in je browser krijgt en welke PSRAM- en partitie-instellingen je gebruikt. Daarna bekijk je de oorzaken van de meest voorkomende fouten Camera init failed with error 0x105 en brownout, bestuur je de flitsled en bouw je een sketch die een foto op een microSD-kaart opslaat als je op een knop drukt.

Wat is de ESP32-CAM en hoe werkt hij?
Het hart van het board is de ESP32-S-module met de dualcore-ESP32-chip met Wi-Fi en Bluetooth. De camera wordt met een dunne flatkabel (FPC) in een 24-pins connector op het board gestoken. De ESP32 stuurt een klokssignaal van 20 MHz (XCLK) naar de camera op GPIO 0 en configureert hem via de I2C-achtige SCCB-bus op GPIO 26 en 27. Omdat de OV2640-sensor het beeld zelf naar JPEG kan comprimeren, ontvangt de ESP32 kleine JPEG-frames in plaats van ruwe pixels. Deze frames gaan via een 8-bits parallelle databus naar de 4 MB PSRAM van het board en Wi-Fi brengt ze verder naar een browser of server.
| Eigenschap | Waarde |
|---|---|
| Processor | ESP32 (ESP32-S-module), dualcore, tot 240 MHz |
| Draadloos | Wi-Fi 802.11 b/g/n (alleen 2,4 GHz), Bluetooth 4.2 en BLE |
| Geheugen | 520 KB interne SRAM + 4 MB PSRAM, 4 MB flash |
| Camera | OV2640, 2 MP, tot 1600×1200 (UXGA), JPEG-uitvoer |
| Opslag | microSD-sleuf (tot 4 GB volgens de officiële documentatie) |
| Licht | Witte flitsled (GPIO 4), rode statusled op de achterkant (GPIO 33) |
| Voeding | 5 V op de 5V-pin (aanbevolen) of 3,3 V op de 3V3-pin |
| Stroom (bij 5 V) | Ongeveer 180 mA met flits uit, ongeveer 310 mA met flits op volle sterkte; Wi-Fi-pieken liggen hoger |
| Afmetingen | 27 × 40,5 × 4,5 mm |
AI-Thinker ESP32-CAM-pinout: welke pins zijn vrij?
Er zitten 16 pins langs de twee randen van het board, maar slechts een paar daarvan zijn echt vrij: de camera alleen al gebruikt 15 GPIO's en de microSD-sleuf deelt er nog zes. De tabel hieronder zet de randpins en hun gebruiksmogelijkheden op een rij. Je kunt de algemene pineigenschappen van de ESP32 ook bekijken in de tool Pinout.
| Pin | Functie | Vrij te gebruiken? |
|---|---|---|
| 5V | Voedingsingang (aanbevolen) | - |
| 3V3 | Voedingsingang 3,3 V | - |
| GND (3 pinnen) | Massa | - |
| VCC | Voedingsuitgang (standaard 3,3 V) | Gebruik hem niet om het board van stroom te voorzien |
| U0R (GPIO 3) | Seriële RX: programmeren en Serial Monitor | Alleen als je de seriële poort niet nodig hebt |
| U0T (GPIO 1) | Seriële TX: programmeren en Serial Monitor | Alleen als je de seriële poort niet nodig hebt |
| GPIO 0 | Cameraklok (XCLK) en bootmodus | Nee; alleen met GND verbonden tijdens het uploaden |
| GPIO 16 | Op veel boards verbonden met PSRAM | Nee |
| GPIO 2 | SD DATA0 | Als de SD-kaart niet wordt gebruikt; strapping-pin |
| GPIO 4 | SD DATA1 en flitsled | In SD 1-bitmodus of zonder SD |
| GPIO 12 | SD DATA2 | In SD 1-bitmodus of zonder SD; moet LOW zijn bij het opstarten |
| GPIO 13 | SD DATA3 | In SD 1-bitmodus of zonder SD; de veiligste vrije pin |
| GPIO 14 | SD CLK | Als de SD-kaart niet wordt gebruikt |
| GPIO 15 | SD CMD | Als de SD-kaart niet wordt gebruikt; strapping-pin |
| GPIO 33 | Rode led (niet op de header) | Alleen led; LOW schrijven zet hem aan |
Hoe programmeer je de ESP32-CAM? Twee manieren
De USB-serieel-chip waarmee gewone ESP32-boards met je computer praten, ontbreekt op de ESP32-CAM. Om code te uploaden heb je twee opties: de ESP32-CAM-MB-adapter die onder het board wordt gestoken (een klein basisbord met een CH340-chip en een micro-USB-aansluiting), of een USB-TTL-adapter die je al hebt (FTDI, CH340, CP2102). Welke je ook kiest, de logica is dezelfde: als GPIO 0 LOW is bij het opstarten, gaat de ESP32 in downloadmodus en wacht hij op code; is hij HIGH, dan draait het programma in de flash. De IO0-knop op de MB-adapter en de IO0-GND-draad die je bij een USB-TTL-adapter toevoegt, doen precies dit.

| USB-TTL-adapter | ESP32-CAM | Opmerkingen |
|---|---|---|
| GND | GND | Gemeenschappelijke massa |
| 5V | 5V | Voedt het board; de 3,3 V-uitgang van de adapter is niet genoeg |
| TX | U0R (GPIO 3) | Gekruist: zender naar ontvanger |
| RX | U0T (GPIO 1) | Gekruist: ontvanger naar zender |
| - | Tussen IO0 en GND | Alleen tijdens het uploaden; een korte draad tussen de twee naburige pins |
Heeft je adapter een jumper om te kiezen tussen 3,3 V en 5 V, zet die dan op 3,3 V, zodat de TX-lijn op een niveau blijft dat past bij de pins van de ESP32. Voed het board echter via de 5V-pin van de adapter. De 3,3 V-uitgang van de meeste adapters levert maar zo'n 50–100 mA; zodra de ESP32-CAM Wi-Fi inschakelt, bezwijkt die voeding en start het board opnieuw op.
Instellingen in Arduino IDE: board, partitieschema en PSRAM
- Open de Boards Manager in Arduino IDE en installeer het pakket esp32 by Espressif Systems; de gids Arduino IDE installeren legt dat uitgebreid uit.
- Kies het board AI Thinker ESP32-CAM via Tools › Board › esp32.
- Controleer dat Partition Scheme op Huge APP (3MB No OTA/1MB SPIFFS) staat; het cameravoorbeeld heeft minstens 3 MB programmaruimte nodig.
- Sluit het board aan op de adapter en kies de nieuwe poort via Tools › Port (COMx op Windows, /dev/cu.usbserial... of /dev/cu.wchusbserial... op macOS).
- Verschijnt er helemaal geen poort, installeer dan het CH340- of CP2102-stuurprogramma en gebruik een USB-kabel die ook data doorgeeft.
| Instelling | Aanbevolen waarde | Waarom? |
|---|---|---|
| Board | AI Thinker ESP32-CAM | PSRAM, 4 MB flash en het juiste partitieschema zijn vooraf ingesteld |
| Partition Scheme | Huge APP (3MB No OTA/1MB SPIFFS) | De 3 MB programmaruimte die CameraWebServer nodig heeft |
| PSRAM | Altijd aan in deze boarddefinitie | Zet bij ESP32 Dev Module PSRAM op Enabled; bij ESP32 Wrover Module staat hij al aan |
| CPU Frequency | 240MHz (WiFi/BT) | Hoogste snelheid voor beeldoverdracht en Wi-Fi |
| Flash Mode / Flash Frequency | QIO / 80MHz | Probeer DIO / 40MHz als uploaden of opstarten mislukt |
| Core Debug Level | None (Info bij problemen oplossen) | Bij Info worden camera- en FPS-gegevens naar de Serial Monitor geschreven |
| Upload Speed | 460800 (vast op dit board) | Als uploads blijven afbreken, kies ESP32 Wrover Module en probeer 115200 |
Je eerste upload, stap voor stap
- Bedraad het: steek het board in de MB-adapter met de pins op één lijn, of sluit de USB-TTL-adapter aan zoals in de tabel hierboven. Gebruik je een USB-TTL-adapter, voeg dan ook de korte draad tussen IO0 en GND toe.
- Zet het board in downloadmodus: houd bij de MB-adapter de IO0-knop ingedrukt, druk op RST en laat los, en laat daarna IO0 los. Bij een USB-TTL-adapter druk je gewoon op RST terwijl de IO0-GND-draad erop zit. Sommige MB-adapters met een auto-resetschakeling uploaden zonder dat je op knoppen hoeft te drukken.
- Klik in Arduino IDE op Upload. In de uitvoer zie je eerst Connecting..., gevolgd door de schrijfvoortgang in procenten.
- Verschijnt de regel Hard resetting via RTS pin..., dan is de upload klaar. Gebruik je een USB-TTL-adapter, haal dan nu de IO0-GND-draad weg.
- Open de Serial Monitor op 115200 baud en druk op RST; het nieuwe programma gaat draaien.
1// ESP32-CAM ilk yükleme testi / ESP32-CAM first upload test
2const int KIRMIZI_LED = 33; // arkadaki kırmızı LED, ters mantık / red LED on the back, inverted logic
3
4void setup() {
5 Serial.begin(115200);
6 pinMode(KIRMIZI_LED, OUTPUT);
7 delay(500);
8
9 // PSRAM kontrolü / PSRAM check
10 if (psramFound()) {
11 Serial.print("PSRAM bulundu / PSRAM found: ");
12 Serial.print(ESP.getPsramSize());
13 Serial.println(" bayt / bytes");
14 } else {
15 Serial.println("PSRAM yok / No PSRAM");
16 }
17}
18
19void loop() {
20 digitalWrite(KIRMIZI_LED, LOW); // LOW = yanar / LOW = on
21 delay(500);
22 digitalWrite(KIRMIZI_LED, HIGH); // HIGH = söner / HIGH = off
23 delay(500);
24}Als de upload gelukt is, knippert de kleine rode led op de achterkant van het board elke halve seconde. Deze led werkt met omgekeerde logica: LOW schrijven zet hem aan en HIGH zet hem uit. In de Serial Monitor zou je zo'n 4 miljoen bytes PSRAM moeten zien; staat er No PSRAM, controleer dan je boardkeuze, en helpt dat niet, dan heeft je board misschien geen PSRAM-chip. Door deze korte test vóór het cameravoorbeeld uit te voeren, weet je meteen of een probleem in de upload of in de camera zit.
Het voorbeeld CameraWebServer: een live beeld in je browser
- Open File › Examples › ESP32 › Camera › CameraWebServer.
- Kies het cameramodel: zet in de lijst op het tabblad board_config.h (nieuwere versies) of bovenaan het hoofdbestand (oudere versies) // voor de regel CAMERA_MODEL_ESP_EYE en haal de // voor de regel CAMERA_MODEL_AI_THINKER weg.
- Vul de naam en het wachtwoord van je 2,4 GHz Wi-Fi-netwerk in op de regels ssid en password.
- Zet het board in downloadmodus en upload de sketch; haal daarna de IO0-verbinding weg en druk op RST.
- In de Serial Monitor zie je een regel als Camera Ready! Use 'http://192.168.1.45' to connect; open dat adres in de browser van een telefoon of computer op hetzelfde netwerk.
- Start het live beeld met de knop Start Stream op de pagina, of maak één foto met Get Still.
1// board_config.h (eski sürümlerde CameraWebServer.ino) / (CameraWebServer.ino in older versions)
2//#define CAMERA_MODEL_ESP_EYE // Has PSRAM <- kapat / comment out
3#define CAMERA_MODEL_AI_THINKER // Has PSRAM <- aç / enable
4
5// CameraWebServer.ino
6const char *ssid = "AgAdi"; // Wi-Fi adı / Wi-Fi name
7const char *password = "Sifre123"; // Wi-Fi şifresi / Wi-Fi passwordDe interface draait op twee afzonderlijke servers: de instellingenpagina en het adres /capture, dat één foto teruggeeft, staan op poort 80, terwijl de livestream op /stream op poort 81 staat (bijv. http://192.168.1.45:81/stream). Dit streamadres kun je toevoegen aan je eigen webpagina of aan domoticasoftware. In het menu links kun je de resolutie, JPEG-kwaliteit, helderheid, contrast en witbalans aanpassen. Staat het beeld ondersteboven, gebruik dan de schakelaars V-Flip en H-Mirror; nieuwere versies hebben ook een schuifregelaar LED Intensity voor de flits. Het board bedient meestal maar één kijker tegelijk, dus een stream die je in een tweede tabblad opent, kan vastlopen. Gaat de pagina helemaal niet open, controleer dan of je telefoon en het board op hetzelfde netwerk zitten; bij verbindingsproblemen zie ESP32 maakt geen verbinding met Wi-Fi.
ESP32-CAM-tabel met resolutie en FPS
Op papier kan de OV2640-sensor 15 beelden per seconde leveren bij 1600×1200, 30 bij 800×600 en 60 bij CIF-formaat. In de praktijk wordt de framesnelheid vooral bepaald door de Wi-Fi-verbinding en de grootte van het JPEG-frame: naarmate resolutie en kwaliteit stijgen, wordt elk frame groter en gaat het langzamer over het netwerk. De waarden hieronder zijn ruwe bereiken die je met CameraWebServer ziet bij een goed Wi-Fi-signaal en JPEG-kwaliteit 10–12. Wil je je eigen board meten, zet dan Core Debug Level op Info; tijdens het streamen schrijft de Serial Monitor voor elk frame een regel als MJPG: ... (x fps).
| Resolutie | Pixels | Ca. FPS (Wi-Fi-stream) | Geschikt voor |
|---|---|---|---|
| QQVGA | 160×120 | 25–30 | Bewegingsdetectie, zeer zwakke netwerken |
| QVGA | 320×240 | 20–30 | Robotauto's, vloeiende livevideo |
| CIF | 400×296 | 15–25 | Vloeiend kijken op kleine schermen |
| VGA | 640×480 | 10–20 | Algemeen live kijken |
| SVGA | 800×600 | 8–15 | Scherper kijken; het grootste formaat dat zonder PSRAM bruikbaar is |
| XGA | 1024×768 | 5–10 | Gedetailleerde beelden |
| HD | 1280×720 | 4–8 | Brede (16:9) beeldverhouding |
| SXGA | 1280×1024 | 3–6 | Foto's |
| UXGA | 1600×1200 | 2–5 | Foto's in de hoogste resolutie |
In je eigen code kun je de resolutie, kwaliteit en oriëntatie wijzigen via het sensorobject zodra de camera succesvol is gestart. De JPEG-kwaliteit is een getal van 0 tot 63, waarbij een lager getal een hogere kwaliteit betekent; onder 10 komen frames groter uit en kunnen er half afgemaakte beelden ontstaan.
1// esp_camera_init() başarılı olduktan sonra / after esp_camera_init() succeeds
2sensor_t *s = esp_camera_sensor_get();
3s->set_framesize(s, FRAMESIZE_VGA); // 640x480 çözünürlük / resolution
4s->set_quality(s, 12); // 0-63: küçük = daha kaliteli, 10 altı önerilmez / lower = better, below 10 not advised
5s->set_vflip(s, 1); // görüntüyü dikey çevir / flip vertically
6s->set_hmirror(s, 1); // yatay ayna / mirror horizontally
7s->set_brightness(s, 1); // parlaklık -2..2 / brightness -2..2Waarom is de PSRAM-instelling van de ESP32-CAM zo belangrijk?
Het interne geheugen van de ESP32 is 520 KB en de Wi-Fi-stack gebruikt daar een groot deel van. Eén JPEG-frame van 1600×1200 kan daarentegen 100–250 KB beslaan, afhankelijk van de scène en kwaliteit. Daarom plaatst het cameradriver zijn framebuffers in PSRAM. CameraWebServer controleert met de functie psramFound() of er PSRAM is: zo ja, dan start hij op de hoogste resolutie met twee framebuffers; zo nee, dan beperkt hij de resolutie tot SVGA (800×600) en houdt hij één buffer in het interne geheugen.
Vraag je een hoge resolutie terwijl PSRAM niet is ingeschakeld, dan toont de Serial Monitor frame buffer malloc failed, gevolgd door Camera init failed with error 0xffffffff. De oplossing is AI Thinker ESP32-CAM als board kiezen (bij ESP32 Dev Module zet je Tools › PSRAM: Enabled) of de resolutie verlagen en het aantal framebuffers terugbrengen tot 1. Sommige goedkope klonen hebben helemaal geen PSRAM-chip; de PSRAM-regel in de eerste testsketch maakt dit meteen duidelijk.
Camera init failed with error 0x105 en andere camerafouten
De meeste camerafouten komen neer op een van drie oorzaken: het verkeerde cameramodel in de code, een flatkabel die niet goed in zijn connector zit, of een onvoldoende voeding. Met de foutcode in de Serial Monitor beperk je de oorzaak snel:
| Bericht in de Serial Monitor | Betekenis | Oplossing |
|---|---|---|
| Camera probe failed with error 0x105(ESP_ERR_NOT_FOUND) | De ESP32 vond geen camera op de SCCB-bus | Controleer of CAMERA_MODEL_AI_THINKER is gekozen, steek de flatkabel opnieuw in en voed het board met 5 V / 2 A |
| Detected camera not supported en 0x106 | Dezelfde situatie in nieuwere driverversies: geen camera gevonden of herkend | Dezelfde stappen als bij 0x105; blijft het probleem, vervang dan de cameramodule |
| frame buffer malloc failed en 0xffffffff | Er kon geen geheugen voor de framebuffer worden gereserveerd | Schakel PSRAM in, verlaag de resolutie, zet fb_count op 1 |
| cam_hal: EV-VSYNC-OVF of FB-OVF | Er kwam een nieuw frame binnen voordat het vorige was verwerkt, dus een frame werd overgeslagen | Af en toe onschuldig; als het vaak gebeurt, verlaag de resolutie en verbeter het Wi-Fi-signaal |
| NO-SOI (JPEG start marker missing) | Beschadigd of onvolledig JPEG-frame | Controleer de voeding en flatkabel, zet xclk_freq_hz op 10000000 |
| Beeld half weg, groen of gestreept | Het frame paste niet in de buffer, of de voeding is ruizig | Verhoog de JPEG-kwaliteitswaarde naar 12 of meer, verbeter de voeding |
Brownout-fout en de juiste voeding (5 V / 2 A)
Toont de Serial Monitor Brownout detector was triggered en blijft het board opnieuw opstarten, dan is de voedingsspanning van de ESP32 kortstondig onder een veilig niveau gedaald. De ESP32-CAM trekt korte maar hoge stroompieken zodra hij de Wi-Fi-zender inschakelt en de camera begint op te nemen. Een zwakke USB-poort, dunne en lange jumperdraden of de 3,3 V-uitgang van de adapter kunnen deze pieken niet bijhouden. Dit zijn de blijvende oplossingen:
- Gebruik een voeding die 5 V en minstens 2 A levert en sluit die aan op de 5V-pin van het board; de spanningsregelaar op het board brengt het terug naar 3,3 V.
- Houd de voedingsdraden kort en dik; breadboards en lange jumperdraden vergroten het spanningsverlies.
- Plaats een elco van 470–1000 µF tussen de pins 5V en GND van het board, zo dicht mogelijk bij het board (plus-pootje naar 5V).
- Voed je hem vanaf een computer, steek hem dan direct in een poort aan de achterkant van de pc in plaats van in een USB-hub.
- Gebruik voor batterijvoeding een 18650-cel met een 5 V-boostmodule; dat is veel stabieler dan een rij AA-batterijen.

Online kom je vaak de regel WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0) tegen, die de brownout-detector in code uitschakelt. Dat stopt het opnieuw opstarten, maar lost het probleem niet op: de spanning blijft dalen en het board kan nu vastlopen, beschadigde frames produceren of gegevens verliezen tijdens het schrijven naar flash. Gebruik het alleen voor een tijdelijke test; de volledige lijst met herstartmeldingen staat in de gids ESP32 brownout en Guru Meditation. Ga bij het schatten van de batterijduur uit van een gemiddeld verbruik van 180 mA tijdens continu streamen: een 18650 van 2600 mAh met een boostconverter met 85% rendement geeft ongeveer 1600 mAh aan de 5 V-kant, wat neerkomt op zo'n 9 uur streamen. Je eigen cijfers bereken je met de Batterijduurcalculator; houd er rekening mee dat het board zelfs in deep sleep ongeveer 6 mA trekt vanwege de regelaar en PSRAM.
De flitsled bedienen (GPIO 4)
De felle witte led aan de voorkant van het board wordt aangestuurd via een transistor op GPIO 4. De pin schakelt dus alleen de transistor en de hoge stroom van de led komt van de voedingsrail. digitalWrite(4, HIGH) zet hem aan en LOW zet hem uit. De led is erg fel en als hij lang aan blijft, worden zowel de led als het board warm; je kunt de flits het best maar een paar honderd milliseconden laten branden terwijl je een foto maakt. GPIO 4 is ook de DATA1-lijn van de microSD-kaart, dus als de kaart in 4-bitmodus draait, knippert de flits zelf bij elke lees- en schrijfactie. Om dat te voorkomen, start je de SD-kaart in 1-bitmodus (SD_MMC.begin("/sdcard", true)); op sommige boards kan de led nog steeds heel zwak gloeien.
Foto's opslaan op een microSD-kaart met de ESP32-CAM
De sketch hieronder zet de flits aan, maakt een foto van 1600×1200 en slaat die op de microSD-kaart op als foto1.jpg, foto2.jpg... telkens als je op een knop op GPIO 13 drukt. Formatteer de microSD-kaart op je computer als FAT32; hoewel de officiële documentatie kaarten tot 4 GB noemt, werken FAT32-kaarten van 16–32 GB in de praktijk meestal prima. Sluit één pootje van de knop aan op GPIO 13 en het andere op GND; de sketch schakelt de interne pull-upweerstand in, dus een extra weerstand is niet nodig. Hoe je een knop bedraadt, lees je in Een knop aansluiten op Arduino.
1#include "esp_camera.h"
2#include "FS.h"
3#include "SD_MMC.h"
4
5// AI-Thinker ESP32-CAM kamera pinleri / AI-Thinker ESP32-CAM camera pins
6#define PWDN_GPIO_NUM 32
7#define RESET_GPIO_NUM -1
8#define XCLK_GPIO_NUM 0
9#define SIOD_GPIO_NUM 26
10#define SIOC_GPIO_NUM 27
11#define Y9_GPIO_NUM 35
12#define Y8_GPIO_NUM 34
13#define Y7_GPIO_NUM 39
14#define Y6_GPIO_NUM 36
15#define Y5_GPIO_NUM 21
16#define Y4_GPIO_NUM 19
17#define Y3_GPIO_NUM 18
18#define Y2_GPIO_NUM 5
19#define VSYNC_GPIO_NUM 25
20#define HREF_GPIO_NUM 23
21#define PCLK_GPIO_NUM 22
22
23#define FLAS_LED 4 // beyaz flaş LED'i / white flash LED
24#define BUTON 13 // butonun diğer ucu GND'de / other button leg to GND
25
26int fotoNo = 1; // sıradaki dosya numarası / next file number
27bool hazir = false; // kamera ve SD hazır mı? / are camera and SD ready?
28
29bool kameraBaslat() {
30 camera_config_t config = {};
31 config.ledc_channel = LEDC_CHANNEL_0;
32 config.ledc_timer = LEDC_TIMER_0;
33 config.pin_d0 = Y2_GPIO_NUM;
34 config.pin_d1 = Y3_GPIO_NUM;
35 config.pin_d2 = Y4_GPIO_NUM;
36 config.pin_d3 = Y5_GPIO_NUM;
37 config.pin_d4 = Y6_GPIO_NUM;
38 config.pin_d5 = Y7_GPIO_NUM;
39 config.pin_d6 = Y8_GPIO_NUM;
40 config.pin_d7 = Y9_GPIO_NUM;
41 config.pin_xclk = XCLK_GPIO_NUM;
42 config.pin_pclk = PCLK_GPIO_NUM;
43 config.pin_vsync = VSYNC_GPIO_NUM;
44 config.pin_href = HREF_GPIO_NUM;
45 config.pin_sccb_sda = SIOD_GPIO_NUM;
46 config.pin_sccb_scl = SIOC_GPIO_NUM;
47 config.pin_pwdn = PWDN_GPIO_NUM;
48 config.pin_reset = RESET_GPIO_NUM;
49 config.xclk_freq_hz = 20000000; // 20 MHz kamera saati / 20 MHz camera clock
50 config.pixel_format = PIXFORMAT_JPEG;
51
52 if (psramFound()) {
53 config.frame_size = FRAMESIZE_UXGA; // 1600x1200
54 config.jpeg_quality = 10; // küçük = daha kaliteli / lower = better quality
55 config.fb_count = 2;
56 config.fb_location = CAMERA_FB_IN_PSRAM;
57 config.grab_mode = CAMERA_GRAB_LATEST;
58 } else {
59 config.frame_size = FRAMESIZE_SVGA; // PSRAM yoksa 800x600 / 800x600 without PSRAM
60 config.jpeg_quality = 12;
61 config.fb_count = 1;
62 config.fb_location = CAMERA_FB_IN_DRAM;
63 config.grab_mode = CAMERA_GRAB_WHEN_EMPTY;
64 }
65
66 esp_err_t err = esp_camera_init(&config);
67 if (err != ESP_OK) {
68 Serial.printf("Camera init failed 0x%x (%s)\n", err, esp_err_to_name(err));
69 return false;
70 }
71 return true;
72}
73
74void fotoCek() {
75 digitalWrite(FLAS_LED, HIGH); // flaşı yak / flash on
76 delay(150); // pozlama otursun / let exposure settle
77
78 camera_fb_t *fb = esp_camera_fb_get(); // eski kareyi at / discard the stale frame
79 if (fb) esp_camera_fb_return(fb);
80 fb = esp_camera_fb_get(); // asıl fotoğraf / the real photo
81 digitalWrite(FLAS_LED, LOW); // flaşı söndür / flash off
82
83 if (!fb) {
84 Serial.println("Kare alinamadi / Capture failed");
85 return;
86 }
87
88 String yol = "/foto" + String(fotoNo) + ".jpg";
89 File dosya = SD_MMC.open(yol, FILE_WRITE);
90 if (dosya) {
91 dosya.write(fb->buf, fb->len); // JPEG verisini yaz / write the JPEG data
92 dosya.close();
93 Serial.printf("Kaydedildi / Saved: %s (%u bayt / bytes)\n", yol.c_str(), (unsigned)fb->len);
94 fotoNo++;
95 } else {
96 Serial.println("Dosya acilamadi / Could not open file");
97 }
98 esp_camera_fb_return(fb); // tamponu geri ver / return the buffer
99}
100
101void setup() {
102 Serial.begin(115200);
103 pinMode(BUTON, INPUT_PULLUP);
104
105 if (!kameraBaslat()) return; // kamera yoksa dur / stop without a camera
106
107 // 1-bit mod: GPIO 4, 12 ve 13 boşta kalır / 1-bit mode keeps GPIO 4, 12 and 13 free
108 if (!SD_MMC.begin("/sdcard", true)) {
109 Serial.println("SD kart takilamadi / SD card mount failed");
110 return;
111 }
112 if (SD_MMC.cardType() == CARD_NONE) {
113 Serial.println("SD kart yok / No SD card");
114 return;
115 }
116
117 pinMode(FLAS_LED, OUTPUT);
118 digitalWrite(FLAS_LED, LOW);
119
120 // Var olan fotoğrafların üzerine yazma / don't overwrite existing photos
121 while (SD_MMC.exists("/foto" + String(fotoNo) + ".jpg")) fotoNo++;
122
123 hazir = true;
124 Serial.println("Hazir, butona bas / Ready, press the button");
125}
126
127void loop() {
128 if (!hazir) { // hata varsa bekle / wait if setup failed
129 delay(1000);
130 return;
131 }
132 if (digitalRead(BUTON) == LOW) {
133 delay(30); // buton sıçramasını (bounce) önle / debounce
134 if (digitalRead(BUTON) == LOW) {
135 fotoCek();
136 while (digitalRead(BUTON) == LOW) delay(10); // bırakılmasını bekle / wait for release
137 }
138 }
139}Omdat de sketch de SD-kaart in 1-bitmodus start, gebruikt hij alleen GPIO 2, 14 en 15, zodat GPIO 4 beschikbaar blijft voor de flits en GPIO 13 voor de knop. Voordat de foto wordt genomen, wordt één frame opgehaald en meteen teruggegeven: de camera produceert continu frames, dus het eerste frame in de buffer kan zijn opgenomen voordat de flits aanging, en de automatische belichting heeft een korte pauze nodig om zich aan het nieuwe licht aan te passen. Het bestandsnummer wordt bepaald door te kijken naar de bestanden die al op de kaart staan, zodat oude foto's ook na een herstart niet worden overschreven. Voor de algemene regels voor het loggen van data op een SD-kaart kun je de gids SD-kaartmodule bekijken.
MicroPython en nieuwere cameraboards
Je kunt de ESP32-CAM ook met MicroPython programmeren, maar de officiële MicroPython-build bevat geen cameradriver; je moet een community-firmware met camera-ondersteuning flashen. Daarom is de route via Arduino IDE voor beginners veel soepeler. Wil je liever geen board zonder USB-aansluiting, kijk dan ook naar cameraboards op basis van de ESP32-S3 met USB en meer geheugen (bijv. de Seeed XIAO ESP32S3 Sense of de ESP32-S3-EYE); ook deze boards staan in de modellenlijst van CameraWebServer.
Projectideeën voor de ESP32-CAM
- Foto bij beweging: maak een foto als een PIR-sensor iemand opmerkt en stuur die naar je telefoon; de stapsgewijze gids staat in ESP32-CAM-foto's naar Telegram.
- Time-lapse-opname: laat het board elke 10 minuten wakker worden, een foto maken, die op de SD-kaart opslaan en weer in deep sleep gaan; zie een plant groeien of het weer veranderen.
- Deurbelcamera: fotografeer je voordeur als op de belknop wordt gedrukt en stuur een melding met een Telegram-bot.
- Robotauto met video: bestuur de auto terwijl je op je telefoon een vloeiende QVGA-livestream bekijkt.
- Huisdiercamera: bekijk de livestream op je thuisnetwerk en zet de flits indien nodig aan vanaf de webpagina.
- Je eigen bedieningspaneel: bed de livestream in je eigen webpagina in en voeg daarnaast relais en sensoruitlezingen toe; de gids ESP32 WebSocket wijst de weg.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Failed to connect to ESP32: No serial data received (in oudere versies: Timed out waiting for packet header) | Het board staat niet in downloadmodus, of TX en RX zijn verkeerd aangesloten | Verbind IO0 met GND of gebruik de IO0-knop, druk op RST; controleer dat TX naar U0R gaat en RX naar U0T |
| Wrong boot mode detected (0x13) | GPIO 0 was niet LOW bij het opstarten | Druk altijd op RST nadat je de IO0-GND-verbinding hebt gemaakt |
| waiting for download in de Serial Monitor | IO0 zit nog aan GND | Haal de IO0-draad weg en druk op RST |
| Onleesbare tekens in de Serial Monitor | Verkeerde baudrate | Zet de Serial Monitor op 115200 baud |
| Board ontbreekt in de poortlijst | Ontbrekend stuurprogramma, of een kabel die alleen oplaadt | Installeer het CH340- of CP2102-stuurprogramma, gebruik een datakabel |
| Upload mislukt met de SD-kaart erin | GPIO 2 is zowel een SD-lijn als een strapping-pin | Haal de microSD-kaart eruit tijdens het uploaden |
| Zeer trage of vaak vastlopende beelden | Zwak Wi-Fi-signaal of hoge resolutie | Ga naar VGA of QVGA, zet het board dichter bij de router, gebruik zo nodig een externe antenne |
| Flits gloeit de hele tijd zwak | SD-kaart in 4-bitmodus, of GPIO 4 zweeft | Start de SD-kaart in 1-bitmodus, zet GPIO 4 op OUTPUT en schrijf LOW |
De ESP32-CAM is de eenvoudigste manier om een Wi-Fi-camera op een betaalbaar board te bouwen, en bijna elke moeilijkheid die je tegenkomt, komt voort uit de programmeerverbinding of de voeding. Als je die twee goed krijgt, streamt het board livevideo vanaf zijn eigen webserver, maakt het foto's en slaat het ze op een SD-kaart op. In de BlueGrays-app vind je ESP32-projecten zoals Wi-Fi-verbinding, webserver, mDNS, datalogging op microSD en een bewegingsalarm met Telegram-meldingen, elk met stapsgewijze schakelschema's en kant-en-klare code.
Veelgestelde vragen
Hoe programmeer je de ESP32-CAM?
Omdat de ESP32-CAM geen USB-aansluiting heeft, heb je een ESP32-CAM-MB-adapter of een USB-TTL-adapter nodig. In Arduino IDE kies je het board AI Thinker ESP32-CAM en zet je het board in downloadmodus door op RST te drukken terwijl GPIO 0 met GND is verbonden (of terwijl de IO0-knop op de MB ingedrukt wordt gehouden). Haal na de upload de IO0-verbinding weg en druk opnieuw op RST.
Kun je de ESP32-CAM programmeren met een Arduino Uno?
Ja; als je de RESET-pin van de Uno met GND verbindt, werkt zijn USB-chip als een USB-seriële brug. De bedrading is dan recht, niet gekruist: D0 (RX) van de Uno gaat naar U0R, D1 (TX) gaat naar U0T en IO0 blijft met GND verbonden. Omdat de signalen van de Uno 5 V zijn, brengt dit de ESP32 aan zijn grenzen; voor regelmatig gebruik is een MB-adapter of een 3,3 V USB-TTL-adapter veiliger.
Welke spanning heeft de ESP32-CAM nodig?
Het board voeden met 5 V op de 5V-pin is aanbevolen; de spanningsregelaar op het board brengt het terug naar 3,3 V. Je kunt ook 3,3 V op de 3V3-pin aanleggen, maar als de bron de Wi-Fi-stroompieken niet aankan, blijft het board opnieuw opstarten. Een voeding die minstens 2 A kan leveren, voorkomt de meeste brownout-fouten.
Hoe los je de ESP32-CAM-fout Camera init failed op?
Foutcode 0x105 of 0x106 betekent dat de camera helemaal niet is gevonden: controleer eerst of CAMERA_MODEL_AI_THINKER in de code is gekozen, daarna of de flatkabel er volledig in zit, en voed het board met 5 V / 2 A. Blijft het probleem, dan is de cameramodule mogelijk defect. Zie je 0xffffffff samen met frame buffer malloc failed, schakel dan PSRAM in of verlaag de resolutie.
Werkt de ESP32-CAM zonder internet?
Ja. Om het beeld te bekijken heb je alleen een lokaal netwerk nodig, geen internet; de ESP32-CAM kan met WiFi.softAP() ook zijn eigen Wi-Fi-netwerk aanmaken en is dan in de browser bereikbaar op 192.168.4.1. Je kunt hem zelfs zonder netwerk gebruiken als camera die alleen foto's op een microSD-kaart opslaat.
Kan de ESP32-CAM video opnemen?
De kant-en-klare voorbeelden streamen livevideo als MJPEG en maken losse foto's; ze nemen niet direct een videobestand op. Er zijn community-projecten die opeenvolgende JPEG-frames naar een microSD-kaart schrijven om een AVI-bestand te maken, maar de framesnelheid is zelfs bij lage resoluties beperkt. Het board heeft geen microfoon, dus ook geluid kan het niet opnemen.
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 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.

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

