Ratgeber · 10 Min. Lesezeit

ESP32-CAM Projekte: 12 Ideen von Überwachungskamera bis QR-Code

12 ESP32-CAM Projekte: Telegram-Fotos, PIR-Überwachungskamera, Zeitraffer, Roboterauto, QR-Code lesen – mit Tabelle zu Auflösung, Strom, Schwierigkeit und Code.

ESP32-CAM Projekte nutzen die 2-Megapixel-Kamera OV2640, das WLAN und den microSD-Slot dieses streichholzschachtelgroßen Boards zusammen: ein Livestream im Heimnetz, ein Foto, das bei Bewegung auf deinem Handy landet, ein Zeitraffer, der tagelang das Wachstum einer Pflanze aufnimmt, oder ein kleines Bildverarbeitungsexperiment, das einen QR-Code liest. Das Board ist günstig, aber Auflösung, Stromversorgung und Vorkenntnisse unterscheiden sich von Projekt zu Projekt stark. Wer mit dem falschen Projekt anfängt, kämpft meist nicht mit der Kamera, sondern mit Brownout-Fehlern oder vollem Speicher.

In diesem Ratgeber vergleichen wir 12 Projektideen von leicht bis schwer in einer Tabelle: Für jede findest du die empfohlene Auflösung, die Stromversorgung, die zusätzlichen Bauteile und den Schwierigkeitsgrad. Außerdem erklären wir den Unterschied zwischen der AI-Thinker ESP32-CAM und den neueren ESP32-S3-Kameraboards und geben dir fertigen Code, der per PIR oder Timer aufwacht und das Foto auf microSD speichert. Wenn du das Board noch nie benutzt hast, erledige zuerst Einrichtung und ersten Upload mit der ESP32-CAM Anleitung.

AI-Thinker ESP32-CAM Board mit OV2640 Kamera
AI-Thinker ESP32-CAM: OV2640 Kamera, 4 MB PSRAM, microSD-Slot und Blitz-LED an GPIO 4 auf einem Board; eine USB-Buchse fehlt, zum Hochladen brauchst du einen USB-TTL-Adapter.

Die Grenzen des Boards kennen, bevor du ein ESP32-CAM Projekt startest

Im Herzen der ESP32-CAM steckt ein gewöhnlicher ESP32; zum Kameraboard machen ihn der 4 MB PSRAM auf der Platine und das 24-polige Flachbandkabel der Kamera. Die Kamera liefert Bilder direkt als JPEG, der ESP32 muss also nicht Pixel für Pixel komprimieren. Ein JPEG-Bild mit 1600×1200 belegt 100–250 KB und passt nur in den PSRAM. Nach den Pins für Kamera, SD-Karte und PSRAM bleiben nur wenige freie GPIOs: Mit der SD-Karte im 1-Bit-Modus hast du GPIO 12 und 13, ganz ohne SD-Karte zusätzlich GPIO 2, 14 und 15. Dieser Pinmangel bestimmt den Aufbau jedes Projekts mit Motoren oder mehreren Sensoren von Anfang an. Die zweite Grenze ist die Stromversorgung: Ohne Blitz zieht das Board etwa 180 mA, WLAN-Spitzen liegen kurzzeitig deutlich höher, und ein schwaches Netzteil lässt das Board neu starten.

MerkmalAI-Thinker ESP32-CAMESP32-S3-Kameraboard (z. B. XIAO ESP32S3 Sense)
ProzessorESP32, Dual-Core, 240 MHzESP32-S3, Dual-Core, 240 MHz, Vektorbefehle
PSRAM4 MB8 MB (schnellerer Octal-PSRAM)
USBKeins; USB-TTL oder ESP32-CAM-MB nötigUSB-C eingebaut; direkter Upload
Freie GPIOs2 Pins mit SD im 1-Bit-Modus (GPIO 12, 13)5–10 Pins je nach Board
KameraOV2640, 2 MPOV2640 oder OV3660 (je nach Board)
ExtrasmicroSD, Blitz-LEDmicroSD, meist digitales Mikrofon
KIGesichtserkennung langsam und mit niedriger AuflösungMit ESP-DL deutlich schneller
Preis ca.6–10 € (mit Programmierboard)15–25 €
Ideal fürLivestream, Fotos, Telegram, ZeitrafferGesichtserkennung, Ton + Bild, Projekte mit vielen Pins

AI-Thinker oder ESP32-S3-Kameraboard?

Für die meisten Projekte dieser Liste reicht die AI-Thinker ESP32-CAM völlig aus. Alles, was du für Livestream, Einzelfotos, Telegram-Benachrichtigungen und Aufnahmen auf microSD brauchst, ist auf diesem Board, und es ist die günstigste Wahl. Den echten Unterschied machen Bildverarbeitungsprojekte. Die Vektorbefehle des ESP32-S3 führen die neuronalen Netze aus Espressifs ESP-DL-Bibliothek um ein Vielfaches schneller aus als der klassische ESP32, und 8 MB PSRAM fassen größere Modelle und Bildpuffer problemlos. Das eingebaute USB erspart dir außerdem, IO0 bei jedem Upload mit GND zu verbinden. Kurz gesagt: Willst du Gesichtserkennung, ein Babyfon mit Mikrofon oder drei, vier Sensoren neben der Kamera, nimm ein ESP32-S3-Kameraboard; willst du Fotos aufnehmen und verschicken oder speichern, genügt die AI-Thinker.

Bestell zur AI-Thinker gleich das kleine Programmierboard ESP32-CAM-MB mit. Es trägt den USB-Seriell-Wandler und die automatische Upload-Schaltung; du steckst die ESP32-CAM obendrauf, verbindest sie per USB-Kabel mit dem Rechner und lädst Code ohne Kabelsalat hoch.

12 ESP32-CAM Projekte: Tabelle zu Auflösung, Strom und Schwierigkeit

#ProjektEmpfohlene AuflösungStromversorgungZusätzliche TeileSchwierigkeit
1WLAN-Livestream-KameraVGA (640×480)5 V / 2 A NetzteilKeineLeicht
2Sofortfoto und Blitz über eine WebseiteUXGA (1600×1200)5 V / 2 A NetzteilKeineLeicht
3Foto per Telegram bei BewegungSVGA (800×600)5 V / 2 A NetzteilPIR-SensorMittel
4PIR-Überwachungskamera mit microSD-AufnahmeUXGANetzteil oder 18650 + 5 V Step-upPIR, microSD-KarteMittel
5Zeitraffer-Kamera (Timelapse)UXGA oder HDNetzteil oder 18650 + Deep SleepmicroSD-KarteMittel
6Nistkasten- und WildkameraSVGA18650 + SolarmodulPIR, NoIR-Objektiv, 850-nm-IR-LEDsSchwer
7Roboterauto mit Live-VideoQVGA (320×240)2 × 18650Motortreiber, ChassisSchwer
8Schwenk-Neige-Kamera für Baby und HaustierVGA5 V / 2 A Netzteil2 × SG90 Servo, Pan-Tilt-HalterungMittel
9QR-Code-LeserQVGA, Graustufen5 V NetzteilKeineMittel
10GesichtserkennungQVGA oder 240×2405 V / 2 A NetzteilESP32-S3-Board empfohlenSchwer
11Video-Türklingel (Home Assistant)VGA5 V / 2 A NetzteilTaster, BuzzerMittel
12Wasser- oder Gaszähler auslesenSVGA5 V NetzteilGehäuse für festen BildausschnittSchwer

Die Auflösungen in der Tabelle sind ein Ausgangspunkt. Bei Streaming-Projekten bedeutet eine niedrigere Auflösung mehr Bilder pro Sekunde: Bei QVGA erreichst du 20–30, bei UXGA nur noch 2–5. Bei Projekten, die Fotos speichern oder verschicken, spielt die Bildrate keine Rolle, also kannst du die höchste Auflösung wählen. Diese 12 Punkte sind Projektideen, und wir liefern dir das Wissen, um sie wirklich aufzubauen. Die ESP32-Projekte in der BlueGrays-App vermitteln die Bausteine dieser Ideen Schritt für Schritt: ESP32 Bewegungsalarm (PIR + Buzzer + LED + Telegram) zeigt Bewegungserkennung und Telegram-Benachrichtigung, ESP32 Deep Sleep — Batterie sparen den Tiefschlaf und ESP32 Temperatur-Logger das Schreiben von Dateien auf microSD.

Einsteigerprojekte (1–3): Livestream, Sofortfoto und Telegram

Für Projekt 1 musst du keine einzige Zeile Code schreiben: Stelle im Beispiel CameraWebServer der Arduino IDE das Modell CAMERA_MODEL_AI_THINKER ein, trage deine WLAN-Daten ein und lade hoch. Gibst du die im seriellen Monitor angezeigte IP-Adresse im Browser ein, öffnet sich die Einstellungsseite; der Livestream kommt über die Adresse /stream auf Port 81. Stell das Board an einen festen Ort wie Schlafzimmer oder Garage und beobachte es im Heimnetz. Projekt 2 nutzt die Adresse /capture desselben Servers, die bei jeder Anfrage ein einzelnes JPEG liefert. Setz einen Button auf deine eigene Webseite, schalte über GPIO 4 den Blitz ein und nimm das Foto einige hundert Millisekunden später auf – so siehst du jederzeit in einen dunklen Schrank oder auf das Druckbett deines 3D-Druckers.

Projekt 3 ist das beliebteste der Liste: Erkennt ein PIR-Sensor Bewegung, macht die ESP32-CAM ein Foto und schickt es über einen Telegram-Bot auf dein Handy. Da eine sichere Verbindung (HTTPS) zum Telegram-Server aufgebaut und das Foto in Stücken hochgeladen wird, ist SVGA oder XGA ein guter Kompromiss zwischen Tempo und Schärfe. Bot-Einrichtung, Chat-ID und den kompletten Code findest du im Artikel ESP32-CAM Telegram-Foto. Möchtest du erst ohne Kamera starten, baut das Projekt ESP32 Bewegungsalarm in der BlueGrays-App dieselbe Telegram-Logik mit PIR, Buzzer und LED auf; das Foto ergänzt du danach leicht.

Aufnahmeprojekte (4–6): PIR-Kamera, Zeitraffer und Nistkasten

Projekt 4 und Projekt 5 basieren auf demselben Code: Das Board wacht auf, macht ein Foto, speichert es auf microSD und geht wieder in den Tiefschlaf. Da es sich nie mit dem Internet verbindet, ist es viel schneller fertig und funktioniert auch im Garten oder Schuppen ohne WLAN. Der folgende Code nutzt zwei Weckquellen gleichzeitig: Sieht der PIR-Sensor an GPIO 13 eine Bewegung, wacht das Board sofort auf und beginnt den Dateinamen mit pir_; auch ohne Bewegung wacht es alle 10 Minuten auf und speichert ein Zeitrafferbild mit tl_ am Anfang. So ist dasselbe Board Überwachungs- und Zeitrafferkamera zugleich.

BauteilESP32-CAM PinHinweis
PIR (HC-SR501) VCC5VDas Modul hat einen eigenen Spannungsregler und läuft mit 5 V
PIR OUTGPIO 13Der Ausgang liefert 3,3 V und wird direkt angeschlossen; im SD-1-Bit-Modus ist dieser Pin frei
PIR GNDGNDGemeinsame Masse
microSD-KarteSlot auf dem BoardFAT32-formatiert; der 1-Bit-Modus nutzt nur GPIO 2, 14 und 15
Stromversorgung5V und GND5 V / 2 A; Kondensator mit 470–1000 µF zwischen 5V und GND
C++ (Arduino IDE)
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 sleep

Die Details im Code sind wichtig. Da die SD-Karte im 1-Bit-Modus geöffnet wird, bleiben GPIO 4, 12 und 13 frei; so können wir den PIR an GPIO 13 anschließen und verhindern, dass die Blitz-LED bei jedem Schreibvorgang flackert. Die ersten Bilder der Kamera sind oft dunkel oder grünstichig, weil Belichtungsautomatik und Weißabgleich noch nicht eingeschwungen sind; der Code verwirft deshalb drei Bilder und speichert das vierte. Die Dateinummer liegt mit Preferences im nichtflüchtigen Speicher, sodass alte Fotos auch nach einem Stromausfall nicht überschrieben werden. Die Zeile rtc_gpio_hold_en hält GPIO 4 während des Schlafs auf LOW, sonst kann der Blitz im Schlaf schwach glimmen. Vor dem Einschlafen wartet das Board bis zu 10 Sekunden, bis der PIR-Ausgang wieder LOW ist; ein noch aktiver Sensor würde das Board sonst sofort wieder wecken.

Nimm beim Hochladen die microSD-Karte heraus: GPIO 2 ist zugleich SD-Leitung und Boot-Pin, eine eingesteckte Karte kann den Upload stören. Stelle beim HC-SR501 den Retrigger-Jumper auf H und das Zeit-Potentiometer auf den kürzesten Wert; sonst bleibt der Sensor nach einer einzigen Bewegung minutenlang HIGH und verzögert den Schlaf des Boards.

Projekt 6, die Nistkasten- oder Wildkamera, ist derselbe Code mit Akku und Nachtsicht. Das Standardobjektiv der OV2640 hat einen Filter, der Infrarotlicht sperrt; für Bilder bei Nacht brauchst du ein NoIR-Objektiv ohne IR-Filter und 850-nm-Infrarot-LEDs, die Vögel nicht sehen. Die Akkurechnung überrascht: Wegen Spannungsregler und PSRAM zieht das AI-Thinker-Board selbst im Tiefschlaf etwa 6 mA. Ein Board, das alle 10 Minuten 3–4 Sekunden wach ist, kommt im Mittel auf rund 7 mA, und fast alles davon entfällt auf den Schlaf; ein 18650-Akku mit 2600 mAh hält mit 5-V-Step-up etwa 9–10 Tage. Für eine Kamera, die monatelang läuft, ergänze ein kleines Solarmodul oder trenne die Stromversorgung im Schlaf mit einem Timer-Chip wie dem TPL5110 komplett.

Gib Wachzeit, Wachstrom und Schlafstrom in den Akkulaufzeit-Rechner ein, um das passende Intervall für deine Kamera zu finden. Details zum Tiefschlaf und zu den Weckquellen findest du im Artikel ESP32 Deep Sleep.

Projekte mit Bewegung (7–8): Roboterauto und Schwenk-Neige-Kamera

In Projekt 7 wird die ESP32-CAM zum Auge eines Roboterautos: Du siehst das Livebild im Browser deines Handys und fährst mit Buttons auf derselben Seite. QVGA hält die Verzögerung gering. Die vier Eingänge des Motortreibers kommen an GPIO 12, 13, 14 und 15, die ohne SD-Karte frei sind; versorge die Motoren aus einem eigenen Akkupack, nicht aus der 5-V-Leitung des Boards. Chassis, Treiberwahl und Weboberfläche erklärt der Artikel ESP32-CAM Roboterauto Schritt für Schritt. In Projekt 8 drehen zwei SG90-Servos eine Pan-Tilt-Halterung nach links, rechts, oben und unten; du richtest die Kamera vom Handy aus, während du das Babyzimmer oder dein Haustier beobachtest. Die Kamera nutzt den LEDC-Timer 0 für ihr XCLK-Signal, weise der Servo-Bibliothek daher einen anderen Timer zu; sonst wird das Bild gestört oder die Servos zittern.

Bildverarbeitungsprojekte (9–10): QR-Code lesen und Gesichtserkennung

In Projekt 9 liefert die Kamera statt JPEG rohe Graustufenpixel, und eine Bibliothek auf Basis von quirc (zum Beispiel ESP32QRCodeReader) durchsucht jedes Bild nach einem QR-Code. Bei QVGA werden einige Bilder pro Sekunde verarbeitet; das reicht, um einen Code auf einer Kiste zu scannen, eine Tür zu öffnen oder ein Inventar zu führen. Halte den Code 15–25 cm vor die Kamera und sorge für gutes Licht; das Fixfokus-Objektiv der OV2640 sieht zu nahe Codes unscharf. Projekt 10, die Gesichtserkennung, ist das gefragteste und zugleich enttäuschendste Projekt. In den alten 2.0.x-Versionen des Arduino-ESP32-Cores hatte das Beispiel CameraWebServer Schaltflächen für Gesichtserkennung und -wiedererkennung; neuere Versionen haben diese Optionen aus dem Beispiel entfernt. Der klassische ESP32 prüft bei niedriger Auflösung nur wenige Gesichter pro Sekunde, und die Wiedererkennung ist unzuverlässig. Für ein ernsthaftes Projekt liefern ein ESP32-S3-Board und Espressifs ESP-WHO-Beispiele weit bessere Ergebnisse.

Bevor du eine Kamera, die aufnimmt oder Bilder verschickt, in einem Bereich aufstellst, den andere nutzen, sag den Betroffenen Bescheid; Datenschutzgesetze können Aufnahmen in gemeinsam genutzten Bereichen und Kameras, die in Nachbars Garten blicken, einschränken. Stell die Livestream-Adresse auch nicht ohne Passwort ins Internet: CameraWebServer hat keine Anmeldung.

Smart-Home-Projekte (11–12): Video-Türklingel und Zähler auslesen

In Projekt 11 ertönt beim Klingeln ein Buzzer, die ESP32-CAM fotografiert den Eingang und das Bild landet auf deinem Handy. Mit Home Assistant ist die sauberste Lösung die ESPHome-Komponente esp32_camera: Du beschreibst das Board in wenigen YAML-Zeilen, die Kamera erscheint in Home Assistant als Entität, und eine Automation schickt beim Tastendruck einen Schnappschuss als Benachrichtigung (ESPHome einrichten). Projekt 12 macht einen alten mechanischen Wasser- oder Gaszähler smart: Die Kamera wird über dem Zähler befestigt, die Ziffern im von der Blitz-LED beleuchteten Bild liest ein kleines neuronales Netz direkt auf dem Board, und der Verbrauch geht per MQTT an Home Assistant. Dafür wird häufig die fertige Open-Source-Firmware AI-on-the-edge-device genutzt; sie zu flashen und einzurichten geht viel schneller als eigener Code.

Häufige Fehler bei ESP32-CAM Projekten und Lösungen

SymptomMögliche UrsacheLösung
Brownout detector was triggered, das Board startet ständig neuSchwache Versorgung oder dünne, lange Kabel5 V / 2 A Netzteil verwenden, 470–1000 µF Kondensator nah am 5V-Pin ergänzen
Camera init failed with error 0x105Kamera nicht gefunden: Flachbandkabel sitzt nicht oder falsches Modell gewähltFlachbandkabel neu einstecken, Pindefinitionen für CAMERA_MODEL_AI_THINKER prüfen
SD Card Mount FailedKarte nicht FAT32 oder zu großKarte als FAT32 formatieren, 32 GB oder weniger bevorzugen, 1-Bit-Modus testen
Aufnahmen sind dunkel oder grünstichigErste Bilder vor dem Einschwingen der Belichtung aufgenommenVor dem Speichern 2–3 Bilder verwerfen, Blitz vor der Aufnahme einschalten
Livestream friert ein, Bilder fehlenSchwaches WLAN oder hohe AuflösungAuf VGA oder QVGA gehen, Board näher an den Router, externe Antenne nutzen
Akku ist nach wenigen Tagen leerDas Board zieht selbst im Tiefschlaf etwa 6 mAWeckintervall verlängern, Solarmodul ergänzen oder Strom mit TPL5110 trennen
Für eine externe Antenne musst du den 0-Ω-Widerstand neben der IPEX-Buchse von der Position für die interne Antenne auf die für die externe umlöten; nur die Antenne anzustecken ändert nichts. Alle Brownout- und Guru-Meditation-Meldungen findest du im Artikel ESP32 Brownout.

Mit welchem ESP32-CAM Projekt solltest du anfangen?

  • Du nutzt das Board zum ersten Mal: Starte mit Projekt 1. Läuft CameraWebServer, sind Stromversorgung, Upload und WLAN in Ordnung.
  • Du willst Benachrichtigungen aufs Handy: Geh zu Projekt 3; teste den Bot zuerst mit einem PIR-Telegram-Alarm ohne Kamera und ergänze dann das Foto.
  • Du willst ohne Internet aufnehmen: Nutze für Projekt 4 und 5 den Code oben und passe Intervall und Dateinamen an.
  • Du willst eine Kamera, die monatelang mit Akku läuft: Plane Projekt 6 mit Solarmodul oder einem Timer, der den Strom trennt, und rechne den Schlafstrom des Boards mit ein.
  • Du magst Bewegung und Steuerung: Projekt 7 und 8; bring zuerst einen Livestream ohne Motoren zum Laufen und ergänze dann Motortreiber oder Servos.
  • Dich reizt Bildverarbeitung: Beginne mit dem QR-Code-Lesen und wechsle für Gesichtserkennung auf ein ESP32-S3-Board.

Das Schöne an der ESP32-CAM: Mit demselben kleinen Board baust du an einem Wochenende eine funktionierende Überwachungskamera und einen Monat später ein Gerät, das Bilder verarbeitet. Egal welches Projekt du wählst, eine stabile 5-V-Versorgung und die richtige Auflösung sind die halbe Miete. In der BlueGrays-App findest du ESP32-Projekte wie einen Bewegungsalarm mit Telegram-Benachrichtigung, Deep Sleep zum Akkusparen, Datenaufzeichnung auf microSD, mDNS und Updates per OTA, jeweils mit Schaltplan, Teileliste und fertigem Code, sodass du diese Bausteine zu deinem eigenen Kameraprojekt kombinieren kannst.

Häufige Fragen

Was kann man mit einer ESP32-CAM machen?

Mit einer ESP32-CAM baust du eine Livestream-Kamera fürs Heimnetz, einen Alarm, der bei Bewegung ein Foto per Telegram schickt, eine Überwachungskamera mit microSD-Aufnahme, eine Zeitrafferkamera, ein Roboterauto mit Live-Video, einen QR-Code-Leser und eine Video-Türklingel. Da das Board WLAN und eine 2-MP-Kamera vereint, brauchen die meisten Projekte keine Zusatzmodule.

Mit wie viel Volt wird die ESP32-CAM betrieben?

Am zuverlässigsten schließt du ein 5-V-Netzteil mit mindestens 2 A an den 5V-Pin an; der Regler auf dem Board erzeugt daraus 3,3 V. Eine Versorgung über den 3V3-Pin ist möglich, doch der Spannungseinbruch bei gleichzeitigem WLAN- und Kamerabetrieb führt zu Brownout-Fehlern.

Wie lange hält eine ESP32-CAM mit Akku?

Ein Board im Dauer-Livestream zieht im Schnitt etwa 180 mA und läuft mit einem 2600-mAh-18650-Akku und 5-V-Step-up rund 9 Stunden. Ein Board, das zwischen den Fotos im Tiefschlaf wartet, hält Tage bis Wochen; da das AI-Thinker-Board aber selbst im Schlaf etwa 6 mA zieht, sind Monate nur mit Solarmodul oder einem Timer möglich, der den Strom trennt.

Kann die ESP32-CAM Gesichter erkennen?

Sie schafft einfache Gesichtserkennung bei niedriger Auflösung, auf dem klassischen ESP32 ist das aber langsam und die Wiedererkennung unzuverlässig. Neuere Arduino-Core-Versionen haben die Optionen zur Gesichtserkennung aus dem CameraWebServer-Beispiel entfernt; für ein ernsthaftes Projekt passen ein ESP32-S3-Kameraboard und Espressifs ESP-WHO-Beispiele besser.

Funktioniert die ESP32-CAM ohne Internet?

Ja. Projekte, die Fotos auf microSD speichern, kommen ganz ohne WLAN aus, und das Board kann einen eigenen Access Point (AP-Modus) öffnen, um direkt aufs Handy zu streamen. Für Telegram-Benachrichtigungen oder Fernzugriff brauchst du dagegen eine Internetverbindung.

Welche microSD-Karte unterstützt die ESP32-CAM?

Die offizielle Dokumentation nennt Karten bis 4 GB, in der Praxis laufen FAT32-formatierte Karten mit 8–32 GB meist problemlos. Nutzt du die Karte im 1-Bit-Modus, bleiben GPIO 4, 12 und 13 frei und die Blitz-LED flackert nicht bei jedem Schreibvorgang.

Alle Projekte ansehen
ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)
ES-41Fortgeschritten
Premium

ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)

Eine smarte Alarmanlage: Erkennt der PIR-Sensor eine Bewegung, ertönt der Summer, die LED leuchtet und der Besitzer bekommt sofort eine Telegram-Nachricht. Eine Sperrzeit von 30 Sekunden begrenzt, wie oft der Alarm wiederholt wird; Fehlauslösungen des PIR-Sensors verhindert sie nicht. Geeignet für Haus, Garage, Lager oder Arbeitszimmer.

9
Automatische Beleuchtung mit dem ESP32-PIR-Bewegungssensor
ES-19Mittel
Premium

Automatische Beleuchtung mit dem ESP32-PIR-Bewegungssensor

Ein PIR-Bewegungssensor HC-SR501 erkennt, wenn jemand den Raum betritt, und schaltet automatisch eine LED ein. millis() misst, wie lange sie leuchtet: Jedes HIGH erneuert die Zeit der letzten Bewegung, frühestens 10 Sekunden nach dem letzten HIGH geht die LED aus. Der Code wartet zudem in jeder Schleife 50 ms mit delay(50), ist also nicht ganz blockierungsfrei. Ideal für Treppen, Flure, Bäder oder Schrankbeleuchtung.

4.4(24)
38
ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
ES-33Fortgeschritten
Premium

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)

Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

4.3(10)
16
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

4.7(7)
12
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)

Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

4.8(16)
26
ESP32 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)
ES-29Fortgeschritten
Premium

ESP32 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)

Wir ergänzen den ESP32 um einen mDNS-Dienst (Multicast DNS), damit du ihn statt über eine IP-Adresse unter einem lesbaren Hostnamen wie bluegrays-esp.local erreichst. Auch wenn sich die per DHCP vergebene IP ändert, bleibt der Name gleich. Ein kleiner Webserver auf dem Board lässt dich die LED im Browser unter http://bluegrays-esp.local/ steuern.

4.8(14)
23
ESP32-OTA-Update – Drahtlose Firmware-Installation (mit LCD-Display)
ES-30Fortgeschritten
Premium

ESP32-OTA-Update – Drahtlose Firmware-Installation (mit LCD-Display)

Du lernst, neue Firmware ohne USB-Kabel per WLAN auf den ESP32 zu laden. Mit der Bibliothek ArduinoOTA wird der ESP32 im Netzwerk sichtbar und erscheint in der Arduino IDE unter "Network port" automatisch als bluegrays-ota. Das erste Hochladen läuft über USB, danach kommen alle Updates kabellos, eine wichtige Funktion für Geräte im Außeneinsatz.

4.6(14)
22