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

Die Platine ESP32-CAM mit der 5-MP-Kamera OV5640 ist ein ESP32-Modul mit eingebauter Kamera, das Bilder aufnimmt und über WLAN überträgt, ohne weitere Bauteile zu benötigen. Es wird in Projekten zur Überwachung, Fernüberwachung, automatischen Fotografie und Bilderkennung eingesetzt.

Das Tutorial verwendet die Platine ESP32-CAM AI-Thinker als Plattform, programmiert über die Arduino IDE. Die Platine hat keinen USB-Anschluss, daher erfolgt das Hochladen des Programms über einen USB-Seriell-Adapter FT232RL. Die Stromversorgung erfolgt separat über eine Quelle 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. Die Übertragung wird durch die Signale XCLK (Takt für den Sensor), PCLK (Pixeltakt), VSYNC (Bildbeginn) und HREF (gültige Zeile) synchronisiert. 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 benutzt 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. Mit 2 Byte pro Pixel (Format RGB565) hätte ein Bild etwas über 10 MB (10 077 696 Byte), also mehr als die 4 MB PSRAM der Platine. Als JPEG belegt ein Bild wesentlich weniger Platz 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 lag der Durchschnitt bei Qualität 12 bei 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 bleibt daher für Einzelfotos reserviert, und für den Videostream werden SVGA oder HD gewählt. Die Bibliothek esp32-camera bietet als maximale Auflösung QSXGA mit 2560 x 1920 Pixel, etwas unter den 2592 x 1944 Pixeln des Sensors.

Anschluss:

Die Platine wird über eine separate Quelle mit 5 VDC und mindestens 2 A am Pin 5V versorgt. Speisen Sie sie nicht über den USB-Seriell-Adapter, denn dieser liefert nicht den Spitzenstrom, den die Kamera OV5640 zusammen mit dem WLAN benötigt, und der 3,3-V-Ausgang des Adapters ist für diese Platine nicht geeignet. Der Pin VCC des Adapters FT232RL bleibt unverbunden, und der Jumper des Adapters wird auf 3.3 V gesetzt, damit die Signale TXD und RXD den Logikpegel von 3.3 V der GPIOs des ESP32 haben. Die seriellen Leitungen werden gekreuzt: 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 an den FT232-Programmierer.

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 Seriellen 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, dass die LED bei maximaler Helligkeit den Verbrauch um etwa 130 mA erhöht. In unseren Tests hat die Platine mit der Kamera OV5640 bei 5 V etwa 340 - 360 mA verbraucht, mit aktiver Kamera und ausgeschalteter LED.

Platine und Bibliotheken:

Gehen Sie in der Arduino IDE zu Datei - Voreinstellungen und tragen Sie im Feld Zusätzliche Boardverwalter-URLs die Adresse https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json ein. Öffnen Sie danach Werkzeuge - Board - Boardverwalter, suchen Sie nach esp32 und installieren Sie das Paket esp32 by Espressif Systems in einer aktuellen Version (2.0.x oder neuer).

Nach der Installation wählen Sie die Platine AI Thinker ESP32-CAM unter Werkzeuge - Board - esp32. Die folgenden Abbildungen zeigen die Konfigurationsschritte in der Arduino IDE.

Es muss keine Bibliothek über den Bibliotheksverwalter installiert werden, da esp_camera.h und WiFi.h im Paket esp32 by Espressif Systems enthalten sind.

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 über Port 80 verbunden ist. Ersetzen Sie vor dem Hochladen Name und 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 Netzwerkdaten. 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, dieselben wie in der Tabelle der Beschreibung. FLASH_LED_GPIO_NUM ist GPIO4, und das Serverobjekt lauscht auf Port 80.

Die Funktion startCamera() füllt die Struktur camera_config_t mit den Pins der Kamera, 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. Gibt psramFound() true zurück, 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 einzigen Puffer im internen Speicher gewählt. Nach esp_camera_init() liest die Funktion den Sensor mit esp_camera_sensor_get(), gibt die PID-Kennung aus, die beim OV5640 0x5640 ist, und warnt, wenn der angeschlossene Sensor ein anderer ist.

Die Funktion skipRequest() liest und ignoriert den HTTP-Header der Anfrage des Browsers bis zur ersten Leerzeile. Die Funktion streamTo() sendet den Header multipart/x-mixed-replace und wiederholt dann in einer Schleife: Sie holt ein Bild mit esp_camera_fb_get(), sendet das Trennzeichen, 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 sich der Client trennt.

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

Ergebnis:

Öffnen Sie den Seriellen Monitor mit 115200 Baud. Nach dem Start muss die Bestätigung der Kamerainitialisierung mit 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 übliche Ursache ist der falsche Startmodus. Prüfen Sie, ob IO0 mit GND verbunden ist, drücken Sie RESET vor dem Hochladen und kontrollieren Sie, ob TXD an U0R und RXD an U0T angeschlossen ist und nicht direkt.

Nach dem Hochladen passiert nichts, und im Seriellen Monitor erscheint eine Meldung, dass auf das Hochladen des Programms gewartet wird. Die Brücke zwischen IO0 und GND ist noch gesetzt. Entfernen Sie sie und drücken Sie RESET.

Die Platine startet sich ständig neu, oder es erscheint die Meldung Brownout detector was triggered. Die Stromversorgung ist unzureichend, meist weil die Platine über USB oder mit einer schwachen Quelle versorgt wird. Verwenden Sie eine stabile Quelle mit 5 VDC und mindestens 2 A sowie 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 Position ein und schließen Sie die Klappe.

Das Bild hat nach einer gewissen 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 stockt oder hat nur wenige Bilder pro Sekunde. Das WLAN-Signal ist schwach oder die Auflösung ist zu hoch. Rücken 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 1.5-V-Regler versorgt, der aus 3.3 V gespeist wird. Die Spannungsdifferenz wird direkt im Sensor in Wärme umgewandelt, und ab etwa 50 Grad C können Rauschen und ein violetter Farbstich im Bild auftreten.

Ohne Hardwareänderungen verwenden Sie einen Kühlkörper auf der Kamera, im Streaming Auflösungen von höchstens SVGA oder HD und setzen 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 von etwa 338 mA auf 163 mA, wenn der Sensor im Standby war. 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 reduzieren, indem sie den 1.2-V-Regler neben dem Kameraanschluss durch einen 1.5-V-Regler ersetzen (zum Beispiel XC6206P152MR oder ME6206A15XG) und per Software den internen Regler des Sensors abschalten. Dies geschieht über Bit 3 des Registers 0x3031 (Wert 0x08), direkt 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 Kern des Sensors würde dann unter der minimalen Spannung arbeiten, mit dem Risiko beschädigter Bilder und Abstürze. Eine modifizierte Platine ist nicht mehr für die Kamera OV2640 geeignet und muss entsprechend gekennzeichnet werden.

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