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

Das ESP32-CAM-Board mit der OV5640-Kamera (5 MP) ist ein ESP32-Entwicklungsmodul mit integrierter Kamera. Es nimmt Bilder auf und überträgt sie per WLAN, ganz ohne weitere Komponenten. Dieses Tutorial verwendet das ESP32-CAM-Board von AI-Thinker als Plattform und die Arduino IDE, um ein Programm hochzuladen, das die Kamera startet und über einen internen Webserver einen einfachen Videostream bereitstellt.

Da das Board keinen eigenen USB-Anschluss hat, benötigen Sie zum Hochladen des Programms einen externen USB-Seriell-Adapter vom Typ FT232, der an die seriellen Pins des Boards angeschlossen wird.

Funktionsweise:

Der Sensor OV5640 nimmt das Bild über die 8 parallelen Datenleitungen D0-D7 auf, die durch die Signale XCLK, PCLK, VSYNC und HREF synchronisiert werden. Die Konfiguration des Sensors (Auflösung, Belichtung, Weißabgleich) erfolgt über eine I2C/SCCB-Verbindung auf den Leitungen SIOD und SIOC. Der Sensor komprimiert das Bild im JPEG-Format, bevor der ESP32 es übernimmt. Das verringert die Datenmenge im Vergleich zu einem Rohbild erheblich.

Bei der Auflösung SVGA (800 x 600 Pixel) hat ein JPEG-Frame je nach Szene und der im Code gewählten Qualitätsstufe etwa 20 - 50 KB. Teilt man eine typische lokale WLAN-Bandbreite von einigen hundert KB/s durch diese Framegröße, ergibt sich ein Stream von einigen Bildern pro Sekunde. Das genügt für die Videoüberwachung, liegt aber deutlich unter der maximalen Leistungsfähigkeit des Sensors von 2592 x 1944 Pixeln, die Einzelfotos vorbehalten ist.

Anschluss:

Das Board wird über einen FT232-Adapter programmiert, der an die seriellen Pins des ESP32-CAM angeschlossen wird. Der Spannungs-Jumper des Adapters steht dabei auf 5V. Der Pin IO0 wird nur während des Hochladens des Codes vorübergehend mit GND verbunden.

Board und Bibliotheken:

Gehen Sie in der Arduino IDE zu File - Preferences und tragen Sie im Feld Additional Boards Manager URLs die Adresse https://dl.espressif.com/dl/package_esp32_index.json ein. Öffnen Sie dann Tools - Board - Boards Manager, suchen Sie nach esp32 und installieren Sie das Paket esp32 by Espressif Systems.

Wählen Sie nach der Installation das Board AI Thinker ESP32-CAM unter Tools - Board - ESP32 Arduino aus.

Es ist keine zusätzliche Bibliothek zu installieren, da esp_camera.h und WiFi.h automatisch mit dem Paket esp32 by Espressif Systems mitgeliefert werden.

Der Code:

Der folgende Code initialisiert die Kamera mit der Pinbelegung des AI-Thinker-Boards, verbindet sich mit dem WLAN-Netzwerk und sendet den Videostream an jeden Client, der sich über Port 80 verbindet.

/*
  ESP32-CAM (AI-Thinker) with OV5640 5MP camera - WiFi video stream example
  Board: "AI Thinker ESP32-CAM" (Tools > Board > ESP32 Arduino)
  Board package: esp32 by Espressif Systems, installed from Boards Manager
  Boards Manager URL: https://dl.espressif.com/dl/package_esp32_index.json
  Libraries: esp_camera.h and WiFi.h, both included with the esp32 package, no extra library required
  Upload wiring: FT232 VCC->5V, FT232 GND->GND, FT232 TXD->U0R, FT232 RXD->U0T, IO0 bridged to GND only during upload
*/
#include "esp_camera.h"
#include <WiFi.h>
// ---- Wi-Fi credentials ----
const char* ssid = "YOUR_WIFI_SSID";
const char* 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
WiFiServer server(80);
void startCamera() {
  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;
  if (psramFound()) {
    config.frame_size = FRAMESIZE_SVGA;   // 800x600, good balance for streaming
    config.jpeg_quality = 12;             // lower number = higher quality, bigger file
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_CIF;
    config.jpeg_quality = 15;
    config.fb_count = 1;
  }
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x\n", err);
    return;
  }
  Serial.println("Camera initialized");
}
void sendStreamToClient(WiFiClient &client) {
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: multipart/x-mixed-replace; boundary=frame");
  client.println();
  while (client.connected()) {
    camera_fb_t * fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Frame capture failed");
      break;
    }
    client.println("--frame");
    client.println("Content-Type: image/jpeg");
    client.printf("Content-Length: %u\n\n", fb->len);
    client.write(fb->buf, fb->len);
    client.println();
    esp_camera_fb_return(fb);
    if (!client.connected()) break;
  }
}
void setup() {
  Serial.begin(115200);
  Serial.println();
  startCamera();
  WiFi.begin(ssid, password);
  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.println("Open this address in a browser to view the live stream");
  server.begin();
}
void loop() {
  WiFiClient client = server.available();
  if (client) {
    Serial.println("New client connected");
    sendStreamToClient(client);
    client.stop();
    Serial.println("Client disconnected");
  }
}

Wie der Code funktioniert:

Am Anfang der Datei werden die WLAN-Zugangsdaten (ssid, password) und die Kamera-Pins gemäß dem AI-Thinker-Board definiert (PWDN_GPIO_NUM, XCLK_GPIO_NUM, Y2_GPIO_NUM - Y9_GPIO_NUM, VSYNC_GPIO_NUM, HREF_GPIO_NUM, PCLK_GPIO_NUM, SIOD_GPIO_NUM, SIOC_GPIO_NUM).

Die Funktion startCamera füllt die Struktur camera_config_t mit diesen Pins, wählt die Auflösung FRAMESIZE_SVGA und zwei Frame-Puffer, sofern das Board über PSRAM verfügt, ruft dann esp_camera_init auf und gibt auf Serial aus, ob die Initialisierung erfolgreich war.

Die Funktion sendStreamToClient sendet an den verbundenen Client einen HTTP-Header vom Typ multipart/x-mixed-replace. Solange der Client verbunden bleibt, holt sie dann jeweils einen JPEG-Frame mit esp_camera_fb_get, sendet ihn über die Verbindung und gibt ihn mit esp_camera_fb_return wieder frei.

In der Funktion setup werden die serielle Schnittstelle initialisiert, die Kamera gestartet, auf die Verbindung mit dem WLAN-Netzwerk gewartet und die erhaltene IP-Adresse ausgegeben. Anschließend wird der Server WiFiServer auf Port 80 gestartet. In der Funktion loop wartet das Board auf einen neuen Client und sendet ihm den Videostream über sendStreamToClient.

Ergebnis:

Öffnen Sie den Serial Monitor mit 115200 Baud. Nach der Initialisierung der Kamera und der Verbindung mit dem Netzwerk wird die IP-Adresse des Boards angezeigt. Wenn Sie diese Adresse in einem Browser aufrufen, erscheint der Live-Videostream der Kamera.

Camera initialized
Connecting to WiFi.....
WiFi connected, IP address: 192.168.0.114
Open this address in a browser to view the live stream
New client connected
Client disconnected
New client connected
Client disconnected

Häufige Probleme:

Wenn der Serial Monitor nichts anzeigt, prüfen Sie, ob die gewählte Geschwindigkeit 115200 Baud beträgt und ob Sie die Verbindung zwischen IO0 und GND entfernt haben, bevor Sie nach dem Hochladen RESET drücken.

Wenn beim Start die Fehlermeldung zur Kamera-Initialisierung erscheint (camera init failed), prüfen Sie, ob das Flexband der Kamera fest im FPC-Steckverbinder sitzt und beim Anbringen des Kühlkörpers nicht verschoben wurde.

Wenn sich das Board von selbst zurücksetzt oder im Serial Monitor Brownout-Meldungen erscheinen, ist die Stromversorgung zu schwach. Ersetzen Sie sie durch ein Netzteil mit 5V und mindestens 2A, das direkt an den Pin 5V angeschlossen wird.

Wenn sich das Board nicht mit dem WLAN-Netzwerk verbindet, prüfen Sie, ob Sie Netzwerkname und Passwort korrekt eingegeben haben und ob das WLAN-Signal am Einsatzort des Boards stark genug ist.

Wenn das Bild sehr dunkel oder stark verrauscht ist, sorgen Sie für eine bessere Lichtquelle in der Szene, da die Kamera außer der Blitz-LED keine eigene Beleuchtung hat.

Wenn das Hochladen des Codes mit Meldungen über eine fehlgeschlagene Verbindung zum Board abbricht, stellen Sie die Brücke IO0-GND erneut her und drücken Sie RESET noch einmal genau in dem Moment, in dem die Arduino IDE mit dem Hochladen beginnt.

Einschränkungen und Tipps:

Die Kamera OV5640 erreicht die maximale Auflösung von 5 MP nur bei Einzelfotos. Für kontinuierliches Streaming werden kleinere Auflösungen wie SVGA oder HD empfohlen, um eine vernünftige Anzahl von Bildern pro Sekunde zu halten.

Das Board hat keinen eigenen USB-Anschluss, daher erfordert die Programmierung immer einen externen USB-Seriell-Adapter. Ohne die Variante mit Autofokus arbeitet die Kamera mit festem Fokus.

Der Sensor erwärmt sich im Betrieb deutlich. Deshalb eignet sich das Board nicht für kontinuierliches Videostreaming rund um die Uhr, sondern für Überwachung und zeitweilige Aufnahmen, mit montiertem Kühlkörper und ausreichender Belüftung.

Auf Basis dieses Aufbaus lassen sich Projekte wie WLAN-Überwachungskameras, Überwachungsstationen mit Bildspeicherung auf der microSD-Karte oder einfache Objekterkennungssysteme mit Bildverarbeitung auf einem externen Server umsetzen.