Video mit dem ESP32 Camera Pro Kit streamen

In diesem Tutorial lernst du, wie du Video vom ESP32 Camera Pro Kit über dein lokales Wi-Fi-Netzwerk an deinen Webbrowser streamst. Wir bauen im Grunde eine kabellose Überwachungskamera, die du von deinem Computer aus überwachen kannst.

Benötigte Teile

Für dieses Projekt benötigst du das ESP32 Camera Pro Kit von SunFounder und ein USB-Kabel.

ESP32 Camera Pro Kit

Find at Amazon

Find at SunFounder

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.

SunFounder ESP32 Camera Pro Kit

DasSunFounder ESP32 Camera Pro Kitbietet eine kompakte und funktionsreiche Plattform zur Entwicklung von kabellosen Video-Streaming- und eingebetteten Vision-Anwendungen.

Im Kern befindet sich das ESP32 WROOM-32E Modul, ein Dual-Core-Mikrocontroller mit integrierter Wi-Fi- und Bluetooth-Konnektivität, kombiniert mit einer OV2640-Kamera, die Bilder mit bis zu 1600 × 1200 Pixeln aufnehmen kann.

Die im Kit enthaltene Erweiterungsplatine vereint wichtige Peripheriegeräte wie einen micro-SD-Kartensteckplatz, Batterieladeelektronik, GPIO-Erweiterungsanschlüsse und eine 24-polige Kamera-Schnittstelle und bietet so Flexibilität und Zuverlässigkeit für Prototyping und Einsatz.

Das Kit unterstützt eine einzelne 18650 Lithium-Ionen-Batterie, die einen autarken Betrieb ohne externe Stromversorgung ermöglicht. Die Kombination aus Onboard-Speicher, kabelloser Vernetzung und Kamerafunktion macht es ideal für IoT-Szenarien wie Fernüberwachung, Echtzeit-Streaming und Datenprotokollierung.

ESP32 Camera Pro Kit with Battery and Camera — ESP32 Camera Pro Kit mit Batterie und Kamera

Technische Spezifikation

Komponente / Merkmal	Spezifikation
Mikrocontroller	ESP32 WROOM-32E, Dual-Core Xtensa® 32-Bit LX6 @ bis zu 240 MHz
Drahtlos	Wi-Fi 802.11 b/g/n, Bluetooth 4.2 (BR/EDR + BLE)
Kameramodul	OV2640, 2 MP Sensor, bis zu 1600 × 1200 Auflösung, ca. 68° Sichtfeld
Onboard-Speicher	Micro-SD-Kartensteckplatz (unterstützt bis zu 32 GB, FAT32)
Stromversorgung	3,7 V 18650 Li-Ion Batterie (USB aufladbar, integriertes Lade-Management)
Erweiterungsschnittstellen	Buchsenleisten für GPIO, 14-poliger Schraubklemmenblock (3,5 mm Raster)
Kamera-Schnittstelle	24-poliger FFC/FPC-Anschluss (dediziert für OV2640)
Statusanzeigen	Power (PWR) und Lade- (CHG) Status-LEDs
Programmierschnittstellen	Micro-USB (UART, Stromversorgung, Laden)

Pinbelegung des ESP32 WROOM-32E

Installation des ESP32 Cores

Wenn dies dein erstes Projekt mit einem Board der ESP32-Serie ist, musst du zuerst den ESP32 Core installieren. Falls ESP32 Boards bereits in deiner Arduino IDE installiert sind, kannst du diesen Abschnitt überspringen.

Öffne zunächst den Preferences-Dialog über „Preferences…“ im „File“-Menü. Es öffnet sich der unten gezeigte Preferences-Dialog.

Unter dem Reiter Settings findest du unten im Dialog ein Eingabefeld mit der Bezeichnung „Additional boards manager URLs“:

In dieses Eingabefeld kopiere 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 Boards über den Boards Manager.

Öffne den Boards Manager über „Tools -> Boards -> Board Manager“. Der Boards Manager erscheint in der linken Seitenleiste. Gib oben im Suchfeld „ESP32“ ein, und du solltest zwei Arten von ESP32 Boards sehen: die „Arduino ESP32 Boards“ und die „esp32 von Espressif“ Boards. Wir wollen die esp32 Bibliotheken von Espressif. Klicke auf den INSTALL-Button und warte, bis der Download und die Installation abgeschlossen sind.

Install ESP32 Core libraries — ESP32 Core Bibliotheken installieren

Board auswählen

Zum Schluss müssen wir ein ESP32 Board auswählen. Für das ESP32 Camera Pro Kit wählen wir das generische „AI Thinker ESP32-CAM“. Klicke dazu auf das Dropdown-Menü und dann auf „Select other board and port…“:

Drop-down Menu for Board Selection — Dropdown-Menü zur Board-Auswahl

Es öffnet sich ein Dialog, in dem du „ai“ in die Suchleiste eingibst. Du siehst das Board „AI Thinker ESP32-CAM“ unter Boards. Klicke darauf, wähle den COM-Port aus, um es zu aktivieren, und bestätige mit OK:

Board Selection Dialog "AI Thinker ESP32-CAM" board — Board-Auswahl-Dialog „AI Thinker ESP32-CAM“ Board

Alternativ könntest du auch das neuere „ESP32 Dev Module“ auswählen, musst dann aber im Tools-Menü PSRAM und Huge APP aktivieren.

Beachte, dass du das Board per USB-Kabel mit deinem Computer verbinden musst, bevor du einen COM-Port auswählen kannst.

Video-Streaming

In diesem Projekt implementieren wir einen Video-Streaming-Server, der auf dem ESP32 läuft, dem Mikroprozessor im ESP32 Camera Pro Kit. Die Kamera nimmt Bilder auf, und der ESP32 stellt sie über Wi-Fi bereit. Dein Wi-Fi-Router leitet diese Bilder dann an einen Webbrowser weiter, der sie als Videostream anzeigt. Das folgende Bild zeigt die Einrichtung:

Beachte, dass der Videostream nicht verschlüsselt oder gesichert ist, aber nur unter einer URL innerhalb deines lokalen Wi-Fi-Netzwerks sichtbar ist, z.B. 192.168.2.39/stream. Nur jemand mit Zugang zu deinem Wi-Fi-Netzwerk kann den Videostream sehen.

Code für Video-Server

Der folgende Arduino-Code implementiert den Video-Streaming-Server, der einen kontinuierlichen MJPEG-Stream vom ESP32 Camera Pro Kit an jeden Webbrowser im gleichen Wi-Fi-Netzwerk sendet.

Wir verwenden die esp32cam Bibliothek, die die Handhabung der Kamera vereinfacht. Du kannst sie über den Library Manager in der Arduino IDE installieren. Suche einfach nach „esp32cam“ und klicke auf INSTALL. Das Bild unten zeigt die abgeschlossene Installation:

esp32cam library installed via Library Manager — esp32cam Bibliothek installiert über Library Manager

Unten findest du den kompletten Code für den Video-Streaming-Server. Schau ihn dir kurz an, danach gehen wir auf die Details ein:

#include "WebServer.h"
#include "WiFi.h"
#include "esp32cam.h"

const char* WIFI_SSID = "SSID";
const char* WIFI_PASS = "PASSWORD";
const char* URL = "/stream";
const auto RESOLUTION = esp32cam::Resolution::find(1024, 768);

WebServer server(80);

void handleStream() {
  static char head[128];
  WiFiClient client = server.client();

  server.sendContent("HTTP/1.1 200 OK\r\n"
                     "Content-Type: multipart/x-mixed-replace; "
                     "boundary=frame\r\n\r\n");

  while (client.connected()) {
    auto frame = esp32cam::capture();
    if (frame) {
      sprintf(head,
              "--frame\r\n"
              "Content-Type: image/jpeg\r\n"
              "Content-Length: %ul\r\n\r\n",
              frame->size());
      client.write(head, strlen(head));
      frame->writeTo(client);
      client.write("\r\n");
    }
  }
}

void initCamera() {
  using namespace esp32cam;
  Config cfg;
  cfg.setPins(pins::AiThinker);
  cfg.setResolution(RESOLUTION);
  cfg.setBufferCount(2);
  cfg.setJpeg(80);
  Camera.begin(cfg);
}

void initWifi() {
  WiFi.persistent(false);
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
  }
  Serial.printf("Stream at: http://%s%s\n",
                WiFi.localIP().toString().c_str(), URL);
}

void initServer() {
  server.on(URL, handleStream);
  server.begin();
}

void setup() {
  Serial.begin(115200);
  initWifi();
  initCamera();
  initServer();
}

void loop() {
  server.handleClient();
}

Includes

Der Code beginnt mit dem Einbinden der notwendigen Bibliotheken:

#include "WebServer.h"
#include "WiFi.h"
#include "esp32cam.h"

Diese Bibliotheken ermöglichen HTTP-Server-Funktionalität (WebServer.h), Wi-Fi-Konnektivität (WiFi.h) und Kamerasteuerung (esp32cam.h).

Konstanten

Als Nächstes definieren wir einige Konstanten:

const char* WIFI_SSID = "SSID";
const char* WIFI_PASS = "PASSWORD";
const char* URL = "/stream";
const auto RESOLUTION = esp32cam::Resolution::find(1024, 768);

Die WIFI_SSID und WIFI_PASS Variablen speichern die Zugangsdaten für das Wi-Fi-Netzwerk. Du musst SSID und PASSWORD durch die tatsächlichen Zugangsdaten deines Wi-Fi-Netzwerks ersetzen.

Der URL ist der Pfad, unter dem der Videostream bereitgestellt wird. Du kannst ihn nach Belieben ändern, z.B. in „/video“ oder „/frontdoor“, achte nur darauf, den Schrägstrich (‚/‘) am Anfang beizubehalten.

Die RESOLUTION legt die gewünschte Auflösung der Kamera mit der esp32cam Bibliothek fest.

Hier ist eine Liste möglicher Kameraauflösungen, wobei je nach verwendeter Kamera nicht alle funktionieren müssen:

96×96
160×120
128×128
176×144
240×176
240×240
320×240
320×320
400×296
480×320
640×480
800×600
1024×768
1280×720
1280×1024
1600×1200

Du kannst die Liste der Kameraauflösungen mit der folgenden Funktion ausgeben:

void printResolutions() {
  Serial.println("Camera resolutions:");
  for (auto res : esp32cam::Camera.listResolutions()) {
    Serial.printf("%dx%d\n", res.getWidth(), res.getHeight());
  }
}

Beachte, dass die Auflösung die maximale Bildrate beeinflusst. Bei 1600×1200 Auflösung erhältst du nicht viel mehr als 10 Bilder pro Sekunde.

Objekte

Die folgende Zeile erstellt ein HTTP-Server-Objekt, das auf Port 80 lauscht. Das ist unser Webserver, der den Videostream bereitstellt.

WebServer server(80);

handleStream

Die Funktion handleStream() verarbeitet den Videostream, sobald ein Client den /stream Pfad aufruft:

void handleStream() {
  static char head[128];
  WiFiClient client = server.client();

Diese Zeile holt den aktuell mit dem Server verbundenen Client. Die Antwort wird dann vorbereitet:

server.sendContent("HTTP/1.1 200 OK\r\n"
                   "Content-Type: multipart/x-mixed-replace; "
                   "boundary=frame\r\n\r\n");

Dieser Header teilt dem Browser mit, dass er einen multipart MJPEG-Stream erhält, bei dem jeder Teil durch eine Grenze namens frame getrennt ist.

In einer Schleife nimmt die Funktion einen Frame von der Kamera auf:

  while (client.connected()) {
    auto frame = esp32cam::capture();

Wenn ein Frame erfolgreich aufgenommen wurde, wird ein Header erstellt, der das JPEG-Bild beschreibt, und dann als JPEG an den Client gesendet:

    if (frame) {
      sprintf(head,
              "--frame\r\n"
              "Content-Type: image/jpeg\r\n"
              "Content-Length: %ul\r\n\r\n",
              frame->size());
      client.write(head, strlen(head));
      frame->writeTo(client);
      client.write("\r\n");
    }

initCamera

Die initCamera() Funktion konfiguriert und startet die Kamerahardware:

void initCamera() {
  using namespace esp32cam;
  Config cfg;
  cfg.setPins(pins::AiThinker);
  cfg.setResolution(RESOLUTION);
  cfg.setBufferCount(2);
  cfg.setJpeg(80);
  Camera.begin(cfg);
}

Hier wird ein Config Objekt erstellt. Die setPins Funktion konfiguriert die Kamerapins basierend auf dem AiThinker Board-Layout, das auch für das ESP32 Camera Pro Kit funktioniert.setResolution legt die zu verwendende Auflösung fest, während setBufferCount bestimmt, wie viele Bildpuffer intern verwendet werden.

Die setJpeg Funktion setzt die JPEG-Kompressionsqualität. 80 ist ein guter Kompromiss zwischen Qualität und Größe. 90 liefert bessere Qualität, aber eine geringere Größenreduktion. Für schnelleres Video kannst du die Auflösung und JPEG-Kompression reduzieren, bekommst dann aber kleinere Bilder mit geringerer Qualität.

Abschließend initialisiert Camera.begin(cfg) die Kamera mit diesen Einstellungen.

initWifi

Die initWifi() Funktion verbindet den ESP32 mit dem angegebenen Wi-Fi-Netzwerk:

void initWifi() {
  WiFi.persistent(false);
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
  }
  Serial.printf("Stream at: http://%s%s\n",
                WiFi.localIP().toString().c_str(), URL);
}

WiFi.persistent(false) deaktiviert das Schreiben der Zugangsdaten in den Flash-Speicher, was die Wiederverbindung beschleunigt. Das Gerät wird in den Station-Modus (WIFI_STA) versetzt und versucht, sich mit den angegebenen Zugangsdaten zu verbinden.

Nach der Verbindung werden die IP-Adresse und der Stream-Pfad im Serial Monitor ausgegeben. Du musst diese URL in die Adresszeile deines Browsers kopieren, um den Videostream zu sehen. Die tatsächliche URL hängt von deinem ESP32 ab. In meinem Fall sehe ich folgende URL im Serial Monitor:

Streaming URL printed to Serial Monitor — Streaming-URL im Serial Monitor ausgegeben

Daher kopiere ich „http://192.168.2.39/stream“ in die Adresszeile meines Chrome-Browsers, um das Video zu sehen.

initServer

Die initServer() Funktion verknüpft den Streaming-Pfad mit dem Handler und startet den Server:

void initServer() {
  server.on(URL, handleStream);
  server.begin();
}

Damit wird jede Anfrage an /stream an die handleStream() Funktion weitergeleitet, und der Server gestartet.

setup

Die setup() Funktion läuft einmal beim Start:

void setup() {
  Serial.begin(115200);
  initWifi();
  initCamera();
  initServer();
}

Sie startet die serielle Kommunikation, verbindet mit Wi-Fi, initialisiert die Kamera und richtet den Webserver ein.

loop

Schließlich verarbeitet die loop() Funktion kontinuierlich eingehende HTTP-Anfragen:

void loop() {
  server.handleClient();
}

Diese Zeile erlaubt dem ESP32, auf Client-Anfragen zu reagieren, indem registrierte Handler wie handleStream() aufgerufen werden.

Zum Flashen dieses Codes auf dein ESP32-Modul stelle sicher, dass du das AI Thinker ESP32-CAM Board ausgewählt hast:

Select AI Thinker ESP32-CAM as board — Wähle AI Thinker ESP32-CAM als Board

Fazit

In diesem Tutorial hast du gelernt, wie du mit dem ESP32 Camera Pro Kit Video über dein lokales Wi-Fi-Netzwerk an deinen Webbrowser streamst.

Mit der integrierten Batterie, Ladefunktion und den Schraubklemmen auf der Erweiterungsplatine ist es sehr einfach, ein batteriebetriebenes Überwachungssystem ohne Löten zu bauen. Du könntest zum Beispiel eine Taschenlampe und eine Hupe anschließen, um bei Bewegung Alarm zu schlagen. Schau dir unser Motion Activated ESP32-CAM Tutorial für weitere Informationen an.

Beachte, dass die Erweiterungsplatine des ESP32 Camera Pro Kit vergleichsweise groß ist. Wenn du ein kleineres Board mit Kamera brauchst, könntest du das XIAO-ESP32-S3-Sense verwenden. Es ist sehr klein, aber wenn du zusätzliche Hardware anschließen willst, musst du löten können.

Sobald du einen Videostream hast, kannst du auch mit der Objekterkennung im Video beginnen. Siehe unser Object Detection with ESP32-CAM and YOLO Tutorial. Es ist für das ESP32-CAM geschrieben, benötigt aber nur eine minimale Änderung (cfg.setPins(pins::AiThinker)), um mit dem ESP32 Camera Pro Kit zu funktionieren.

Zum Schluss schau dir SunFounders Wiki for the ESP32 Camera Pro Kit an. Dort findest du weitere Informationen und Projekte.

Wenn du Fragen hast, hinterlasse sie gerne im Kommentarbereich.

Viel Spaß beim Tüfteln 😉

Stefan Maetschke