ESP32-CAM-Entwicklungsboard mit CH340G, WLAN, Bluetooth, OV5640 5MP

Die ESP32-CAM-Platine mit der 5-MP-Kamera OV5640 ist ein ESP32-Modul mit eingebauter Kamera. Es nimmt Bilder auf und überträgt sie per WLAN, ohne weitere Bauteile. Einsatzgebiete sind Überwachung, Fernkontrolle, automatische Fotografie und Bilderkennung.

Das Tutorial verwendet die ESP32-CAM-Platine AI-Thinker als Plattform, programmiert über die Arduino IDE. Die Platine hat keinen USB-Anschluss, deshalb erfolgt das Hochladen des Programms über einen USB-Seriell-Adapter FT232RL. Die Stromversorgung erfolgt separat über ein Netzteil mit 5 VDC und mindestens 2 A. Das Programm startet die Kamera und stellt einen Videostream über einen einfachen Webserver bereit.

So funktioniert es:

Der Sensor OV5640 erfasst das Bild und sendet es über 8 parallele Datenleitungen (D0 - D7) an den ESP32. Synchronisiert wird die Übertragung durch die Signale XCLK (Takt für den Sensor), PCLK (Pixeltakt), VSYNC (Bildbeginn) und HREF (gültige Zeile). Die Konfiguration des Sensors, also Auflösung, Belichtung und Weißabgleich, erfolgt über einen I2C- / SCCB-Bus auf den Leitungen SIOD (GPIO26) und SIOC (GPIO27). Der Pin PWDN (GPIO32) kann den Sensor abschalten, wenn er nicht benötigt wird.

Die folgende Rechnung zeigt, warum das Bild direkt im Sensor als JPEG komprimiert wird. Die maximale Auflösung beträgt 2592 x 1944 = 5 038 848 Pixel. Bei 2 Byte pro Pixel (Format RGB565) hätte ein Bild knapp über 10 MB (10 077 696 Byte), also mehr als die 4 MB PSRAM der Platine. Im JPEG-Format benötigt ein Bild deutlich weniger Speicher und passt problemlos in den Speicher.

Bei der Auflösung SVGA (800 x 600 = 480 000 Pixel) hat ein JPEG-Bild je nach Szene und der im Code gewählten Qualität etwa 10 - 40 KB. In unseren Tests betrug der Mittelwert bei Qualität 12 etwa 13 KB pro Bild. Wenn das WLAN in der Praxis 400 KB/s liefert und ein Bild 40 KB groß ist, ergibt sich 400 / 40 = 10 Bilder pro Sekunde. Oberhalb der HD-Auflösung liefert der Sensor bei einem XCLK-Takt von 20 MHz nur 4 - 6 Bilder pro Sekunde. Die maximale Auflösung ist daher für Einzelfotos reserviert, für den Videostream werden SVGA oder HD gewählt. Die Bibliothek esp32-camera bietet als maximale Auflösung QSXGA mit 2560 x 1920 Pixeln, etwas weniger als die 2592 x 1944 Pixel des Sensors.

Anschluss:

Die Platine wird über eine separate Stromquelle mit 5 VDC und mindestens 2 A am Pin 5V versorgt. Versorgen Sie sie nicht über den USB-Seriell-Adapter, denn Adapter und USB-Port liefern nicht den Spitzenstrom, den die Kamera OV5640 zusammen mit dem WLAN benötigt. Außerdem ist der 3,3-V-Ausgang des Adapters für diese Platine nicht geeignet. Der Pin VCC des FT232RL bleibt unverbunden, und der Jumper des Adapters wird auf 3,3 V gesetzt, damit die Signale TXD und RXD den logischen Pegel von 3,3 V der GPIOs des ESP32 haben. Die seriellen Leitungen werden über Kreuz verbunden: TXD des Adapters geht an U0R, RXD des Adapters an U0T. Die Brücke zwischen IO0 und GND wird nur während des Hochladens des Programms gesetzt.

Das folgende Bild zeigt den Anschluss der Platine am FT232-Programmer.

Tasten, Einstellungen und Anzeigen:

Zum Hochladen verbinden Sie IO0 mit GND, drücken RESET und laden das Programm hoch. Die Platine ist im richtigen Modus, wenn die Arduino IDE den Upload ohne Verbindungsfehler startet.

Entfernen Sie nach dem Hochladen die Brücke zwischen IO0 und GND und drücken Sie RESET. Die Platine führt nun das Programm aus, und im Serial Monitor erscheinen die Startmeldungen.

Die weiße LED bleibt im Programm aus. Wenn Sie zusätzliche Beleuchtung wünschen, steuern Sie GPIO4 im Code an. Beachten Sie dabei, dass die LED bei maximaler Helligkeit etwa 130 mA zusätzlich verbraucht. In unseren Tests benötigte die Platine mit der Kamera OV5640 bei 5 V etwa 340 - 360 mA, mit aktiver Kamera und ausgeschalteter LED.

Board und Bibliotheken:

Öffnen Sie in der Arduino IDE File - Preferences und fügen Sie im Feld Additional Boards Manager URLs die Adresse https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json ein. Öffnen Sie danach Tools - Board - Boards Manager, suchen Sie nach esp32 und installieren Sie das Paket esp32 by Espressif Systems in einer aktuellen Version (2.0.x oder neuer).

Wählen Sie nach der Installation die Platine AI Thinker ESP32-CAM unter Tools - Board - esp32 aus. Die folgenden Screenshots zeigen die Konfigurationsschritte in der Arduino IDE.

Im Library Manager muss keine Bibliothek installiert werden, denn esp_camera.h und WiFi.h sind im Paket esp32 by Espressif Systems bereits enthalten.

Der Code:

Das Programm initialisiert die Kamera mit der Pinbelegung der Platine AI-Thinker, verbindet sich mit dem WLAN und sendet den JPEG-Videostream an einen Client, der mit Port 80 verbunden ist. Ersetzen Sie vor dem Hochladen den Namen und das Passwort des Netzwerks.

/*
  ESP32-CAM (AI-Thinker) with OV5640 5MP camera - WiFi MJPEG video stream
  Board selected in Arduino IDE: "AI Thinker ESP32-CAM" (Tools > Board > esp32)
  Board package: esp32 by Espressif Systems (installed from Boards Manager)
  Boards Manager URL (File > Preferences): https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
  Libraries: none to install, esp_camera.h and WiFi.h come with the esp32 package
  Upload wiring: FT232 TXD -> U0R, FT232 RXD -> U0T, FT232 GND -> GND,
                 5V supply (min 2 A) on the 5V pin, IO0 bridged to GND only during upload
*/
#include "esp_camera.h"
#include <WiFi.h>
// ---- Wi-Fi credentials (replace with your own) ----
const char* WIFI_SSID = "YOUR_WIFI_SSID";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";
// ---- AI-Thinker camera pin map ----
#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
// White flash LED on GPIO4 (also SD card DATA1)
#define FLASH_LED_GPIO_NUM 4
WiFiServer server(80);
// Configure and start the camera
bool startCamera() {
  camera_config_t config = {};          // start from a zeroed structure
  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_sccb_sda = SIOD_GPIO_NUM;
  config.pin_sccb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;        // 20 MHz clock for the sensor
  config.pixel_format = PIXFORMAT_JPEG;  // the sensor compresses the image itself
  if (psramFound()) {
    config.frame_size = FRAMESIZE_SVGA;  // 800x600, a good balance for streaming
    config.jpeg_quality = 12;            // lower number = better quality, bigger file
    config.fb_count = 2;                 // two frame buffers for smoother streaming
    config.fb_location = CAMERA_FB_IN_PSRAM;
    config.grab_mode = CAMERA_GRAB_LATEST;  // always send the newest frame
    Serial.println("PSRAM found, using SVGA with 2 frame buffers");
  } else {
    config.frame_size = FRAMESIZE_CIF;
    config.jpeg_quality = 15;
    config.fb_count = 1;
    config.fb_location = CAMERA_FB_IN_DRAM;
    config.grab_mode = CAMERA_GRAB_WHEN_EMPTY;
    Serial.println("No PSRAM, using CIF with 1 frame buffer");
  }
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x\n", err);
    return false;
  }
  // Read the sensor ID to confirm which camera is attached
  sensor_t *s = esp_camera_sensor_get();
  Serial.printf("Camera init OK, sensor PID: 0x%04X\n", s->id.PID);
  if (s->id.PID != OV5640_PID) {
    Serial.println("Warning: the attached sensor is not an OV5640");
  }
  return true;
}
// Read and ignore the HTTP request header sent by the browser
void skipRequest(WiFiClient &client) {
  unsigned long start = millis();
  while (client.connected() && millis() - start < 1000) {
    if (client.available()) {
      String line = client.readStringUntil('\n');
      if (line.length() <= 1) break;  // blank line ends the header
    }
  }
}
// Send frames to the client until it disconnects
void streamTo(WiFiClient &client) {
  client.print("HTTP/1.1 200 OK\r\n");
  client.print("Content-Type: multipart/x-mixed-replace; boundary=frame\r\n\r\n");
  Serial.println("Streaming started");
  uint32_t frames = 0;
  while (client.connected()) {
    camera_fb_t *fb = esp_camera_fb_get();  // get one JPEG frame
    if (!fb) {
      Serial.println("Frame capture failed");
      break;
    }
    size_t len = fb->len;
    client.print("--frame\r\n");
    client.print("Content-Type: image/jpeg\r\n");
    client.printf("Content-Length: %u\r\n\r\n", (unsigned)len);
    size_t sent = client.write(fb->buf, len);
    client.print("\r\n");
    esp_camera_fb_return(fb);               // give the buffer back to the driver
    if (sent != len) break;                 // client is gone
    frames++;
  }
  Serial.printf("Client disconnected after %u frames\n", (unsigned)frames);
}
void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println();
  Serial.println("ESP32-CAM OV5640 stream example");
  // Keep the white flash LED off
  pinMode(FLASH_LED_GPIO_NUM, OUTPUT);
  digitalWrite(FLASH_LED_GPIO_NUM, LOW);
  if (!startCamera()) {
    return;  // stop here if the camera did not start
  }
  // Connect to Wi-Fi
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  WiFi.setSleep(false);  // no Wi-Fi power saving, better for streaming
  Serial.print("Connecting to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("WiFi connected, IP address: ");
  Serial.println(WiFi.localIP());
  Serial.print("Open http://");
  Serial.print(WiFi.localIP());
  Serial.println("/ in a browser to see the stream");
  server.begin();
}
void loop() {
  WiFiClient client = server.available();  // wait for a browser
  if (client) {
    Serial.println("Client connected");
    skipRequest(client);
    streamTo(client);
    client.stop();
  }
}

So funktioniert der Code:

Der erste Teil enthält die Definitionen. Die Konstanten WIFI_SSID und WIFI_PASSWORD speichern die Zugangsdaten des Netzwerks. Die Zeilen mit PWDN_GPIO_NUM, XCLK_GPIO_NUM, SIOD_GPIO_NUM, SIOC_GPIO_NUM, Y2_GPIO_NUM - Y9_GPIO_NUM, VSYNC_GPIO_NUM, HREF_GPIO_NUM und PCLK_GPIO_NUM beschreiben die Pins zwischen dem ESP32 und dem Kameraanschluss, die mit der Tabelle in der Beschreibung übereinstimmen. FLASH_LED_GPIO_NUM ist GPIO4, und das Server-Objekt lauscht auf Port 80.

Die Funktion startCamera() füllt die Struktur camera_config_t mit den Kamerapins, dem XCLK-Takt von 20 MHz und dem Format PIXFORMAT_JPEG. Die Struktur wird leer initialisiert (= {}), damit nicht gesetzte Felder keine zufälligen Werte enthalten. Liefert psramFound() den Wert wahr, wird FRAMESIZE_SVGA mit zwei Bildpuffern im PSRAM (fb_count = 2) und dem Modus CAMERA_GRAB_LATEST gewählt, der immer das neueste Bild sendet. Andernfalls wird FRAMESIZE_CIF mit einem einzelnen Puffer im internen Speicher verwendet. Nach esp_camera_init() liest die Funktion den Sensor mit esp_camera_sensor_get(), gibt die Kennung PID aus, die für den OV5640 0x5640 lautet, und warnt, falls ein anderer Sensor angeschlossen ist.

Die Funktion skipRequest() liest den HTTP-Header der vom Browser gesendeten Anfrage und verwirft ihn bis zur ersten leeren Zeile. Die Funktion streamTo() sendet den Header multipart/x-mixed-replace und wiederholt danach in einer Schleife: Sie holt ein Bild mit esp_camera_fb_get(), sendet die Trennzeichenfolge, den Typ und die Länge, schreibt die JPEG-Daten mit client.write() und gibt den Puffer mit esp_camera_fb_return() frei. Die Schleife endet, wenn der Client die Verbindung trennt.

In setup() wird Serial mit 115200 Baud gestartet, die weiße LED bleibt aus, startCamera() wird aufgerufen, die Platine verbindet sich mit WiFi.begin() mit dem WLAN und die erhaltene IP-Adresse wird angezeigt. In loop() wartet das Programm mit server.available() auf einen Client und liefert bei Verbindung den Stream über streamTo().

Ergebnis:

Öffnen Sie den Serial Monitor mit 115200 Baud. Nach dem Start muss die erfolgreiche Initialisierung der Kamera mit der PID 0x5640 erscheinen, danach die IP-Adresse der Platine. Geben Sie die Adresse im Browser ein, dann erscheint das Bild in Echtzeit.

ESP32-CAM OV5640 stream example
PSRAM found, using SVGA with 2 frame buffers
Camera init OK, sensor PID: 0x5640
Connecting to WiFi......
WiFi connected, IP address: 192.168.1.57
Open http://192.168.1.57/ in a browser to see the stream
Client connected
Streaming started
Client disconnected after 412 frames

Häufige Probleme:

Der Upload bricht mit einem Verbindungsfehler ab. Die häufige Ursache ist der falsche Startmodus. Prüfen Sie, ob IO0 mit GND verbunden ist, drücken Sie RESET vor dem Hochladen und kontrollieren Sie, dass TXD an U0R und RXD an U0T angeschlossen ist und nicht direkt.

Nach dem Hochladen passiert nichts, und im Serial Monitor erscheint eine Meldung über das Warten auf das Hochladen eines Programms. Die Brücke zwischen IO0 und GND ist noch gesetzt. Entfernen Sie sie und drücken Sie RESET.

Die Platine startet ständig neu, oder es erscheint die Meldung Brownout detector was triggered. Die Stromversorgung ist unzureichend, meist weil die Platine über USB oder ein schwaches Netzteil versorgt wird. Verwenden Sie ein stabiles Netzteil mit 5 VDC und mindestens 2 A und kurze Kabel.

Es erscheint die Meldung Camera init failed mit einem Fehlercode. Das Flachbandkabel der Kamera ist nicht vollständig eingesteckt, oder die Klappe des FPC-Steckers ist nicht geschlossen. Trennen Sie die Stromversorgung, stecken Sie das Kabel mit den Kontakten in der richtigen Lage wieder ein und schließen Sie die Klappe.

Das Bild zeigt nach einer Betriebszeit Rauschen oder einen violetten Farbstich. Der Sensor OV5640 hat sich zu stark erwärmt. Montieren Sie einen Kühlkörper auf der Rückseite der Kamera, sorgen Sie für Belüftung und reduzieren Sie die Auflösung auf SVGA oder HD.

Die Platine verbindet sich mit dem WLAN, aber das Bild hängt sich auf oder hat nur wenige Bilder pro Sekunde. Das WLAN-Signal ist schwach, oder die Auflösung ist zu hoch. Stellen Sie die Platine näher an den Router und reduzieren Sie die Auflösung im Code.

Einschränkungen und Tipps:

Das Modul wird für einen dauerhaften Streaming-Betrieb rund um die Uhr nicht empfohlen, da sich die Kamera OV5640 auf dieser Platine stark erwärmt. Der Grund ist, dass die Platine für die Kamera OV2640 entwickelt wurde und den Kameraanschluss mit 3,3 V, 2,8 V und 1,2 V versorgt, während der OV5640 seinen Kern über einen internen Regler mit 1,5 V versorgt, der aus den 3,3 V erzeugt wird. Die Spannungsdifferenz wird direkt im Sensor in Wärme umgewandelt. Oberhalb von etwa 50 °C können Rauschen und ein violetter Farbstich im Bild auftreten.

Ohne Hardwareänderungen verwenden Sie einen Kühlkörper auf der Kamera, beschränken das Streaming auf höchstens SVGA oder HD und schalten den Sensor zwischen den Aufnahmen über das Register 0x3008 in den Standby (Wert 0x42 für Standby und 0x02 für aktiv). In unseren Tests sank der Verbrauch der Platine mit dem Sensor im Standby von etwa 338 mA auf 163 mA. Die maximale Auflösung der Bibliothek, 2560 x 1920 Pixel, eignet sich für Fotos.

Anwender mit Erfahrung im Löten von SMD-Bauteilen können die Erwärmung verringern, indem sie den 1,2-V-Regler neben dem Kameraanschluss durch einen 1,5-V-Regler ersetzen (zum Beispiel XC6206P152MR oder ME6206A15XG) und den internen Regler des Sensors per Software deaktivieren. Dazu wird Bit 3 des Registers 0x3031 (Wert 0x08) gesetzt, unmittelbar nach esp_camera_init(). Nach dieser Änderung blieb der Kühlkörper der Kamera in unseren Tests merklich kühler.

// Only on a board where the DVDD regulator was replaced with a 1.5 V one
sensor_t *s = esp_camera_sensor_get();
if (s->id.PID == OV5640_PID) {
  s->set_reg(s, 0x3031, 0x08, 0x08);  // bypass the internal 1.5 V core regulator
}

Deaktivieren Sie den internen Regler nicht auf einer unveränderten Platine, denn der Sensorkern würde dann unterhalb der minimalen Spannung arbeiten, mit der Gefahr beschädigter Bilder und Abstürze. Eine geänderte Platine eignet sich nicht mehr für die Kamera OV2640 und muss entsprechend gekennzeichnet werden.

Auf der Grundlage dieses Tutorials können Sie eine Überwachungskamera mit Zugriff über den Browser, ein System für periodische Fotos mit Speicherung auf einer microSD-Karte oder ein Projekt zur Objekterkennung bauen. Dabei können Sie die freien GPIOs für Bewegungssensoren oder weitere Module nutzen.