Home
ESP32 S3

ESP32 S3 - Kamera

Dieses Tutorial zeigt Ihnen, wie Sie den ESP32 S3 mit einer Kamera verwenden. Der ESP32 S3 ist leistungsstark genug, um Fotos aufzunehmen und Live-Video über WLAN zu senden, sodass Sie das Video in einem Webbrowser auf Ihrem Handy oder Computer ansehen können. Dieses Tutorial funktioniert mit drei Kamerasensoren: dem OV2640, dem OV3660 und dem OV5640. Derselbe Code funktioniert für alle.

ESP32 S3 - Kamera

Was Sie bauen werden:

  1. Ein ESP32 S3 Kamera-Board, das mit Ihrem WLAN-Netzwerk verbunden ist
  2. Code, der Ihren Kamerasensor automatisch erkennt (OV2640, OV3660 oder OV5640)
  3. Einen kleinen Webserver, der Live-Video in jedem Webbrowser anzeigt
  4. Ein zweites, kürzeres Programm, das ein großes, scharfes JPEG-Foto aufnimmt

Erforderliche Hardware

1×ESP32 S3 N16R8 OV5640 Camera
1×(Alternativ) ESP32 S3 N16R8 OV2640 Camera
1×USB-Kabel Typ-A zu Typ-C (für USB-A PC)
1×USB-Kabel Typ-C zu Typ-C (für USB-C PC)
1×(Optional) DC-Stromanschluss
1×(Empfohlen) Screw Terminal Expansion Board for ESP32 S3
1×(Empfohlen) Breakout Expansion Board for ESP32 S3
1×(Empfohlen) Power Splitter for ESP32 S3

Oder Sie können die folgenden Kits kaufen:

1×DIYables Sensor-Kit (18 Sensoren/Displays)
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.

※ Notiz:

Das ESP32 S3 Kamera-Board hat 40 Pins, aber der Schraubklemmenblock und das Breakout-Board haben 44 Pins. Sie funktionieren trotzdem zusammen. Setzen Sie das Kamera-Board in die Mitte des 44-Pin-Boards, sodass links 2 Pins und rechts 2 Pins frei bleiben.

Mit dem Schraubklemmenblock können Sie Drähte mit einem Schraubendreher anschließen, ganz ohne Löten. Das Breakout-Board bietet Ihnen einfache Stiftleisten für ein Steckbrett.

Überblick über ESP32 S3 Camera

Das ESP32 S3 Kamera-Board ist ein ESP32 S3 N16R8 Board mit einem Kameraanschluss. Die Kamera selbst ist ein kleines Modul, das mit einem Flachbandkabel in diesen Anschluss gesteckt wird. Das Board hat 16 MB Flash-Speicher und 8 MB PSRAM. Das PSRAM ist sehr wichtig, da ein Foto zu groß ist, um in den normalen Speicher des Chips zu passen.

ESP32 S3 Kameramodul

Wichtige Spezifikationen

EigenschaftWert
MikrocontrollerESP32 S3 (Dual-Core, 240 MHz)
Flash-Speicher16 MB
PSRAM8 MB (OPI)
WLAN2,4 GHz, 802.11 b/g/n
KameraschnittstelleDVP, 8-Bit parallel
BildformatJPEG, RGB565, YUV422, Graustufen
Stromversorgung5V über USB Type-C

Vergleich der Kamerasensoren

Für dieses Board sind drei Kamerasensoren erhältlich. Sie verwenden alle denselben Anschluss, dieselben Pins und denselben Code. Sie unterscheiden sich nur in Bildgröße und Bildqualität.

SensorAuflösungGrößtes BildGeeignet für
OV26402 MPUXGA 1600×1200Schnelles Video, einfache Projekte
OV36603 MPQXGA 2048×1536Mehr Details, trotzdem schnell
OV56405 MPQSXGA 2592×1944Beste Fotoqualität

※ Notiz:

Ein größeres Bild ist nicht immer besser. Ein größeres Bild braucht mehr Zeit, um über WLAN gesendet zu werden, sodass das Video langsamer wird. Für Live-Video ist ein kleines Bild wie SVGA (800×600) meist die beste Wahl, auch wenn Sie den OV5640 haben.

Wie die ESP32 S3 Kamera funktioniert

Der Kamerasensor nimmt ein Bild auf und sendet es an den ESP32 S3. Dies geschieht in drei Schritten:

  1. Der ESP32 S3 sendet über den XCLK-Pin ein Taktsignal an die Kamera. Dieser Takt bringt die Kamera zum Arbeiten.
  2. Der ESP32 S3 sendet über die Pins SIOD und SIOC Einstellungen an die Kamera. Diese beiden Pins bilden einen Steuerbus (ähnlich wie I2C).
  3. Die Kamera sendet die Bilddaten über 8 Datenpins (D0 bis D7) zurück, zusammen mit den Pins PCLK, HREF und VSYNC. Diese drei Pins teilen dem ESP32 S3 mit, wo jedes Pixel, jede Zeile und jedes neue Bild beginnt.

Die Kamera kann das Bild selbst in das JPEG-Format komprimieren. Das ist wichtig, da ein JPEG-Bild etwa 10-mal kleiner ist als ein Rohbild. Ein kleineres Bild bedeutet schnelleres Video über WLAN.

Der ESP32 S3 speichert jedes Bild im PSRAM. Ein gespeichertes Bild wird Frame Buffer (Bildpuffer) genannt. Ihr Code fordert einen Frame Buffer an, verwendet ihn und gibt ihn dann an die Kamera zurück.

Namen der Bildgrößen

Die Kamerabibliothek verwendet Kurznamen für Bildgrößen. Sie werden diese Namen im Code sehen:

Name im CodeGröße in PixelnFunktioniert mit
FRAMESIZE_QVGA320 × 240Allen Sensoren
FRAMESIZE_VGA640 × 480Allen Sensoren
FRAMESIZE_SVGA800 × 600Allen Sensoren
FRAMESIZE_HD1280 × 720Allen Sensoren
FRAMESIZE_UXGA1600 × 1200Allen Sensoren
FRAMESIZE_QXGA2048 × 1536Nur OV3660 und OV5640
FRAMESIZE_QSXGA2592 × 1944Nur OV5640

Wiring Diagram between Camera and ESP32 S3

Die Kamera wird über ein Flachbandkabel mit dem ESP32 S3 Board verbunden. Sie benötigen kein Steckbrett und keine Jumper-Kabel.

  • Wie man das Kameramodul mit dem ESP32 S3 Board verbindet
ESP32 S3 Kamera Schaltplan

Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.

  1. Schalten Sie die Stromversorgung aus. Ziehen Sie zuerst das USB-Kabel ab.
  2. Suchen Sie den schwarzen Anschluss auf dem Board. Ziehen Sie den kleinen schwarzen Bügel nach oben. Ziehen Sie vorsichtig.
  3. Schieben Sie das Flachbandkabel in den Anschluss. Die blaue Seite des Kabels zeigt nach oben, und die Metallkontakte zeigen nach unten.
  4. Drücken Sie den kleinen schwarzen Bügel wieder nach unten, um das Kabel zu verriegeln.
  5. Stecken Sie das USB-Kabel ein.

Sicherheitshinweise

Stecken Sie die Kamera niemals ein oder aus, während das Board mit Strom versorgt wird. Dies kann den Kamerasensor beschädigen. Ziehen Sie immer zuerst das USB-Kabel ab. Ziehen Sie außerdem nicht fest am Flachbandkabel, da es leicht bricht.

Die folgende Tabelle zeigt, wie die Kamera im Board verbunden ist. Sie müssen diese Pins nicht selbst verdrahten, aber Sie benötigen sie in Ihrem Code:

Kamera-PinESP32 S3 PinBedeutung
XCLKGPIO15Takt zur Kamera
SIODGPIO4Steuerdaten
SIOCGPIO5Steuertakt
VSYNCGPIO6Beginn eines neuen Bildes
HREFGPIO7Beginn einer neuen Zeile
PCLKGPIO13Pixeltakt
D0GPIO11Datenbit 0
D1GPIO9Datenbit 1
D2GPIO8Datenbit 2
D3GPIO10Datenbit 3
D4GPIO12Datenbit 4
D5GPIO18Datenbit 5
D6GPIO17Datenbit 6
D7GPIO16Datenbit 7

※ Notiz:

Diese Pins werden von der Kamera verwendet. Verwenden Sie sie nicht für andere Bauteile in Ihrem Projekt.

Arduino IDE Einstellungen für die ESP32 S3 Kamera

Die Kamera funktioniert nicht mit den Standardeinstellungen der Arduino IDE. Sie müssen einige Punkte im Menü Tools ändern, bevor Sie den Code hochladen.

Menüpunkt in ToolsDiese Option wählen
BoardESP32S3 Dev Module
Flash Size16MB (128Mb)
PSRAMOPI PSRAM
Partition SchemeHuge APP (3MB No OTA/1MB SPIFFS)
CPU Frequency240MHz (WiFi)
USB ModeHardware CDC and JTAG
Upload ModeUART0 / Hardware CDC
Upload Speed921600
USB CDC On BootEnabled

※ Notiz:

Zwei Einstellungen sind am wichtigsten:

  • PSRAM muss OPI PSRAM sein. Wenn es Disabled ist, kann die Kamera nicht starten.
  • Partition Scheme muss Huge APP sein. Der Kamera-Code ist groß, und die Standardeinstellung ist dafür zu klein.

Ändern Sie zuerst Flash Size, da sich danach die Liste der Partition-Scheme-Optionen ändert.

DIYables ESP32 WebServer Bibliothek installieren

Dieses Tutorial verwendet die Bibliothek DIYables ESP32 WebServer. Diese Bibliothek macht den Webserver-Teil sehr kurz und leicht lesbar.

  1. Öffnen Sie die Arduino IDE.
  2. Klicken Sie auf das Symbol Libraries in der linken Leiste.
  3. Geben Sie DIYables ESP32 WebServer in das Suchfeld ein.
  4. Suchen Sie die Bibliothek von DIYables.io und klicken Sie auf INSTALL.
  • Search for DIYables ESP32 WebServer created by DIYables.io and click the Install button.
∞
Newbiely | Arduino IDE 2.3.8
──
☐
✕
File
Edit
Sketch
Tools
Help
ESP32S3 Dev Module
Library Manager
DIYables ESP32 WebServer
Type:
All
Topic:
All
DIYables ESP32 WebServer by DIYables.io
DIYables ESP32 WebServer library designed for ESP32 boards. It includes multi-page web server capabilities and WebSocket support for real-time communication, perfect for IoT projects and DIYables ESP32 boards. More info
1.0.1
INSTALL
Newbiely.ino
···
1 void setup() {
Output
Serial Monitor
Ln 1, Col 1
ESP32S3 Dev Module on COM15
1

Die Kamerabibliothek (esp_camera.h) ist bereits im ESP32-Board-Paket enthalten. Diese müssen Sie nicht installieren.

Wie man die ESP32 S3 Kamera programmiert

  • Binden Sie die beiden Bibliotheken am Anfang Ihres Codes ein.
#include <WiFi.h> #include <DIYables_ESP32_WebServer.h> #include "esp_camera.h"
  • Legen Sie Ihre Kameraeinstellungen in einer Variablen vom Typ camera_config_t ab. Die wichtigsten Einstellungen sind das Bildformat, die Bildgröße und die Bildqualität.
camera_config_t config; config.pixel_format = PIXFORMAT_JPEG; // JPEG is small and fast config.frame_size = FRAMESIZE_SVGA; // 800x600 config.jpeg_quality = 10; // 0 to 63, a lower number means a better image config.fb_count = 2; // use 2 frame buffers for smooth video
  • Starten Sie die Kamera mit der Funktion esp_camera_init(). Sie gibt ESP_OK zurück, wenn die Kamera korrekt startet.
esp_err_t err = esp_camera_init(&config); if (err != ESP_OK) { Serial.printf("Camera init failed with error 0x%x\n", err); }
  • Finden Sie heraus, welcher Kamerasensor auf Ihrem Board sitzt. Jeder Sensor hat eine eigene ID-Nummer, die PID genannt wird.
sensor_t *s = esp_camera_sensor_get(); if (s->id.PID == OV2640_PID) Serial.println("This is an OV2640 camera"); else if (s->id.PID == OV3660_PID) Serial.println("This is an OV3660 camera"); else if (s->id.PID == OV5640_PID) Serial.println("This is an OV5640 camera");
  • Nehmen Sie mit der Funktion esp_camera_fb_get() ein Foto auf. Diese Funktion gibt Ihnen einen Frame Buffer. Das Foto befindet sich in fb->buf, und seine Größe in Bytes in fb->len.
camera_fb_t *fb = esp_camera_fb_get(); if (fb) { Serial.printf("Photo size: %u bytes\n", fb->len); esp_camera_fb_return(fb); // give the frame buffer back }

※ Notiz:

Sie müssen nach jedem esp_camera_fb_get() die Funktion esp_camera_fb_return() aufrufen. Wenn Sie es vergessen, geht der Kamera der Speicher aus und sie stoppt nach wenigen Fotos.

  • Ändern Sie das Aussehen des Bildes. Drehen Sie das Bild zum Beispiel auf den Kopf oder machen Sie es heller.
sensor_t *s = esp_camera_sensor_get(); s->set_vflip(s, 1); // turn the image upside down s->set_hmirror(s, 1); // mirror the image left to right s->set_brightness(s, 1); // -2 to 2 s->set_saturation(s, 0); // -2 to 2

※ Notiz:

Der OV3660 zeigt das Bild standardmäßig auf dem Kopf. Der Code unten behebt dies mit s->set_vflip(s, 1). Wenn Ihr eigenes Bild auf dem Kopf steht oder gespiegelt ist, ändern Sie diese beiden Zeilen.

※ Notiz:

Mit der Bildgröße ist es anders. Wählen Sie sie einmal in config.frame_size, vor esp_camera_init(). Ändern Sie sie später nicht, während der Code läuft, sonst zeigt die Kamera den Fehler cam_hal: FB-OVF und liefert keine Bilder mehr.

Nun zum Webserver-Teil. Die Bibliothek DIYables ESP32 WebServer benötigt nur drei Dinge: den Server erstellen, Ihre Adressen hinzufügen und handleClient() immer wieder aufrufen.

  • Erstellen Sie den Webserver auf Port 80.
DIYables_ESP32_WebServer server(80);
  • Schreiben Sie für jede Adresse eine Funktion. Jede Funktion muss genau diese fünf Parameter haben.
void handleHome(WiFiClient &client, const String &method, const String &request, const QueryParams &params, const String &jsonData) { server.sendResponse(client, INDEX_HTML, "text/html"); }
  • Fügen Sie Ihre Adressen in setup() hinzu und starten Sie den Server.
server.addRoute("/", handleHome); server.addRoute("/stream", handleStream); server.begin();

※ Notiz:

Verwenden Sie server.begin() und verbinden Sie sich selbst mit dem WLAN. Verwenden Sie in diesem Projekt nicht server.begin(ssid, password), da diese Version die Geschwindigkeit des Seriellen Monitors auf 9600 setzt und Sie die Meldungen dann bei 115200 nicht lesen können.

  • Um Live-Video zu senden, senden Sie viele Fotos nacheinander und setzen Sie einen Trenntext dazwischen. Das nennt man einen MJPEG-Stream. Jeder Webbrowser versteht ihn. Ein Bild ist kein Text, daher müssen Sie client.write() und nicht client.print() verwenden.
while (client.connected()) { camera_fb_t *fb = esp_camera_fb_get(); size_t len = fb->len; client.print("--" BOUNDARY "\r\n"); client.print("Content-Type: image/jpeg\r\n"); client.printf("Content-Length: %u\r\n\r\n", len); client.write(fb->buf, len); client.print("\r\n"); esp_camera_fb_return(fb); }
  • Rufen Sie handleClient() in loop() auf. Ohne diese Zeile tut der Webserver nichts.
void loop() { server.handleClient(); }

※ Notiz:

Während eine Person das Video ansieht, ist der ESP32 S3 beschäftigt und kann einer zweiten Person nicht antworten. Das ist für ein kleines Board normal. Öffnen Sie das Video jeweils nur auf einem Gerät.

ESP32 S3 Code - Beispiel 1: Live-Video

Dies ist das einfache Beispiel. Es startet die Kamera, verbindet sich mit Ihrem WLAN-Netzwerk und zeigt das Live-Video in einem Webbrowser an. Beginnen Sie mit diesem.

Der Webserver hat zwei Adressen:

  • http://<IP>/ zeigt eine Webseite mit dem Live-Video
  • http://<IP>/stream ist nur das Live-Video

Der Code liest die Sensor-ID und setzt automatisch die richtigen Einstellungen für den OV2640, den OV3660 oder den OV5640. Sie müssen den Code für Ihre Kamera nicht ändern.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt. * Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte: * https://newbiely.de/tutorials/esp32-s3/esp32-s3-camera */ #include <WiFi.h> #include <DIYables_ESP32_WebServer.h> // DIYables ESP32 WebServer library #include "esp_camera.h" const char *WIFI_SSID = "YOUR_WIFI_SSID"; // CHANGE IT const char *WIFI_PASSWORD = "YOUR_WIFI_PASSWORD"; // CHANGE IT // Camera pins of the ESP32-S3-N16R8 camera board. // The same pins work for the OV2640, OV3660 and OV5640 versions. #define PWDN_GPIO_NUM -1 #define RESET_GPIO_NUM -1 #define XCLK_GPIO_NUM 15 #define SIOD_GPIO_NUM 4 #define SIOC_GPIO_NUM 5 #define Y9_GPIO_NUM 16 #define Y8_GPIO_NUM 17 #define Y7_GPIO_NUM 18 #define Y6_GPIO_NUM 12 #define Y5_GPIO_NUM 10 #define Y4_GPIO_NUM 8 #define Y3_GPIO_NUM 9 #define Y2_GPIO_NUM 11 #define VSYNC_GPIO_NUM 6 #define HREF_GPIO_NUM 7 #define PCLK_GPIO_NUM 13 DIYables_ESP32_WebServer server(80); // The text that separates one image from the next image in the video #define BOUNDARY "diyablesframe" const char INDEX_HTML[] = R"rawliteral( <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1"> <title>ESP32 S3 Camera</title> <style> body { background:#111; color:#eee; font-family:sans-serif; text-align:center; margin:0; padding:16px; } img { width:100%; max-width:800px; border-radius:8px; } </style> </head> <body> <h2>ESP32 S3 Camera</h2> <img src="/stream"> </body> </html> )rawliteral"; // Returns the name of the camera sensor that is installed on the board const char *getSensorName(int pid) { switch (pid) { case OV2640_PID: return "OV2640 (2 MP, max UXGA 1600x1200)"; case OV3660_PID: return "OV3660 (3 MP, max QXGA 2048x1536)"; case OV5640_PID: return "OV5640 (5 MP, max QSXGA 2592x1944)"; default: return "Unknown sensor"; } } bool initCamera() { 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_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; config.pixel_format = PIXFORMAT_JPEG; config.frame_size = FRAMESIZE_SVGA; // 800x600 config.jpeg_quality = 12; // 0 to 63, a lower number means a better image config.fb_count = 1; config.fb_location = CAMERA_FB_IN_DRAM; config.grab_mode = CAMERA_GRAB_WHEN_EMPTY; if (psramFound()) { config.fb_location = CAMERA_FB_IN_PSRAM; config.jpeg_quality = 10; config.fb_count = 2; config.grab_mode = CAMERA_GRAB_LATEST; } else { config.frame_size = FRAMESIZE_QVGA; Serial.println("WARNING: PSRAM not found. Please set PSRAM to OPI PSRAM in the Tools menu."); } 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; } sensor_t *s = esp_camera_sensor_get(); Serial.printf("Camera sensor: %s\n", getSensorName(s->id.PID)); // Each sensor needs slightly different settings switch (s->id.PID) { case OV2640_PID: s->set_vflip(s, 0); s->set_hmirror(s, 0); break; case OV3660_PID: s->set_vflip(s, 1); // the OV3660 image is upside down by default s->set_brightness(s, 1); // make the image a little brighter s->set_saturation(s, -2); // make the colors a little softer break; case OV5640_PID: s->set_vflip(s, 0); s->set_hmirror(s, 0); break; default: break; } return true; } // Shows the web page with the live video void handleHome(WiFiClient &client, const String &method, const String &request, const QueryParams &params, const String &jsonData) { server.sendResponse(client, INDEX_HTML, "text/html"); } // Sends the live video to the web browser void handleStream(WiFiClient &client, const String &method, const String &request, const QueryParams &params, const String &jsonData) { Serial.println("Video stream started"); client.print("HTTP/1.1 200 OK\r\n"); client.print("Content-Type: multipart/x-mixed-replace; boundary=" BOUNDARY "\r\n"); client.print("Access-Control-Allow-Origin: *\r\n"); client.print("Connection: close\r\n\r\n"); while (client.connected()) { camera_fb_t *fb = esp_camera_fb_get(); if (!fb) { Serial.println("Frame capture failed"); break; } size_t len = fb->len; client.print("--" BOUNDARY "\r\n"); client.print("Content-Type: image/jpeg\r\n"); client.printf("Content-Length: %u\r\n\r\n", len); size_t sent = client.write(fb->buf, len); client.print("\r\n"); esp_camera_fb_return(fb); if (sent != len) { // the web browser closed the video break; } } Serial.println("Video stream stopped"); } void setup() { Serial.begin(115200); delay(1000); if (!initCamera()) { Serial.println("Stopped"); while (true) delay(1000); } WiFi.mode(WIFI_STA); WiFi.begin(WIFI_SSID, WIFI_PASSWORD); Serial.print("Connecting to WiFi"); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(); WiFi.setSleep(false); // keep WiFi fast for the video server.addRoute("/", handleHome); server.addRoute("/stream", handleStream); server.begin(); Serial.print("Camera is ready. Open this address in your web browser: http://"); Serial.println(WiFi.localIP()); } void loop() { server.handleClient(); }

Schnelle Schritte

  • Neu beim ESP32 S3? Absolvieren Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3.
  • Verbinden Sie das Kameramodul mit dem Board. Denken Sie daran: Ziehen Sie zuerst das USB-Kabel ab.
  • Installieren Sie die Bibliothek DIYables ESP32 WebServer. Siehe die Schritte oben.
  • Kopieren Sie den obigen Code und fügen Sie ihn in die Arduino IDE ein.
  • Ändern Sie YOUR_WIFI_SSID und YOUR_WIFI_PASSWORD in den Namen und das Passwort Ihres WLAN-Netzwerks.
  • Ändern Sie die Einstellungen im Menü Tools. Siehe die Tabelle oben.
  • Kompilieren Sie den Code und laden Sie ihn auf das ESP32 S3 Board hoch, indem Sie in der Arduino IDE auf die Schaltfläche Upload klicken.
Arduino IDE Code hochladen
  • Öffnen Sie den Seriellen Monitor in der Arduino IDE.
Wie man den Seriellen Monitor in der Arduino IDE öffnet
  • Drücken Sie einmal die Taste RESET auf dem Board.
  • Lesen Sie die IP-Adresse im Seriellen Monitor ab.
  • Geben Sie diese Adresse in Ihren Webbrowser ein und sehen Sie sich das Live-Video an.
  • Profi-Tipp: Ihr Computer oder Handy muss sich im selben WLAN-Netzwerk wie der ESP32 S3 befinden. Wenn sie in verschiedenen Netzwerken sind, öffnet sich die Seite nicht.

Serieller Monitor

Nach dem Hochladen zeigt der Serielle Monitor den Namen Ihres Kamerasensors und die IP-Adresse der Kamera. Die folgenden Messwerte wurden im Jahr 2026 aufgezeichnet:

∞
Newbiely | Arduino IDE 2.3.8
──
☐
✕
File
Edit
Sketch
Tools
Help
ESP32S3 Dev Module
Newbiely.ino
···
8 Serial.println("Hello World!");
Output
Serial Monitor
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-09-23 10:00:01] Camera sensor: OV5640 (5 MP, max QSXGA 2592x1944) [2026-09-23 10:00:01] Connecting to WiFi... [2026-09-23 10:00:04] Starting web server on IP: 192.168.0.2 [2026-09-23 10:00:04] Camera is ready. Open this address in your web browser: http://192.168.0.2 [2026-09-23 10:00:15] Method: GET [2026-09-23 10:00:15] Requested path: / [2026-09-23 10:00:15] Client disconnected [2026-09-23 10:00:15] Method: GET [2026-09-23 10:00:15] Requested path: /stream [2026-09-23 10:00:15] Video stream started
Ln 11, Col 1
ESP32S3 Dev Module on COM15
2

※ Notiz:

Die Zeilen Method: GET, Requested path: / und Client disconnected stammen von der Bibliothek DIYables ESP32 WebServer. Sie zeigen Ihnen, dass der Webbrowser Ihr Board erreicht hat. Das ist normal.

Die Zeile mit dem Sensornamen ist für jede Kamera unterschiedlich:

Ihre KameraZeile im Seriellen Monitor
OV2640Camera sensor: OV2640 (2 MP, max UXGA 1600x1200)
OV3660Camera sensor: OV3660 (3 MP, max QXGA 2048x1536)
OV5640Camera sensor: OV5640 (5 MP, max QSXGA 2592x1944)

Öffnen Sie nun die IP-Adresse in Ihrem Webbrowser. Sie sehen das Live-Video der Kamera:

ESP32 S3 Kamera Live-Video im Webbrowser

ESP32 S3 Code - Beispiel 2: Ein Foto aufnehmen

Dieses Beispiel verwendet kein Video. Es nimmt nur ein Foto auf. Der Code ist kürzer und leichter zu lesen, daher ist er ein guter Einstieg, wenn Ihnen das Video zu schwierig erscheint.

Der Webserver hat zwei Adressen:

  • http://<IP>/ zeigt die Webseite mit dem Foto
  • http://<IP>/photo ist nur das Foto

Jedes Mal, wenn die Seite geöffnet wird, nimmt der ESP32 S3 ein neues Foto auf. Um ein weiteres Foto aufzunehmen, klicken Sie auf den Link Take a new photo.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt. * Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte: * https://newbiely.de/tutorials/esp32-s3/esp32-s3-camera */ #include <WiFi.h> #include <DIYables_ESP32_WebServer.h> // DIYables ESP32 WebServer library #include "esp_camera.h" const char *WIFI_SSID = "YOUR_WIFI_SSID"; // CHANGE IT const char *WIFI_PASSWORD = "YOUR_WIFI_PASSWORD"; // CHANGE IT // Camera pins of the ESP32-S3-N16R8 camera board. // The same pins work for the OV2640, OV3660 and OV5640 versions. #define PWDN_GPIO_NUM -1 #define RESET_GPIO_NUM -1 #define XCLK_GPIO_NUM 15 #define SIOD_GPIO_NUM 4 #define SIOC_GPIO_NUM 5 #define Y9_GPIO_NUM 16 #define Y8_GPIO_NUM 17 #define Y7_GPIO_NUM 18 #define Y6_GPIO_NUM 12 #define Y5_GPIO_NUM 10 #define Y4_GPIO_NUM 8 #define Y3_GPIO_NUM 9 #define Y2_GPIO_NUM 11 #define VSYNC_GPIO_NUM 6 #define HREF_GPIO_NUM 7 #define PCLK_GPIO_NUM 13 DIYables_ESP32_WebServer server(80); const char INDEX_HTML[] = R"rawliteral( <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1"> <title>ESP32 S3 Camera</title> <style> body { background:#111; color:#eee; font-family:sans-serif; text-align:center; margin:0; padding:16px; } img { width:100%; max-width:800px; border-radius:8px; } a { color:#4da3ff; font-size:18px; } </style> </head> <body> <h2>ESP32 S3 Camera</h2> <img src="/photo"> <p><a href="/">Take a new photo</a></p> </body> </html> )rawliteral"; // Returns the name of the camera sensor that is installed on the board const char *getSensorName(int pid) { switch (pid) { case OV2640_PID: return "OV2640 (2 MP, max UXGA 1600x1200)"; case OV3660_PID: return "OV3660 (3 MP, max QXGA 2048x1536)"; case OV5640_PID: return "OV5640 (5 MP, max QSXGA 2592x1944)"; default: return "Unknown sensor"; } } bool initCamera() { 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_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; config.pixel_format = PIXFORMAT_JPEG; config.frame_size = FRAMESIZE_UXGA; // 1600x1200 - a big, sharp photo config.jpeg_quality = 12; // 0 to 63, a lower number means a better image config.fb_count = 1; config.fb_location = CAMERA_FB_IN_DRAM; config.grab_mode = CAMERA_GRAB_WHEN_EMPTY; if (psramFound()) { config.fb_location = CAMERA_FB_IN_PSRAM; config.jpeg_quality = 10; config.fb_count = 2; config.grab_mode = CAMERA_GRAB_LATEST; } else { config.frame_size = FRAMESIZE_QVGA; Serial.println("WARNING: PSRAM not found. Please set PSRAM to OPI PSRAM in the Tools menu."); } 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; } sensor_t *s = esp_camera_sensor_get(); Serial.printf("Camera sensor: %s\n", getSensorName(s->id.PID)); // Each sensor needs slightly different settings switch (s->id.PID) { case OV2640_PID: s->set_vflip(s, 0); s->set_hmirror(s, 0); break; case OV3660_PID: s->set_vflip(s, 1); // the OV3660 image is upside down by default s->set_brightness(s, 1); // make the image a little brighter s->set_saturation(s, -2); // make the colors a little softer break; case OV5640_PID: s->set_vflip(s, 0); s->set_hmirror(s, 0); break; default: break; } return true; } // Shows the web page void handleHome(WiFiClient &client, const String &method, const String &request, const QueryParams &params, const String &jsonData) { server.sendResponse(client, INDEX_HTML, "text/html"); } // Takes one photo and sends it to the web browser void handlePhoto(WiFiClient &client, const String &method, const String &request, const QueryParams &params, const String &jsonData) { camera_fb_t *fb = esp_camera_fb_get(); if (!fb) { Serial.println("Photo capture failed"); server.sendResponse(client, "Photo capture failed", "text/plain"); return; } Serial.printf("Photo taken: %u bytes\n", fb->len); client.print("HTTP/1.1 200 OK\r\n"); client.print("Content-Type: image/jpeg\r\n"); client.print("Content-Disposition: inline; filename=photo.jpg\r\n"); client.printf("Content-Length: %u\r\n", fb->len); client.print("Connection: close\r\n\r\n"); client.write(fb->buf, fb->len); esp_camera_fb_return(fb); // give the memory back to the camera } void setup() { Serial.begin(115200); delay(1000); if (!initCamera()) { Serial.println("Stopped"); while (true) delay(1000); } WiFi.mode(WIFI_STA); WiFi.begin(WIFI_SSID, WIFI_PASSWORD); Serial.print("Connecting to WiFi"); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(); server.addRoute("/", handleHome); server.addRoute("/photo", handlePhoto); server.begin(); Serial.print("Camera is ready. Open this address in your web browser: http://"); Serial.println(WiFi.localIP()); } void loop() { server.handleClient(); }

Wie es funktioniert

Die Webseite hat nur zwei wichtige Zeilen:

<img src="/photo"> <p><a href="/">Take a new photo</a></p>

Der Webbrowser liest <img src="/photo"> und fragt den ESP32 S3 nach der Adresse /photo. Die Funktion handlePhoto() nimmt ein Foto auf und sendet es als JPEG-Bild zurück. Der Link / öffnet die Seite erneut, sodass die Kamera ein neues Foto aufnimmt. Sie benötigen kein JavaScript.

※ Notiz:

Dieses Beispiel verwendet eine große Bildgröße (FRAMESIZE_UXGA, 1600×1200), da ein Foto nicht schnell sein muss. Beispiel 1 verwendet eine kleine Größe (FRAMESIZE_SVGA, 800×600), da ein kleines Bild schneller über WLAN übertragen wird und das Video viele Bilder pro Sekunde benötigt.

※ Notiz:

Möchten Sie ein noch größeres Foto? Ändern Sie config.frame_size in FRAMESIZE_QXGA (nur OV3660 und OV5640) oder in FRAMESIZE_QSXGA (nur OV5640). Ein größeres Foto benötigt mehr PSRAM und mehr Zeit.

Schnelle Schritte

  • Kopieren Sie den obigen Code und fügen Sie ihn in die Arduino IDE ein.
  • Ändern Sie erneut YOUR_WIFI_SSID und YOUR_WIFI_PASSWORD.
  • Laden Sie den Code hoch und drücken Sie einmal die Taste RESET.
  • Öffnen Sie die IP-Adresse in Ihrem Webbrowser. Das Foto erscheint.
  • Klicken Sie auf Take a new photo, um ein weiteres aufzunehmen.
  • Um ein Foto zu behalten, klicken Sie mit der rechten Maustaste auf das Bild und wählen Sie Bild speichern unter...
ESP32 S3 Kamera Foto im Webbrowser

Der Serielle Monitor zeigt die Größe jedes Fotos:

∞
Newbiely | Arduino IDE 2.3.8
──
☐
✕
File
Edit
Sketch
Tools
Help
ESP32S3 Dev Module
Newbiely.ino
···
8 Serial.println("Hello World!");
Output
Serial Monitor
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-09-23 10:05:02] Camera sensor: OV5640 (5 MP, max QSXGA 2592x1944) [2026-09-23 10:05:02] Connecting to WiFi... [2026-09-23 10:05:05] Starting web server on IP: 192.168.0.2 [2026-09-23 10:05:05] Camera is ready. Open this address in your web browser: http://192.168.0.2 [2026-09-23 10:05:20] Method: GET [2026-09-23 10:05:20] Requested path: / [2026-09-23 10:05:20] Client disconnected [2026-09-23 10:05:20] Method: GET [2026-09-23 10:05:20] Requested path: /photo [2026-09-23 10:05:21] Photo taken: 184320 bytes
Ln 11, Col 1
ESP32S3 Dev Module on COM15
2

Fehlerbehebung

Hier sind die Probleme, auf die Einsteiger am häufigsten stoßen, und wie man sie löst.

Der Serielle Monitor zeigt nach den Boot-Meldungen nichts an.

Die Einstellung USB CDC On Boot passt nicht zu Ihrem USB-Anschluss. Wenn Ihr USB-Kabel im Anschluss mit der Bezeichnung UART steckt, stellen Sie USB CDC On Boot auf Disabled. Wenn Ihr Kabel im Anschluss mit der Bezeichnung USB steckt, stellen Sie es auf Enabled. Laden Sie den Code dann erneut hoch. Prüfen Sie außerdem, ob das Geschwindigkeitsfeld im Seriellen Monitor 115200 anzeigt.

Der Serielle Monitor zeigt Camera init failed with error 0x105.

Die Kamera kann nicht starten. Es gibt drei häufige Gründe:

  • PSRAM ist Disabled. Stellen Sie es im Menü Tools auf OPI PSRAM.
  • Das Flachbandkabel ist locker oder falsch herum eingesteckt. Ziehen Sie das USB-Kabel ab, öffnen Sie den Anschluss und stecken Sie das Kabel erneut ein.
  • Der Takt ist für Ihr Kameramodul zu schnell. Ändern Sie im Code config.xclk_freq_hz von 20000000 auf 10000000.

Der Serielle Monitor zeigt WARNING: PSRAM not found.

Stellen Sie PSRAM im Menü Tools auf OPI PSRAM und laden Sie den Code erneut hoch.

Das Hochladen schlägt fehl, oder der COM-Port erscheint nicht.

Halten Sie die Taste BOOT gedrückt, drücken Sie einmal die Taste RESET und lassen Sie dann die Taste BOOT los. Jetzt erscheint der Port im Menü Tools. Drücken Sie nach dem Hochladen einmal RESET.

Der Serielle Monitor zeigt die IP-Adresse, aber die Webseite öffnet sich nicht.

Ihr Computer und Ihr ESP32 S3 befinden sich wahrscheinlich in verschiedenen Netzwerken. Beide müssen im selben WLAN-Netzwerk sein. Geben Sie außerdem http:// und nicht https:// ein, da der ESP32 S3 kein https verwendet.

Das Video ist langsam, oder es stoppt nach wenigen Sekunden.

Das Bild ist für Ihr WLAN zu groß. Ändern Sie config.frame_size in eine kleinere Größe, wie FRAMESIZE_VGA oder FRAMESIZE_QVGA. Sie können auch config.jpeg_quality auf 15 erhöhen, was eine kleinere Datei ergibt.

Der Serielle Monitor zeigt cam_hal: FB-OVF und Photo capture failed.

FB-OVF bedeutet "Frame Buffer Overflow" (Bildpuffer-Überlauf): Das Bild ist größer als der dafür bereitgestellte Speicher. Wählen Sie Ihre Bildgröße einmal in config.frame_size, bevor Sie esp_camera_init() aufrufen. Ändern Sie die Größe später nicht mit s->set_framesize(), da diese Funktion den Kamerasensor ändert, ohne den Speicher zu vergrößern. Wenn Sie die Größe wirklich während der Laufzeit ändern müssen, verwenden Sie stattdessen die Funktion esp_camera_reconfigure().

Das Foto dauert lange, oder die Seite wartet.

Ein großes Foto braucht Zeit. FRAMESIZE_UXGA dauert etwa eine Sekunde. Verwenden Sie FRAMESIZE_XGA oder FRAMESIZE_SVGA, wenn Sie ein schnelleres Foto möchten.

Das Foto schlägt bei jedem Versuch fehl.

Ihre Bildgröße ist für den freien Speicher zu groß. Verwenden Sie eine kleinere Größe, wie FRAMESIZE_XGA, oder setzen Sie config.fb_count auf 1.

Das Bild steht auf dem Kopf oder ist gespiegelt.

Ändern Sie die beiden Zeilen s->set_vflip(s, 0) und s->set_hmirror(s, 0) im Code. Verwenden Sie 1 statt 0.

Anwendungen

Eine ESP32 S3 Kamera ist klein, günstig und funktioniert über WLAN, sodass ein Board eine teure IP-Kamera ersetzt. Hier sind praktische Projekte, die Sie mit diesem Code bauen können:

  1. WLAN-Sicherheitskamera für zu Hause: Beobachten Sie Ihre Tür oder Ihr Fenster von Ihrem Handy aus, ohne monatliche Gebühren.
  2. Haustierkamera für Hunde und Katzen: Sehen Sie, was Ihr Haustier macht, wenn Sie nicht zu Hause sind.
  3. 3D-Drucker-Überwachung: Beobachten Sie einen langen Druckauftrag aus einem anderen Raum und stoppen Sie ihn frühzeitig, wenn etwas schiefgeht.
  4. Video-Türklingel: Nehmen Sie ein Foto auf, wenn jemand den Taster an Ihrer Tür drückt.
  5. Kamera für Baby- und Kinderzimmer: Schauen Sie von Ihrem Handy aus ins Zimmer, ohne die Tür zu öffnen.
  6. Pflanzenwachstums-Rekorder: Nehmen Sie jede Stunde ein Foto auf und fügen Sie sie zu einem Zeitraffervideo zusammen.
  7. Roboterauto-Kamera: Geben Sie einem kleinen Roboter Augen und steuern Sie ihn aus einem anderen Raum.
  8. Drohnen- und RC-Kamera: Senden Sie Live-Video von einem Modellauto, einem Boot oder einer kleinen Drohne.
  9. Aquarium- und Gewächshaus-Wächter: Behalten Sie Ihre Fische oder Pflanzen im Auge, während Sie unterwegs sind.
  10. Maschinen- und Werkstattüberwachung: Beobachten Sie eine Maschine, eine 3D-Drucker-Farm oder einen Laserschneider während des Betriebs.
  11. Kamera für Geschäft und Empfang: Zeigen Sie die Tür Ihres Geschäfts auf einem Bildschirm im hinteren Raum.
  12. Lernprojekt für Schüler: Ein vollständiges Beispiel für eine Kamera, einen Webserver und WLAN auf einem kleinen Board.

Video Tutorial

Wir erwägen die Erstellung von Video-Tutorials. Wenn Sie Video-Tutorials für wichtig halten, abonnieren Sie bitte unseren YouTube-Kanal , um uns zu motivieren, die Videos zu erstellen.

Sehen Sie sich unten die Schritt-für-Schritt-Videoanleitung für dieses ESP32 S3 Projekt an.

Herausforderungen

Da Sie nun eine funktionierende Kamera am ESP32 S3 haben, versuchen Sie, das Projekt mit diesen Übungen zu erweitern, um Ihr Verständnis zu vertiefen.

  1. Einsteiger: Ändern Sie die Bildgröße im Code von FRAMESIZE_SVGA in FRAMESIZE_VGA und dann in FRAMESIZE_UXGA. Beobachten Sie, wie sich die Geschwindigkeit des Videos ändert.
  2. Fortgeschritten: Fügen Sie dem Board einen Taster hinzu. Wenn jemand den Taster drückt, nehmen Sie ein Foto auf und speichern Sie es auf der SD-Karte.
  3. Profi: Nehmen Sie alle 10 Minuten ein Foto auf und senden Sie es mit einem Telegram-Bot an Ihr Handy, sodass Sie ein Bild erhalten, auch wenn Sie weit weg von zu Hause sind.

Sprachreferenzen

Verwandte Tutorials

※ UNSERE NACHRICHTEN

  • Sie können gerne den Link zu diesem Tutorial teilen. Bitte verwenden Sie jedoch unsere Inhalte nicht auf anderen Websites. Wir haben viel Mühe und Zeit in die Erstellung der Inhalte investiert, bitte respektieren Sie unsere Arbeit!
OFFENLEGUNG
Newbiely.de ist Teilnehmer des Amazon Services LLC Associates Program, einem Affiliate-Werbeprogramm, das entwickelt wurde, um Websites eine Möglichkeit zu bieten, Werbegebühren durch Werbung und Verlinkung zu Amazon.com, Amazon.it, Amazon.de, Amazon.co.uk, Amazon.ca, Amazon.de, Amazon.es, Amazon.nl, Amazon.pl und Amazon.se zu verdienen
Copyright © 2026 Newbiely.de. Alle Rechte vorbehalten.
Allgemeine Geschäftsbedingungen | Datenschutzrichtlinie
Email: newbiely.com@gmail.com