Programmierung der ESP32-CAM

In diesem Artikel lernen Sie die Programmierung des ESP32-CAM Moduls. Die ESP32-Kameramodule sind vergleichsweise günstig und sehr gut geeignet, um einfache Überwachungs- oder Monitoring-Systeme zu bauen. Beispielsweise automatisch nachts Bilder von Tieren im Garten zu machen oder Besucher an der Haustür per Webcam anzukündigen, sind gängige Anwendungsfälle.

Das Hochladen und Ausführen von Programmen auf den gängigen ESP32-CAM Entwicklungsboards ist jedoch etwas knifflig. In diesem Artikel betrachten wir verschiedene Methoden, um ein ESP32-CAM Board zu programmieren und Fehler zu beheben.

Benötigte Teile

Nachfolgend finden Sie die Komponenten, die für den Aufbau des Projekts benötigt werden. Einige Teile wie USB-Kabel, micro SD-Karte oder SD-Kartenleser haben Sie vielleicht schon. Dann müssen Sie diese nicht extra kaufen, da keines dieser Teile speziell für dieses Projekt ist.

Wenn Sie keinen FTDI USB-TTL Adapter haben, dann ist das definitiv etwas, das Sie sich zulegen sollten. Früher oder später werden Sie einen brauchen, wenn Sie weiter mit ESP32 Mikrocontrollern basteln. Der hier aufgeführte ist ein einfacher, aber für die meisten Fälle ausreichend.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Grundlagen des ESP32-CAM Entwicklungsboards

Das ESP32-CAM Entwicklungsboard ist ein kompaktes Modul, das einen ESP32-S Chip, eine Kamera, einen eingebauten Blitz und einen microSD-Kartensteckplatz kombiniert. Das Board verfügt über integriertes Wi-Fi und Bluetooth und unterstützt eine OV2640 oder OV7670 Kamera mit bis zu 2 Megapixel Auflösung.

Die detaillierte Spezifikation des Boards finden Sie unten. Beachten Sie, dass wir im Beispielcode auf das originale AI-Thinker Modell des ESP32-CAM Boards verweisen, es aber viele Klone mit gleichen oder ähnlichen Spezifikationen gibt.

Diese werden im Allgemeinen auf die gleiche Weise programmiert und verwendet. Es gibt jedoch eine Ausnahme. Wenn Ihr Board eine Pinleiste mit 6 Reihen (statt nur 4 Reihen) hat, kann es leichter mit dem Programmier-Shield programmiert werden. Siehe das Bild unten zum Vergleich:

Es gibt auch einen Unterschied beim GND-Pin (rot markiert). In Version 1 (linke Seite) ist dieser Pin mit GND/R beschriftet und wird zum Zurücksetzen des Boards verwendet. In Version 2 (rechte Seite) dient dieser Pin als Masse (GND).

Version 2 auf der rechten Seite mit den 4 Pins erfordert, dass Sie beim Hochladen den BOOT- und RST-Knopf manuell drücken (dazu später mehr), während Version 1 dies automatisch macht. Leider ist Version 2 recht verbreitet, und es ist in diesem Fall einfacher, einen FTDI-Programmierer statt des Programmier-Shields zu verwenden.

Eigenschaften

• Ultrakleines 802.11b/g/n Wi-Fi + BT/BLE SoC Modul.
• Niedrigstrom-Dual-Core 32-Bit CPU für Anwendungsprozessoren.
• Hauptfrequenz bis zu 240MHz, Rechenleistung bis zu 600 DMIPS.
• Eingebauter 520 KB SRAM, externer 4M PSRAM.
• Unterstützt Schnittstellen wie UART/SPI/I2C/PWM/ADC/DAC.
• Unterstützt OV2640 und OV7670 Kameras, eingebauter Blitz.
• Unterstützt Bild-Upload über WiFi, unterstützt TF-Karte.
• Unterstützt mehrere Schlafmodi
• Unterstützt STA/AP/STA+AP Betriebsmodi.

Spezifikationen

• Größe: 27*40.5*4.5(±0.2)mm
• SPI Flash: Standardmäßig 32Mbit
• RAM: Intern 520KB + extern 4M PSRAM
• BT: BT 4.2BR/EDR und BLE Standards
• WiFi: 802.11 b/g/n/e/i
• Unterstützte Schnittstellen: UART, SPI, I2C, PWM
• Unterstützt TF-Karte: 4G (meist bis zu 16GB funktionsfähig)
• IO Ports: 9
• Bild-Ausgabeformat: JPEG (nur von OV2640 unterstützt), BMP, GRAYSCALE
• Antenne: Onboard-Antenne, Gewinn 2dBi
• Sicherheit: WPA/WPA2/WPAS-Enterprise/WPS
• Stromversorgungsbereich: 5V
• Arbeitstemperatur: -20 °C bis 85 °C

Stromverbrauch

• Ohne Blitz: 180mA@5V
• Mit Blitz bei maximaler Helligkeit: 310mA@5V
• Deep-Sleep: 6mA@5V
• Modem-Sleep: 20mA@5V
• Light-Sleep: 6.7mA@5V

Pinbelegung

Das folgende Bild zeigt die Pinbelegung des ESP32-CAM. Beachten Sie, dass der ESP32-CAM theoretisch mit 3,3V betrieben werden kann, aber instabiles Verhalten und Bilder mit Wasserzeichen berichtet wurden. Die empfohlene Stromversorgung ist daher 5V @ 2A.

Beachten Sie auch, dass IO0 mit dem Kamera-XCLK-Pin verbunden ist und beim Betrieb des ESP32 frei (nicht verbunden) bleiben sollte. IO0 sollte nur beim Hochladen von Code auf GND gezogen werden. Mehr dazu später.

Im Vergleich zu einem Standard-ESP32-Board hat das ESP32-CAM Board deutlich weniger verfügbare GPIO-Pins. Das liegt daran, dass die meisten GPIO-Pins von der Kamera und dem SD-Kartenleser belegt sind. Außerdem sollten Sie GPIO1, GPIO3 und GPIO0 vermeiden, da diese für die Programmierung benötigt werden. Weitere Informationen finden Sie im More GPIO pins for ESP32-CAM Tutorial.

Der P_OUT Pin ist auf manchen Boards als VCC beschriftet. Es ist ein Ausgangspin, der je nach solder pad 3,3V oder 5V ausgibt. Sie können diesen Pin nicht zur Stromversorgung des Boards verwenden! Nutzen Sie dafür den 5V-Pin.

Seien Sie auch vorsichtig mit den Masse-Pins.Vermeiden Sie die Verwendung des GND-Pins neben GPIO1!Bei manchen ESP32-CAM Boards ist dieser Pin als GND/R beschriftet und wird zum Zurücksetzen des Boards verwendet. Sie können ihn nicht als Masse verwenden. Zur Sicherheit sollten Sie immer den GND-Pin in der Nähe von GPIO0 verwenden.

Schließlich werden die GPIO-Pins 2, 4, 12, 13, 14 und 15 vom SD-Kartenleser verwendet. Wenn Sie den SD-Kartenleser nicht nutzen, sind diese Pins als GPIO verfügbar. Die eingebaute Blitz-LED ist an GPIO 4 angeschlossen, was dazu führt, dass die Blitz-LED leuchtet, wenn der SD-Kartenleser aktiv ist. Sie können den folgenden Code verwenden, um dies zu vermeiden:

SD_MMC.begin("/sdcard", true)

Weitere Informationen zur Pinbelegung des ESP32-CAM Boards finden Sie in diesem RandomNerd Tutorial: ESP32-CAM AI-Thinker Pinout Guide: GPIOs Usage Explained.

Schaltpläne

Wenn Sie ein detailliertes Verständnis der internen Verdrahtung des ESP32-CAM Boards benötigen, werfen Sie einen Blick auf die folgenden Schaltpläne (source). Klicken Sie auf das Bild, um es zu öffnen, oder download das PDF mit den Schaltplänen in voller Auflösung.

Installation des ESP32 Cores

Um den ESP32-CAM zu programmieren, benötigen Sie die Arduino IDE mit installiertem ESP32 Board Support. Glücklicherweise ist die Installation des ESP32 Cores sehr einfach. Starten Sie einfach Ihre Arduino IDE und folgen Sie den unten beschriebenen Schritten. Bei Problemen finden Sie detailliertere Anleitungen in unserem Tutorial How to Program ESP32 with Arduino IDE.

Zusätzliche URLs für den Boards Manager

Öffnen Sie zunächst den Preferences-Dialog, indem Sie im Menü „File“ „Preferences…“ auswählen:

Es öffnet sich der unten gezeigte Preferences-Dialog. Unter dem Tab „Settings“ finden Sie unten ein Eingabefeld mit der Bezeichnung „Zusätzliche URLs für den Boards Manager„:

Kopieren Sie in dieses Eingabefeld die folgende URL: „https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json„

Damit weiß die Arduino IDE, wo sie die ESP32 Core Bibliotheken findet. Als nächstes installieren wir die ESP32 Core Bibliotheken über den Boards Manager.

Boards Manager

Öffnen Sie den BOARDS MANAGER, indem Sie auf das Board-Symbol in der Seitenleiste klicken, wie unten gezeigt:

Der BOARDS MANAGER erscheint rechts neben der Seitenleiste. Geben Sie oben im Suchfeld „ESP32“ ein, und Sie sollten zwei Arten von ESP32 Boards sehen: die „Arduino ESP32 Boards“ und die „esp32 von Espressif“ Boards. Wir wollen die esp32 Bibliotheken von Espressif. Klicken Sie auf die INSTALL Schaltfläche und warten Sie, bis der Download und die Installation abgeschlossen sind.

Nach der Installation sollte Ihr Boards Manager so aussehen, wobei die tatsächliche Version (hier 3.0.0-a) abweichen kann.

Im nächsten Schritt zeige ich Ihnen, wie Sie das ESP32 Board auswählen, das Sie programmieren möchten.

Board auswählen

Um ein Board auszuwählen, gehen Sie ins Tools-Menü. Klicken Sie auf Board: „Arduino Uno“. Möglicherweise sehen Sie ein anderes Board als unten gezeigt, das ist in Ordnung. Gehen Sie ins Untermenü, dort sollten Sie die „Arduino AVR Boards“ und darunter „esp32“ sehen (wie Sie sehen, habe ich auch die esp8266 Boards installiert). Klicken Sie auf „esp32“ und Sie erhalten eine große Liste verfügbarer Boards.

Finden Sie das AI Thinker ESP32-CAM Board in der Liste und klicken Sie darauf.

Jetzt sind Sie bereit, Code auf das ESP32-CAM Board hochzuladen und auszuführen. Ich zeige Ihnen zwei verschiedene Wege, dies zu tun. Sie können eines der Programmier-Shields verwenden, die oft zusammen mit dem ESP32-CAM Modul verkauft werden. Oder Sie verwenden einen separaten und universelleren FTDI-Programmierer. Wir beginnen mit dem Programmier-Shield.

Code mit einem Programmier-Shield hochladen

Wenn Sie einen ESP32 Chip direkt programmieren wollen, müssen Sie die serielle UART-Schnittstelle verwenden. Diese ist über die U0TXD und U0RXD Pins im Pinout verfügbar. Wir wollen den ESP32 jedoch über den USB-Port unseres Computers (und die Arduino IDE) programmieren. Dafür benötigen wir einen USB-zu-UART Konverter.

Programmier-Shield

Viele Entwicklungsboards mit ESP32 haben einen integrierten Chip (CH340), der diese USB-zu-UART Umwandlung übernimmt, aber das ESP32-CAM Modul leider nicht. Sie benötigen daher ein Programmier-Shield, wie unten dargestellt, oder einen FTDI-Programmierer, den wir später besprechen.

Stapeln Sie einfach das ESP32-CAM Modul auf das Programmier-Shield, wie unten gezeigt, verbinden Sie ein USB-Kabel vom Programmier-Shield mit Ihrem Computer, und Sie sind bereit zum Programmieren.

Programmier-Shield mit dem Computer verbinden

Stellen Sie zunächst sicher, dass das USB-Kabel richtig angeschlossen und funktionsfähig ist. Sie sollten beim Einstecken des USB-Kabels einen Ping-Ton vom Computer hören und eine rote LED am Programmier-Shield leuchtet auf. Stellen Sie als nächstes sicher, dass Sie das AI Thinker ESP32-CAM Board und den richtigen seriellen Port ausgewählt haben. Siehe Bild unten.

Der serielle Port, den Sie sehen, wird wahrscheinlich anders sein. Er hängt von Ihrem Computer und dem verwendeten USB-Port ab, mit dem Sie den ESP32-CAM verbinden.

Programmiermodus

Um ein Programm auf den ESP32-CAM hochzuladen, müssen Sie Folgendes tun:

Starten Sie den Upload über die Upload-Schaltfläche in der Arduino IDE:

Drücken und halten Sie auf dem Programmier-Shield die IO0 Taste an der Seite des Moduls:

Warten Sie, bis der Text „Connecting …..“ im Ausgabefenster erscheint:

Dann (während Sie IO0 weiterhin gedrückt halten) drücken und lassen Sie die RST-Taste (eine halbe Sekunde) am ESP32-CAM los (NICHT am Programmier-Shield!). Diese Taste befindet sich an einer ungünstigen Stelle, aber die RST-Taste am Programmier-Shield funktionierte bei mir nicht. Das Bild unten zeigt die Position der RST-Taste, die gedrückt werden muss.

Wenn die Punkte im Text „Connecting …..“ nicht mehr erscheinen, können Sie auch die IO0-Taste loslassen. Danach sollten Sie im Ausgabefenster folgenden Text sehen, der anzeigt, dass der Code jetzt hochgeladen wird:

Betriebsmodus

Sobald der Text „Hard resetting via RTS pin…“ im Ausgabefenster erscheint, ist der Upload abgeschlossen. Sie können das hochgeladene Programm ausführen, indem Sie die RST-Taste am ESP32-CAM Modul drücken. Wie zuvor, verwenden Sie nicht die RST-Taste am Programmier-Shield und drücken Sie nicht die IO0-Taste.

Sie können den folgenden Testcode verwenden, um den Upload zu testen.

Testcode für ESP32-CAM mit Programmier-Shield

Dies ist ein einfaches Blink-Programm, das die Blitz-LED am ESP32-CAM für 10 ms einschaltet, dann 2 Sekunden wartet und den Zyklus wiederholt.

int flashPin = 4;

void setup() {
  pinMode(flashPin, OUTPUT);
}

void loop() {
  digitalWrite(flashPin, HIGH);
  delay(10);
  digitalWrite(flashPin, LOW);
  delay(2000);
}

Wenn Sie die LED blinken sehen, haben Sie erfolgreich ein Programm auf den ESP32-CAM hochgeladen.

Sie haben vielleicht bemerkt, dass das Hochladen von Code auf den ESP32-CAM ein wirklich umständlicher Vorgang ist. Man würde erwarten, dass das Programmier-Shield den ESP32 automatisch in den Programmiermodus versetzt und man keine Tasten drücken muss, aber das funktionierte bei keinem der beiden von mir getesteten Programmier-Shields.

Selbst dann scheint das Timing etwas kritisch zu sein und die Kommunikation ist anfällig. Ich musste oft mehrmals versuchen, um einen erfolgreichen Upload zu erreichen. Häufig half es, das USB-Kabel zu trennen und wieder anzuschließen. Manchmal startete der Upload auch ohne dass ich Tasten gedrückt habe, nachdem ich den USB-Port gewechselt hatte.

Im nächsten Abschnitt zeige ich Ihnen, wie Sie einen FTDI-Programmierer verwenden, der das Hochladen von Code etwas einfacher macht, aber immer noch nicht vollautomatisch ist.

Code mit einem FTDI-Programmierer hochladen

Ein FTDI-Programmierer oder FTDI USB-TTL Adapter übernimmt im Wesentlichen die gleiche Aufgabe wie das Programmier-Shield für den ESP32-CAM. Er wandelt USB-Signale in serielle Signale um und ermöglicht die Programmierung von Mikrocontrollern wie Arduino und ESP32 über die UART-Schnittstelle.

Im Gegensatz zum Programmier-Shield ist der FTDI-Programmierer nicht für ein bestimmtes Board, sondern kann mit allen Mikrocontrollern verwendet werden, die serielle Kommunikation unterstützen. Während der FTDI-Programmierer flexibler ist, müssen Sie die Verkabelung zwischen FTDI-Programmierer und Mikrocontroller selbst vornehmen. Und genau das machen wir im folgenden Abschnitt.

Verbindung des FTDI-Programmierers mit ESP32-CAM

Das folgende Bild zeigt, wie Sie den FTDI-Programmierer mit dem ESP32-CAM Modul verbinden:

Die Verbindungen sind einfach. Beginnen Sie damit, GND des Programmierers mit GND des ESP32-CAM Moduls zu verbinden (blaues Kabel). Dann verbinden Sie die 5V Stromversorgung (rotes Kabel). Beachten Sie, dass einige FTDI-Programmierer Jumper oder Schalter haben, um zwischen 3,3V und 5V umzuschalten. Achten Sie darauf.

Als nächstes verbinden wir den U0T (U0TXD) Pin des ESP32-CAM mit dem RXD Pin des Programmierers (gelbes Kabel). Ebenso wird U0R mit TXD verbunden (grünes Kabel). Damit ist die serielle Kommunikation hergestellt.

Um den ESP32-CAM in den Programmiermodus zu versetzen, muss der IO0 Pin mit Masse (GND) verbunden werden. Möchten Sie das Programm ausführen, muss der IO0 Pin frei bleiben. Ich habe daher einen Schalter zwischen IO0 und GND (violettes Kabel) eingebaut, der mir erlaubt, zwischen Programmier- und Betriebsmodus zu wechseln. Siehe Bild unten:

ESP32-CAM Board auswählen

Stecken Sie den FTDI-Programmierer mit angeschlossenem ESP32-CAM in den USB-Port, klicken Sie im Arduino IDE Dropdown-Menü auf „Select other board and port…“:

Es öffnet sich ein Dialog, in dem Sie „ESP32-CAM“ in die Suchleiste eingeben. Sie sehen das „AI Thinker ESP32-CAM“ Board unter Boards. Klicken Sie darauf, wählen Sie den COM-Port aus, um es zu aktivieren, und klicken Sie dann auf OK:

ESP32-CAM wird am COM-Port nicht erkannt

Wenn Sie trotz angeschlossenem ESP32-CAM über den FTDI-Programmierer keinen PORT auswählen können, fehlt der CP210X Treiber. Gehen Sie zu SILICON LABS Software Downloads und laden Sie den CP210x Treiber für Ihr Betriebssystem herunter, z.B. für Windows „CP210x VCP Windows“:

Dies lädt eine ZIP-Datei herunter. Entpacken Sie diese und führen Sie den Installer aus. Danach sollte Ihr ESP32-CAM als an einen USB-Port angeschlossen erscheinen. Wenn Sie weiterhin Probleme haben, müssen Sie möglicherweise auch den FTDI Driver für den FTDI-Programmierer installieren.

Programmiermodus

Das Programmieren mit dem FTDI-Programmierer ist dem mit dem Programmier-Shield sehr ähnlich. Beginnen Sie damit, das ESP32-CAM Modul in den Programmiermodus zu versetzen, indem Sie den Schalter umlegen (IO0 mit GND verbinden).

Drücken Sie dann die Upload Taste in der Arduino IDE:

Warten Sie, bis der Text „Connecting …..“ im seriellen Monitor erscheint:

Drücken und lassen Sie dann schnell die RST-Taste am ESP32-CAM los.

Die Punkte nach „Connecting …..“ sollten aufhören zu erscheinen und Sie sollten den Upload-Fortschritt im Ausgabefenster sehen:

Was auch zu funktionieren scheint, ist, den ESP32-CAM in den Programmiermodus zu versetzen (Schalter umlegen), dann die RST-Taste drücken und loslassen, und danach die Upload-Taste in der Arduino IDE drücken. So müssen Sie das Timing der Verbindungsanzeige nicht abpassen.

Betriebsmodus

Sobald der Text „Hard resetting via RTS pin…“ im Ausgabefenster erscheint, ist der Upload abgeschlossen. Schalten Sie den Schalter vom Programmier- in den Betriebsmodus und drücken Sie die RST-Taste am ESP32-CAM, um das Programm zu starten.

Sie können denselben Testcode wie oben verwenden oder etwas etwas fortgeschritteneres ausprobieren, wie den folgenden Code.

Testcode für ESP32-CAM mit FTDI-Programmierer

Dies ist im Wesentlichen ein Blink-Programm, bei dem wir die Helligkeit der Blitz-LED langsam über 255 Schritte erhöhen, sie dann für eine Sekunde ausschalten und den Zyklus wiederholen.

int flashPin = 4;

void setup() {
  pinMode(flashPin, OUTPUT);
}

void loop() {
  for (int b = 0; b < 255; b++) {
    analogWrite(flashPin, b);
    delay(1);
  }
  analogWrite(flashPin, 0);
  delay(1000);
}

Da das Programmieren weiterhin umständlich bleibt (auch mit dem FTDI-Programmierer), sollten Sie zuerst die Funktion von SD-Karte und Kamera testen, bevor Sie versuchen, ein komplexeres Programm auszuführen. In den folgenden zwei Abschnitten zeige ich Ihnen, wie das geht.

SD-Karte testen

Laut Datenblatt unterstützt der ESP32-CAM nur 4GB microSD-Karten. Allerdings funktionieren 8GB und 16GB microSD-Karten in der Regel problemlos. Größere Karten müssen mit FAT32 neu formatiert werden. Verwenden Sie die guiformat.exe Software von ridgecrop, um größere SD-Karten mit FAT32 zu formatieren.

Das folgende Testprogramm erstellt eine Testdatei, schreibt etwas Text hinein und liest den Text wieder aus. Wenn das funktioniert, funktioniert Ihre SD-Karte.

#include "SD_MMC.h"
#include "FS.h"
#include "LittleFS.h"

int flashPin = 4;

void setup() {
  Serial.begin(115200);  
  SD_MMC.begin();
  LittleFS.begin(true);

  File file = LittleFS.open("/test.txt", FILE_WRITE);
  file.print("*** Test successful ***");
  file.close();

  file = LittleFS.open("/test.txt");
  while (file.available()) {
    Serial.write(file.read());
  }
  file.close();

  pinMode(flashPin, OUTPUT);
  analogWrite(flashPin, 0);
}

void loop() {
}

Hier eine detailliertere Erklärung des Codes.

Bibliotheken und Initialisierung

Wir beginnen mit dem Einbinden der notwendigen Bibliotheken für SD-Karten- und Dateisystemoperationen: SD_MMC.h, FS.h und LittleFS.h.

#include "SD_MMC.h"
#include "FS.h"
#include "LittleFS.h"

Wir definieren auch eine Variable flashPin, die den Pin repräsentiert, der mit der Blitz-LED verbunden ist.

int flashPin = 4;

Setup-Funktion

In der setup() Funktion initialisieren wir die serielle Kommunikation mit einer Baudrate von 115200.

void setup() {
  Serial.begin(115200);

Dann initialisieren wir die SD-Karte und das LittleFS-Dateisystem. Der Aufruf von LittleFS.begin mit true stellt sicher, dass das Dateisystem für LittleFS erstellt wird. Normalerweise muss man das nur einmal machen, aber es schadet nicht, die Funktion jedes Mal so aufzurufen.

  SD_MMC.begin();
  LittleFS.begin(true);

Als nächstes erstellen wir eine Datei namens test.txt im Schreibmodus, schreiben eine Testnachricht hinein und schließen die Datei.

  File file = LittleFS.open("/test.txt", FILE_WRITE);
  file.print("*** Test successful ***");
  file.close();

Wir öffnen die Datei erneut im Lesemodus, lesen ihren Inhalt Zeichen für Zeichen und geben ihn im seriellen Monitor aus.

  file = LittleFS.open("/test.txt");
  while (file.available()) {
    Serial.write(file.read());
  }
  file.close();

Schließlich setzen wir den flashPin als Ausgangspin und schalten die Blitz-LED aus, indem wir ihren PWM-Wert auf 0 setzen. Ich mache das, da das Schreiben auf die SD-Karte automatisch die Blitz-LED einschaltet, was störend ist. Der Testcode funktioniert auch ohne diese zwei Zeilen, aber ich mochte das Blitzen nicht jedes Mal beim Test.

  pinMode(flashPin, OUTPUT);
  analogWrite(flashPin, 0);

Loop-Funktion

Die loop() Funktion bleibt leer, da alles in der Setup-Funktion passiert. Um das Programm erneut auszuführen, müssen Sie den ESP32-CAM zurücksetzen.

void loop() {
}

Ausgabe im seriellen Monitor

Wenn alles korrekt funktioniert, sollten Sie im seriellen Monitor folgende Zeilen sehen. Beachten Sie die letzte Zeile mit „*** Test erfolgreich ***“, die beweist, dass wir auf die SD-Karte schreiben und von ihr lesen konnten.

Weitere Tests

Alternativ können Sie auch den komplexeren Test aus der ESP32-Bibliothek ausführen. Er hat zusätzliche Debug-Ausgaben, die nützlich sein können. Siehe Sketch SDMMC_Test.ino. Derselbe Code ist über die Sketch-Beispiele verfügbar: File -> Examples -> Examples for AI-Thinker ESP32-CAM -> SDMMC -> SDMMC_Test.

Kamera testen

Nach der SD-Karte wollen wir die Funktion der Kamera testen. Der untenstehende Code ist eine vereinfachte Version komplexerer Programme. Jedes Mal, wenn der ESP32-CAM startet (Reset-Taste gedrückt wird), macht er ein Bild und speichert es auf der SD-Karte.

Dieser Code ist spezifisch für das AI-Thinker Modell, funktioniert aber auch bei den meisten anderen ESP32-basierten Kameraboards gut, sofern sie PSRAM haben (siehe model definitions). Sie müssen nur die pin definitions entsprechend Ihrem Modell anpassen.

#include "esp_camera.h"
#include "soc/rtc_cntl_reg.h"
#include "SD_MMC.h"
#include "EEPROM.h"

// CAMERA_MODEL_AI_THINKER
#define PWDN_GPIO_NUM 32
#define RESET_GPIO_NUM -1
#define XCLK_GPIO_NUM 0
#define SIOD_GPIO_NUM 26
#define SIOC_GPIO_NUM 27
#define Y9_GPIO_NUM 35
#define Y8_GPIO_NUM 34
#define Y7_GPIO_NUM 39
#define Y6_GPIO_NUM 36
#define Y5_GPIO_NUM 21
#define Y4_GPIO_NUM 19
#define Y3_GPIO_NUM 18
#define Y2_GPIO_NUM 5
#define VSYNC_GPIO_NUM 25
#define HREF_GPIO_NUM 23
#define PCLK_GPIO_NUM 22

void configCamera() {
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;
  config.frame_size = FRAMESIZE_UXGA;
  config.jpeg_quality = 10;
  config.fb_count = 2;
  esp_err_t err = esp_camera_init(&config);

  sensor_t* s = esp_camera_sensor_get();
  s->set_brightness(s, 0);
  s->set_contrast(s, 0);
  s->set_saturation(s, 0);
  s->set_special_effect(s, 0);
  s->set_whitebal(s, 1);
  s->set_awb_gain(s, 1);
  s->set_wb_mode(s, 0);
  s->set_exposure_ctrl(s, 1);
  s->set_aec2(s, 0);
  s->set_ae_level(s, 0);
  s->set_aec_value(s, 300);
  s->set_gain_ctrl(s, 1);
  s->set_agc_gain(s, 0);
  s->set_gainceiling(s, (gainceiling_t)0);
  s->set_bpc(s, 0);
  s->set_wpc(s, 1);
  s->set_raw_gma(s, 1);
  s->set_lenc(s, 1);
  s->set_hmirror(s, 0);
  s->set_vflip(s, 0);
  s->set_dcw(s, 1);
  s->set_colorbar(s, 0);
}

unsigned int incCounter() {
  unsigned int cnt = 0;
  int adr = 0;
  EEPROM.get(adr, cnt);
  EEPROM.put(adr, cnt + 1);
  EEPROM.commit();
  return cnt;
}

void skipPictures(int n) {
  for(int i=0; i<n; i++) {
    camera_fb_t* fb = esp_camera_fb_get();
    esp_camera_fb_return(fb);
  }
}

void takePicture() {
  camera_fb_t* fb = esp_camera_fb_get();
  unsigned int cnt = incCounter();
  String path = "/pic" + String(cnt) + ".jpg";
  Serial.println(path);
  File file = SD_MMC.open(path.c_str(), FILE_WRITE);
  file.write(fb->buf, fb->len);
  file.close();
  esp_camera_fb_return(fb);
}

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
  Serial.begin(115200);
  SD_MMC.begin();
  EEPROM.begin(16);
  configCamera();
  skipPictures(n);
  takePicture();
  esp_deep_sleep_start();
}

void loop() {
}

Dieser Code ist ein guter Ausgangspunkt für fortgeschrittene Anwendungsfälle. Zum Beispiel, wenn Sie ein Bild machen wollen, wenn ein Bewegungs- oder Lichtsensor ausgelöst wird. Oder wenn Sie Bilder in bestimmten Zeitintervallen aufnehmen wollen. Im Folgenden etwas mehr Details, wie dieser Code funktioniert.

Konstanten und Bibliotheken

Zuerst binden wir notwendige Bibliotheken wie esp_camera.h, soc/rtc_cntl_reg.h, SD_MMC.h und EEPROM.h ein. Diese Bibliotheken bieten Funktionen für Kamerakonfiguration, SD-Kartenoperationen und EEPROM-Nutzung.

#include "esp_camera.h"
#include "soc/rtc_cntl_reg.h"
#include "SD_MMC.h"
#include "EEPROM.h"

Kamerakonfiguration

Die configCamera() Funktion setzt die Kamerakonfigurationsparameter wie LEDC-Kanal, Pins für Datenleitungen (D0-D7), XCLK, PCLK, VSYNC, HREF, SCCB SDA, SCCB SCL, PWDN, RESET und verschiedene Kameraeinstellungen wie Pixelformat, Bildgröße, JPEG-Qualität usw.

void configCamera() {
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  ...

  sensor_t* s = esp_camera_sensor_get();
  s->set_brightness(s, 0);
  s->set_contrast(s, 0);
  s->set_saturation(s, 0);
  ...
}

Wie erwähnt, können sich die Pin-Definitionen je nach Kameratyp ändern. Wenn Sie mit der Bildqualität nicht zufrieden sind, gibt es viele Parameter, mit denen Sie experimentieren können.

Zähler-Inkrement-Funktion

Die incCounter() Funktion liest und erhöht einen Zählerwert, der im EEPROM gespeichert ist. Sie liest den aktuellen Wert, erhöht ihn, schreibt ihn zurück ins EEPROM und gibt den vorherigen Wert zurück.

unsigned int incCounter() {
  unsigned int cnt = 0;
  int adr = 0;
  EEPROM.get(adr, cnt);
  EEPROM.put(adr, cnt + 1);
  EEPROM.commit();
  return cnt;
}

Das stellt sicher, dass wir einen laufenden Zähler für die aufgenommenen Bilder haben, auch wenn der ESP32-CAM zurückgesetzt wird. Dieser Zähler wird auch verwendet, um eindeutige Dateinamen für die Bilddateien auf der SD-Karte zu erzeugen.

Wenn Sie den Zähler zurücksetzen wollen, können Sie den folgenden Code hochladen und ausführen:

#include "EEPROM.h"
  
void setup() {
  EEPROM.begin(512);
  unsigned int cnt = 0;
  int adr = 0;
  EEPROM.put(adr, cnt);
  EEPROM.commit();
}

void loop() {
}

Bilder überspringen

Die SkipPictures(n) Funktion nimmt n Bilder auf und verwirft sie. Der Grund dafür ist folgender: Die Kamera hat mehrere automatische Funktionen integriert, z.B. automatische Weißabgleich und andere, die einige Zeit und mehrere Bilder benötigen, um sich an die Umgebung anzupassen. Nach einem Neustart aus dem Deep-Sleep müssen wir der Kamera daher etwas Zeit geben, sich einzustellen.

void skipPictures(int n) {
  for(int i=0; i<n; i++) {
    camera_fb_t* fb = esp_camera_fb_get();
    esp_camera_fb_return(fb);
  }
}

Wenn Sie das erste Bild nach einem Neustart aufnehmen, wird es von schlechter Qualität sein. Typischerweise mit starkem Blaustich oder zu dunkel oder zu hell. Nach dem Überspringen der ersten Bilder erhalten Sie meist (aber nicht immer) Bilder guter Qualität.

Sie könnten auch versuchen, den automatischen Weißabgleich und andere automatische Funktionen in den Kameraeinstellungen zu deaktivieren, aber dann benötigen Sie eine recht stabile Umgebung, um die anderen Einstellungen zu optimieren. Andernfalls wird es schwierig, gute Bilder zu erhalten.

Bildaufnahme und Speicherung

Die takePicture() Funktion nimmt ein Bild mit der Kamera auf und speichert es auf der SD-Karte. Sie holt einen Kameraframe-Puffer, erhöht den Zähler, erstellt einen eindeutigen Dateipfad für das Bild, schreibt die Bilddaten in die Datei und gibt den Frame-Puffer frei.

void takePicture() {
  camera_fb_t* fb = esp_camera_fb_get();
  unsigned int cnt = incCounter();
  String path = "/pic" + String(cnt) + ".jpg";
  Serial.println(path);
  File file = SD_MMC.open(path.c_str(), FILE_WRITE);
  file.write(fb->buf, fb->len);
  file.close();
  esp_camera_fb_return(fb);
}

Beachten Sie, dass wir den oben genannten Zähler verwenden, um Dateipfadnamen zu erzeugen. Wenn Ihnen die Dateinamen nicht gefallen, ist dies der Ort, an dem Sie sie ändern können.

Setup-Funktion

In der setup() Funktion deaktivieren wir zuerst den Brownout-Detektor. Der ESP32-CAM neigt dazu, Brownout-Fehler zu melden, wenn die Stromversorgung beim Start zu wenig Strom liefert. Der Aufruf von WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0) vermeidet dieses Problem.

Dann initialisieren wir die serielle Kommunikation, starten die SD-Karte, beginnen mit EEPROM, konfigurieren die Kamera, nehmen ein Bild auf und versetzen das Board in den Deep-Sleep-Modus. Das bedeutet, dass jedes Mal, wenn der ESP32-CAM startet oder zurückgesetzt wird, ein neues Bild aufgenommen und auf der SD-Karte gespeichert wird.

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
  Serial.begin(115200);
  SD_MMC.begin();
  EEPROM.begin(512);
  configCamera();
  takePicture();
  esp_deep_sleep_start();
}

Loop-Funktion

Die loop() Funktion ist leer. Alles passiert während der Setup-Funktion und es wird nur ein Bild aufgenommen, danach geht das Board in den Deep-Sleep und wartet auf einen Neustart.

Camera Web Server Beispiel

Wenn Sie einen Test mit den WiFi-Fähigkeiten des ESP32 machen wollen, ist das CameraWebServer Beispiel gut geeignet. Sie finden es unter File -> Examples -> ESP32 -> Camera -> CameraWebServer.

Sie müssen den Code in CameraWebServer.ino leicht anpassen. Zuerst müssen Sie das Kameramodell definieren, das Sie verwenden. Stellen Sie sicher, dass nur das Modell definiert ist, das Sie haben!

// ===================
// Select camera model
// ===================
//#define CAMERA_MODEL_WROVER_KIT // Has PSRAM
//#define CAMERA_MODEL_ESP_EYE // Has PSRAM
...
//#define CAMERA_MODEL_M5STACK_UNITCAM // No PSRAM
#define CAMERA_MODEL_AI_THINKER // Has PSRAM
//#define CAMERA_MODEL_TTGO_T_JOURNAL // No PSRAM
//#define CAMERA_MODEL_XIAO_ESP32S3 // Has PSRAM

Als nächstes müssen Sie die WiFi-Zugangsdaten Ihres Heimnetzwerks eingeben:

// ===========================
// Enter your WiFi credentials
// ===========================
const char* ssid = "**********";
const char* password = "**********";

Nach dem Hochladen des Codes und dem Zurücksetzen des ESP32-CAM sollten Sie folgenden Text im seriellen Monitor sehen:

Beachten Sie die letzte Zeile, die Ihnen die URL (IP-Adresse) angibt, unter der der Webserver läuft. Kopieren Sie diese URL in die Adresszeile Ihres Browsers, und Sie sollten die folgende Webseite sehen, die Kamerabilder vom ESP32-CAM an Ihren Webbrowser streamt.

Und das war’s! Das sollte Ihnen genug Informationen und Beispiele geben, um mit dem ESP32-CAM Modul zu starten.

Wenn Sie einen einfacheren Beispielcode zum Videostreaming suchen, schauen Sie sich das Stream Video with ESP32-CAM Tutorial an. Und für eine bewegungsaktivierte Kamera sehen Sie das Motion Activated ESP32-CAM Tutorial.

Zusammenfassung

Das ESP32-CAM Modul ist ein schönes und leistungsfähiges Board, sobald es läuft. Das Hochladen von Code auf das Modul ist jedoch umständlich. Ich musste oft mehrere Versuche starten und das USB-Kabel abziehen, um es zum Laufen zu bringen. Die zuverlässigste Methode war folgende:

1. USB-Kabel abziehen
2. Board in den Programmiermodus versetzen
3. USB-Kabel anschließen
4. Upload in der Arduino IDE starten

Das funktionierte immer und erforderte nicht, während des Uploads die RST-Taste zu drücken. Um den ESP32-CAM dann auszuführen, musste ich nur den Programmiermodus deaktivieren und resetten. Das USB-Kabel musste dafür nicht abgezogen werden. Nur zum Hochladen eines neuen Programms musste ich das Board abziehen und die Schritte erneut durchführen.

Ein weiterer Trick, den ich fand, war, die SD-Karte zu entfernen, wenn das Board sich weigerte, in den Programmiermodus zu gehen. Das trat häufig auf, wenn der zuvor geflashte Code die SD-Karte nutzte.

Wenn Sie Schwierigkeiten mit Ihrem ESP32-CAM Board haben, finden Sie unten einige Links mit zusätzlichen Informationen und eine Liste häufig gestellter Fragen mit Antworten.

Schließlich, wenn Sie ein Board suchen, das kein separates Programmier-Shield oder einen FTDI-Programmierer zum Flashen benötigt, schauen Sie sich das ESP32-WROVER CAM an, das auch mehr freie GPIOs hat, aber auch größer ist. Wenn Sie ein sehr kleines Board und ein Mikrofon brauchen, empfehle ich das XIAO-ESP32-S3-Sense.

Viel Spaß beim Basteln!

Links

Hier einige Links, die ich nützlich fand, um mit dem ESP32-CAM zu starten:

• Getting Started With ESP32-CAM
• How to Program / Upload Code to ESP32-CAM AI-Thinker (Arduino IDE)
• ESP32-CAM Troubleshooting Guide: Most Common Problems Fixed
• ESP32-CAM AI-Thinker Pinout Guide: GPIOs Usage Explained
• ESP32-CAM Take Photo and Save to MicroSD Card
• Camera Pin Definitions
• Supported Camera Models

Häufig gestellte Fragen

Und hier sind einige häufige Fragen und Lösungen, die Ihnen bei der Fehlersuche helfen können:

F: Warum verbindet sich mein ESP32-CAM nicht mit dem Wi-Fi?

A: Überprüfen Sie, ob Sie die korrekte SSID und das Passwort im Code eingegeben haben. Stellen Sie sicher, dass das Wi-Fi Netzwerk in Reichweite ist und ordnungsgemäß funktioniert.

F: Wie kann ich die Bildqualität der Kamera verbessern?

A: Passen Sie die Kameraeinstellungen im Code an, um die Bildqualität zu optimieren. Experimentieren Sie mit verschiedenen Auflösungen und Bildraten, um die beste Konfiguration für Ihr Projekt zu finden.

F: Wie kann ich mehr GPIOs hinzufügen?

A: Sie können die SD-Karten-Schnittstelle im 1-Bit-Modus initialisieren, was zwei weitere GPIO-Pins freigibt. Für mehr Details siehe das More GPIO pins for ESP32-CAM Tutorial.

F: Warum nimmt mein ESP32-CAM keine klaren Bilder auf?

A: Schlechte Lichtverhältnisse können die Bildqualität beeinträchtigen. Sorgen Sie für ausreichende Beleuchtung, damit die Kamera klare Bilder aufnehmen kann. Passen Sie die Kameraeinstellungen im Code für optimale Bildqualität an. Stellen Sie auch sicher, dass Sie die kleine Schutzfolie auf der Linse entfernt haben.

F: Was soll ich tun, wenn mein ESP32-CAM nicht auf Befehle vom seriellen Monitor reagiert?

A: Überprüfen Sie die serielle Kommunikationseinstellungen im Code und stellen Sie sicher, dass die korrekte Baudrate (115200) sowohl im Code als auch im seriellen Monitor eingestellt ist. Prüfen Sie die Verbindungen zwischen ESP32-CAM Board und Computer.

F: Warum wird meine SD-Karte nicht erkannt?

A: Stellen Sie sicher, dass die SD-Karte richtig im Slot sitzt und korrekt formatiert ist (FAT32). Prüfen Sie Ihren Code, ob die Initialisierung der SD-Karte korrekt erfolgt. 4-16GB Karten sollten problemlos funktionieren. Karten mit höherer Kapazität können Probleme verursachen.

F: Mein ESP32-CAM wird heiß, ist das normal?

A: Es ist normal, dass der ESP32-CAM während des Betriebs warm wird, aber wenn er übermäßig heiß wird, prüfen Sie auf Kurzschlüsse oder Probleme mit der Stromversorgung.

F: Wie kann ich den Stromverbrauch des ESP32-CAM reduzieren?

A: Deaktivieren Sie unnötige Peripheriegeräte und optimieren Sie Ihren Code, um den Stromverbrauch zu minimieren. Erwägen Sie die Nutzung von Schlafmodi, um Energie zu sparen, wenn das Board nicht verwendet wird.

F: Warum haben die vom ESP32-CAM aufgenommenen Bilder nach einem Neustart einen Blaustich?

A: Die Kamera hat automatische Funktionen, z.B. automatischen Weißabgleich, die einige Zeit benötigen, um sich an die Umgebung anzupassen. Ohne diese Anpassung erhalten Sie blaustichige oder sehr dunkle oder helle Bilder. Eine einfache Methode, dies zu vermeiden, ist, nach einem Neustart mehrere Bilder aufzunehmen und diese zu ignorieren. Siehe die skipPictures() Funktion im Tutorial, die genau das macht.

F: Warum nimmt mein ESP32-CAM keine Bilder auf?

A: Überprüfen Sie, ob das Kameramodul richtig mit dem ESP32-CAM Board verbunden ist. Stellen Sie sicher, dass die Kamerapins korrekt verdrahtet sind und dass das Kameramodul von Ihrem Code unterstützt wird.

F: Wie kann ich Video vom ESP32-CAM streamen?

A: Implementieren Sie einen Streaming-Server auf dem ESP32-CAM mit Bibliotheken wie ESP32-CAM-Webserver, um Video über Wi-Fi zu streamen. Stellen Sie sicher, dass Ihr Netzwerk die Bandbreite für das Videostreaming bewältigen kann.

F: Warum wird mein ESP32-CAM von der Arduino IDE nicht erkannt?

A: Stellen Sie sicher, dass Sie das notwendige ESP32 Board Support Paket in der Arduino IDE installiert haben. Prüfen Sie Ihr USB-Kabel und die Portverbindungen, um eine ordnungsgemäße Kommunikation mit dem ESP32-CAM Board sicherzustellen.

F: Warum zeigt mein ESP32-CAM während des Code-Uploads ständig „Timed out waiting for packet header“?

A: Dieser Fehler kann durch eine langsame oder instabile USB-Verbindung verursacht werden. Versuchen Sie ein anderes USB-Kabel oder einen anderen Port und stellen Sie sicher, dass das ESP32-CAM Board eingeschaltet und im Bootloader-Modus ist, bevor Sie den Code hochladen.

F: Was soll ich tun, wenn mein ESP32-CAM während des Code-Uploads einfriert?

A: Trennen Sie das USB-Kabel, setzen Sie das ESP32-CAM Board zurück und versuchen Sie den Upload erneut. Stellen Sie sicher, dass Ihr Code das Board nicht zum Hängen oder Absturz während des Uploads bringt.

F: Kann ich Code drahtlos auf den ESP32-CAM hochladen?

A: Ja, Sie können Code drahtlos auf den ESP32-CAM per OTA (Over-The-Air) Programmierung hochladen. Implementieren Sie die OTA-Funktionalität in Ihrem Code und folgen Sie den notwendigen Schritten, um Code ohne USB-Verbindung hochzuladen.

F: Warum gelangt mein ESP32-CAM nicht in den Bootloader-Modus zum Code-Upload?

A: Überprüfen Sie die Verbindung des GPIO0 Pins mit GND auf dem ESP32-CAM Board. Stellen Sie sicher, dass Sie die Reset-Taste zum richtigen Zeitpunkt drücken, um in den Bootloader-Modus für den Code-Upload zu gelangen.

F: Wie kann ich den Fehler „A fatal error occurred: Failed to connect to ESP32: Timed out waiting for packet header“ beim Hochladen von Code beheben?

A: Dieser Fehler kann durch falsche Baudrateinstellungen oder ein defektes USB-Kabel verursacht werden. Versuchen Sie, die Baudrate in den Arduino IDE Einstellungen zu ändern oder ein anderes USB-Kabel zu verwenden, um eine stabile Verbindung mit dem ESP32-CAM Board herzustellen.

F: Welche Schritte soll ich unternehmen, wenn ich den Fehler „esptool.FatalError: Timed out waiting for packet header“ beim Hochladen von Code auf den ESP32-CAM sehe?

A: Dieser Fehler weist auf ein Kommunikations-Timeout zwischen Computer und ESP32-CAM Board hin. Überprüfen Sie USB-Kabel, Port und Board-Verbindungen auf Probleme. Starten Sie die IDE neu, setzen Sie das Board zurück und versuchen Sie den Upload erneut.

F: Was soll ich tun, wenn ich die Fehlermeldung „Brownout detector was triggered“ sehe?

A: Dieser Fehler tritt meist auf, wenn die Stromversorgung des ESP32-CAM unzureichend ist und die Versorgungsspannung absinkt. Eine interne Schaltung des ESP32 erkennt dieses Problem, sendet die Fehlermeldung an den seriellen Monitor und setzt das Board zurück. Sie sollten sicherstellen, dass der ESP32-CAM über den 5V-Pin mit einem Netzteil versorgt wird, das 1A Strom liefern kann. Weitere Informationen finden Sie in unserem Fix brownout of ESP32-CAM Tutorial.