ESP32 S3 Kamera - Foto auf SD-Karte speichern, wenn die Tür geöffnet wird

Dieses Tutorial zeigt Ihnen, wie Sie mit dem ESP32 S3 eine Türkamera bauen. Ein magnetischer Türsensor überwacht Ihre Tür. In dem Moment, in dem jemand sie öffnet, nimmt der ESP32 S3 ein Foto auf und speichert es auf einer microSD-Karte. Das Board arbeitet allein. Es braucht kein WLAN und keinen Computer.

ESP32 S3 Kamera - Foto auf SD-Karte speichern, wenn die Tür geöffnet wird

Was Sie bauen werden:

  1. Eine ESP32 S3 Kamera mit einem magnetischen Türsensor
  2. Ein Foto, das jedes Mal auf der microSD-Karte gespeichert wird, wenn die Tür geöffnet wird
  3. Eine saubere Erkennung, sodass eine Türbewegung genau ein Foto speichert
  4. Eine Türkamera, die ganz ohne Internet funktioniert

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×Türsensor
1×microSD Card
1×Verbindungskabel
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 auf der linken Seite 2 Pins frei bleiben und auf der rechten Seite 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 Breadboard.

Überblick über Door Sensor

Ein Türsensor besteht aus zwei Teilen:

  1. Einem kleinen Kunststoffgehäuse mit zwei Drähten. Dieser Teil enthält einen Reedschalter. Sie bringen ihn am Türrahmen an.
  2. Einem zweiten Kunststoffgehäuse ohne Drähte. Dieser Teil enthält einen Magneten. Sie bringen ihn an der Tür selbst an.

Wenn die Tür geschlossen ist, befindet sich der Magnet neben dem Reedschalter und schließt ihn. Wenn sich die Tür öffnet, entfernt sich der Magnet, und der Schalter öffnet sich wieder.

Türsensor

Weitere Details zum Türsensor finden Sie im Tutorial ESP32 S3 - Türsensor.

Wichtige technische Daten

PunktWert
TypMagnetischer Reedschalter (Schließer)
Drähte2, ohne Polarität
Schaltabstandetwa 15 mm bis 25 mm
StromversorgungKeine. Es ist nur ein Schalter.

※ Notiz:

Die beiden Drähte haben kein Plus und kein Minus. Sie können sie beliebig herum anschließen.

Wie der ESP32 S3 die Tür liest

Der Türsensor ist nur ein Schalter, daher muss der ESP32 S3 selbst eine Spannung anlegen. Wir verwenden den internen Pull-up-Widerstand:

pinMode(DOOR_PIN, INPUT_PULLUP);

Mit INPUT_PULLUP ist der Pin HIGH, wenn ihn nichts nach unten zieht. Die Tabelle zeigt, was passiert:

TürMagnetReedschalterPin liest
GeschlossenNeben dem SchalterGeschlossen (mit GND verbunden)LOW
OffenVom Schalter entferntOffen (nichts verbunden)HIGH

Im Code also:

#define DOOR_CLOSED LOW #define DOOR_OPEN HIGH

Warum der Code 50 Millisekunden wartet

Ein Metallschalter wechselt nie sauber. In den ersten Millisekunden springt er viele Male zwischen offen und geschlossen hin und her. Das nennt man Prellen. Ohne Schutz würde eine Türbewegung fünf Fotos speichern.

Der Code wartet, bis der Wert 50 Millisekunden lang gleich bleibt:

if (reading != lastReadState) { lastReadState = reading; lastChangeTime = millis(); // the value changed, so start counting again } if (millis() - lastChangeTime >= DEBOUNCE_TIME && reading != doorState) { doorState = reading; // the value is stable now, so we believe it }

Bewegungssensor oder Türsensor?

Beide ergeben eine kleine Sicherheitskamera, aber sie sind nicht gleich:

TürsensorBewegungssensor (PIR)
ErkenntNur das Öffnen der TürJeden warmen Körper, der sich bewegt
FehlalarmeFast nieManchmal (Heizungen, Fenster, Tiere)
AufwärmzeitKeine30 bis 60 Sekunden
Braucht StromNeinJa, 5V
Funktioniert durch GlasJaNein

Ein Türsensor ist die bessere Wahl, wenn Sie über ein genaues Ereignis informiert werden möchten. Siehe auch das Tutorial ESP32 S3 Kamera - Foto auf SD-Karte speichern, wenn Bewegung erkannt wird.

Überblick über microSD Card on ESP32 S3

Das ESP32 S3 Kamera-Board hat einen microSD-Kartensteckplatz. Die Karte ist ein sehr guter Ort für Fotos, weil:

  • Ein Foto zu groß für den Speicher des ESP32 S3 ist. Die Karte kann tausende Fotos aufnehmen.
  • Die Karte die Fotos behält, wenn der Strom ausfällt.
  • Sie die Karte herausnehmen und auf Ihrem Computer lesen können.

Anforderungen an die Karte

PunktWert
KartentypmicroSD oder microSDHC
GrößeBis 32 GB funktioniert am besten
DateisystemFAT32
GeschwindigkeitsklasseClass 10 oder schneller

※ Notiz:

Eine Karte größer als 32 GB wird meist mit dem Dateisystem exFAT geliefert. Der ESP32 S3 kann exFAT nicht lesen. Formatieren Sie die Karte vor der Verwendung als FAT32.

Der Kartensteckplatz ist bereits im Board verbunden. Sie müssen ihn nicht verdrahten. Aber der Code muss die Pins kennen:

Karten-PinESP32 S3 PinBedeutung
CLKGPIO39Takt
CMDGPIO38Befehle
D0GPIO40Daten

※ Notiz:

Die Kamera verwendet die anderen Karten-Pins, daher muss der Code die Karte im 1-Bit-Modus öffnen. Das ist das Wort true in SD_MMC.begin("/sdcard", true). Mehr dazu im Tutorial ESP32 S3 Kamera - Alle paar Sekunden ein Foto auf SD-Karte speichern.

Schaltplan zwischen Türsensor und ESP32 S3

Schließen Sie die beiden Drähte des Türsensors an Ihren ESP32 S3 an.

ESP32 S3 Türsensor SD-Karte Schaltplan

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

Draht des TürsensorsESP32 S3 Pin
Erster DrahtGPIO2
Zweiter DrahtGND

Stecken Sie dann die microSD-Karte in den Steckplatz und bringen Sie die beiden Teile des Sensors an Ihrer Tür an:

  1. Bringen Sie den Teil mit den Drähten am Türrahmen an.
  2. Bringen Sie den Teil ohne Drähte an der Tür selbst an.
  3. Bewegen Sie die Tür, bis die beiden Teile nebeneinander liegen. Sie müssen sich fast berühren, mit einem Abstand kleiner als 15 mm.
  4. Richten Sie die Kamera auf die Tür.

Sicherheitshinweise

Der Türsensor braucht keinen Strom. Schließen Sie ihn nicht an 5V oder 3,3V an. Ein Draht geht an GPIO2, der andere an GND. Es kann nichts kaputtgehen, weil es nur ein Schalter ist.

Nehmen Sie die microSD-Karte niemals heraus, während das Board ein Foto schreibt. Ziehen Sie immer zuerst das USB-Kabel ab, warten Sie zwei Sekunden und nehmen Sie dann die Karte heraus.

Verwenden Sie keinen Kamera-Pin für den Sensor. Die Kamera verwendet bereits GPIO4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17 und 18. Der Kartensteckplatz verwendet GPIO38, 39 und 40. GPIO2 ist frei, also verwenden wir ihn.

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 Auswahl treffen
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:

PSRAM muss OPI PSRAM sein, und Partition Scheme muss Huge APP sein. Ändern Sie zuerst Flash Size, denn danach ändert sich die Liste der Optionen für Partition Scheme.

So programmieren Sie die Türkamera

Sie müssen keine Bibliothek installieren. SD_MMC und esp_camera sind bereits im ESP32-Boardpaket enthalten.

  • Stellen Sie den Sensor-Pin als Eingang mit Pull-up-Widerstand ein.
#define DOOR_PIN 2 pinMode(DOOR_PIN, INPUT_PULLUP);
  • Lesen Sie die Tür einmal in setup(), damit der Code den Zustand beim Start kennt.
doorState = digitalRead(DOOR_PIN); lastReadState = doorState;
  • Warten Sie in loop(), bis der Wert stabil ist, und achten Sie dann auf den Wechsel zu offen.
int reading = digitalRead(DOOR_PIN); if (reading != lastReadState) { lastReadState = reading; lastChangeTime = millis(); } if (millis() - lastChangeTime >= DEBOUNCE_TIME && reading != doorState) { doorState = reading; if (doorState == DOOR_OPEN) takeAndSavePhoto(); }

※ Notiz:

Der Code speichert nur dann ein Foto, wenn sich die Tür öffnet. Beim erneuten Schließen der Tür passiert nichts. Möchten Sie für beides ein Foto? Dann rufen Sie takeAndSavePhoto() auch im else-Teil auf.

  • Starten Sie die microSD-Karte im 1-Bit-Modus.
SD_MMC.setPins(39, 38, 40); // CLK, CMD, D0 if (!SD_MMC.begin("/sdcard", true)) { Serial.println("SD card not found"); }
  • Geben Sie jedem Foto einen anderen Namen, damit ein neues Foto nie ein altes überschreibt.
String makeFileName(int number) { char name[32]; sprintf(name, "/door_%05d.jpg", number); return String(name); }
  • Wenn das Board neu startet, beginnt der Zähler wieder bei 1. Um die alten Fotos zu behalten, suchen Sie den ersten freien Namen:
while (SD_MMC.exists(makeFileName(photoNumber))) photoNumber++;
  • Öffnen Sie eine Datei, schreiben Sie das Foto und schließen Sie die Datei.
camera_fb_t *fb = esp_camera_fb_get(); File file = SD_MMC.open("/door_00001.jpg", FILE_WRITE); file.write(fb->buf, fb->len); file.close(); esp_camera_fb_return(fb);

※ Notiz:

Sie müssen file.close() aufrufen. Wenn Sie es vergessen, bleibt das Foto im Speicher und erreicht nie die Karte.

ESP32 S3 Code

Der folgende Code speichert jedes Mal, wenn die Tür geöffnet wird, ein Foto mit dem Namen door_00001.jpg, door_00002.jpg und so weiter. Die Ruhezeit beträgt 3 Sekunden. Um sie zu ändern, ändern Sie die Zeile #define QUIET_TIME 3000.

/* * 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-save-photo-to-sd-card-when-door-opens */ #include "esp_camera.h" #include "FS.h" #include "SD_MMC.h" #define DOOR_PIN 2 // the door sensor is connected to GPIO2 #define DEBOUNCE_TIME 50 // wait 50 milliseconds, because the switch bounces #define QUIET_TIME 3000 // wait 3 seconds before the next photo (3000 milliseconds) // 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 // Pins of the microSD card slot on the board #define SD_CLK_GPIO_NUM 39 #define SD_CMD_GPIO_NUM 38 #define SD_D0_GPIO_NUM 40 int photoNumber = 1; // The door sensor is a switch: // LOW = the switch is closed = the magnet is near = the door is CLOSED // HIGH = the switch is open = the magnet is away = the door is OPEN #define DOOR_CLOSED LOW #define DOOR_OPEN HIGH int doorState = DOOR_CLOSED; int lastReadState = DOOR_CLOSED; unsigned long lastChangeTime = 0; unsigned long lastPhotoTime = 0; // 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; } bool initSDCard() { SD_MMC.setPins(SD_CLK_GPIO_NUM, SD_CMD_GPIO_NUM, SD_D0_GPIO_NUM); // true means 1-bit mode. The camera uses the other pins, so we cannot use 4-bit mode. if (!SD_MMC.begin("/sdcard", true)) { Serial.println("SD card not found. Please check the card and push it in again."); return false; } if (SD_MMC.cardType() == CARD_NONE) { Serial.println("No SD card inside the slot"); return false; } Serial.printf("SD card size: %llu MB\n", SD_MMC.cardSize() / (1024 * 1024)); return true; } // Makes a file name like /door_00001.jpg String makeFileName(int number) { char name[32]; sprintf(name, "/door_%05d.jpg", number); return String(name); } // Looks for the first free file name, so old photos are never lost void findFirstFreeNumber() { while (SD_MMC.exists(makeFileName(photoNumber))) photoNumber++; Serial.printf("The next photo will be door_%05d.jpg\n", photoNumber); } void takeAndSavePhoto() { camera_fb_t *fb = esp_camera_fb_get(); if (!fb) { Serial.println("Photo capture failed"); return; } String fileName = makeFileName(photoNumber); File file = SD_MMC.open(fileName.c_str(), FILE_WRITE); if (file) { file.write(fb->buf, fb->len); file.close(); Serial.printf("Saved %s (%u bytes)\n", fileName.c_str(), fb->len); photoNumber++; } else { Serial.printf("Cannot write the file %s\n", fileName.c_str()); } esp_camera_fb_return(fb); // give the memory back to the camera } void setup() { Serial.begin(115200); delay(1000); // INPUT_PULLUP: the pin is HIGH when the switch is open pinMode(DOOR_PIN, INPUT_PULLUP); if (!initCamera()) { Serial.println("Stopped"); while (true) delay(1000); } if (!initSDCard()) { Serial.println("Stopped"); while (true) delay(1000); } findFirstFreeNumber(); doorState = digitalRead(DOOR_PIN); lastReadState = doorState; if (doorState == DOOR_OPEN) Serial.println("Ready. The door is open now."); else Serial.println("Ready. The door is closed now."); } void loop() { int reading = digitalRead(DOOR_PIN); // The switch bounces, so we wait until the value is stable if (reading != lastReadState) { lastReadState = reading; lastChangeTime = millis(); } if (millis() - lastChangeTime >= DEBOUNCE_TIME && reading != doorState) { doorState = reading; if (doorState == DOOR_OPEN) { Serial.println("The door is open!"); if (millis() - lastPhotoTime >= QUIET_TIME) { takeAndSavePhoto(); lastPhotoTime = millis(); } else { Serial.println("Too soon after the last photo. Nothing is saved."); } } else { Serial.println("The door is closed."); } } }

Schnelle Schritte

  • Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
  • Formatieren Sie Ihre microSD-Karte auf Ihrem Computer als FAT32.
  • Ziehen Sie das USB-Kabel ab. Stecken Sie die Karte in den Steckplatz und schließen Sie die beiden Drähte des Türsensors wie in der Tabelle oben an.
  • Kopieren Sie den obigen Code und fügen Sie ihn in die Arduino IDE ein.
  • Ä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.
So öffnen Sie den Seriellen Monitor in der Arduino IDE
  • Drücken Sie einmal die Taste RESET.
  • Legen Sie die beiden Teile des Sensors nebeneinander. Der Serielle Monitor meldet, dass die Tür geschlossen ist.
  • Bewegen Sie die beiden Teile voneinander weg, wie bei einer sich öffnenden Tür.
  • Sehen Sie sich den Seriellen Monitor an. Sie sehen The door is open! und den Namen des Fotos.
  • Ziehen Sie das USB-Kabel ab, nehmen Sie die Karte heraus und sehen Sie sich die Fotos auf Ihrem Computer an.

Serieller Monitor

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 15:00:01] Camera sensor: OV5640 (5 MP, max QSXGA 2592x1944) [2026-09-23 15:00:01] SD card size: 15193 MB [2026-09-23 15:00:01] The next photo will be door_00001.jpg [2026-09-23 15:00:01] Ready. The door is closed now. [2026-09-23 15:01:12] The door is open! [2026-09-23 15:01:13] Saved /door_00001.jpg (184320 bytes) [2026-09-23 15:01:31] The door is closed. [2026-09-23 15:02:05] The door is open! [2026-09-23 15:02:06] Saved /door_00002.jpg (183104 bytes)
Ln 11, Col 1
ESP32S3 Dev Module on COM15
2

Wenn die Tür zu schnell wieder geöffnet wird, meldet der Code das und speichert nichts:

∞
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 15:02:08] The door is open! [2026-09-23 15:02:08] Too soon after the last photo. Nothing is saved.
Ln 11, Col 1
ESP32S3 Dev Module on COM15
2

Fehlerbehebung

Der Serielle Monitor meldet immer, dass die Tür offen ist, auch wenn sie geschlossen ist.

  • Die beiden Teile sind zu weit voneinander entfernt. Sie müssen sich fast berühren, mit einem Abstand kleiner als 15 mm.
  • Prüfen Sie den Draht an GPIO2 und den Draht an GND.
  • Manche Türsensoren sind "Öffner" statt "Schließer". Dann müssen die beiden Zeilen #define DOOR_CLOSED LOW und #define DOOR_OPEN HIGH ihre Werte tauschen.

Der Serielle Monitor meldet immer, dass die Tür geschlossen ist.

Die beiden Drähte berühren sich wahrscheinlich, oder ein Draht ist am falschen Pin. Ein Draht geht an GPIO2, der andere an GND.

Eine Türbewegung speichert zwei oder drei Fotos.

Erhöhen Sie DEBOUNCE_TIME von 50 auf 150.

Der Serielle Monitor zeigt SD card not found.

Formatieren Sie die Karte als FAT32, verwenden Sie eine Karte mit 32 GB oder weniger und stecken Sie die Karte erneut ein. Sie können auch die drei Pinnummern oben im Code mit der Zeichnung Ihres Boards vergleichen.

Der Serielle Monitor zeigt No SD card inside the slot.

Das Board hat den Steckplatz gefunden, aber keine Karte. Stecken Sie die Karte erneut ein oder probieren Sie eine andere Karte.

Der Serielle Monitor zeigt Cannot write the file.

Die Karte ist voll, gesperrt oder defekt. Prüfen Sie den freien Speicherplatz auf Ihrem Computer.

Das Foto ist dunkel.

Die Kamera kann im Dunkeln nicht sehen. Bringen Sie ein Licht in der Nähe der Tür an, oder eine Lampe, die sich mit der Tür einschaltet.

Der Serielle Monitor zeigt nach den Startmeldungen nichts an.

Wenn Ihr USB-Kabel im Anschluss mit dem Namen UART steckt, stellen Sie USB CDC On Boot auf Disabled. Wenn es im Anschluss mit dem Namen USB steckt, stellen Sie es auf Enabled.

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

Stellen Sie PSRAM im Menü Tools auf OPI PSRAM und prüfen Sie das Flachbandkabel der Kamera.

Anwendungen

Ein Türsensor liefert Ihnen ein eindeutiges Ereignis mit fast keinen Fehlalarmen, und die microSD-Karte bedeutet kein WLAN, kein Internet und keine monatlichen Kosten. Hier sind praktische Projekte, die Sie mit diesem Code bauen können:

  1. Offline-Haustürkamera: Sehen Sie, wer Ihre Haustür geöffnet hat, während Sie weg waren, ganz ohne Internetverbindung.
  2. Paketbox-Kamera: Bewahren Sie ein Foto der Person auf, die Ihre Paketbox oder Ihren Briefkasten öffnet.
  3. Protokoll für Werkzeugkasten, Tresor oder Spind: Erhalten Sie jedes Mal ein Bild, wenn jemand ihn öffnet, auch an einem Ort ohne WLAN.
  4. Garagen- und Schuppenkamera: Erfahren Sie, wer nachts Ihr Garagentor geöffnet hat.
  5. Medizinschrank-Beobachter: Bewahren Sie ein Foto auf, wenn ein Kind einen Schrank öffnet, der geschlossen bleiben muss.
  6. Serverschrank und Schaltschrank: Führen Sie ein Fotoprotokoll aller Personen, die bei der Arbeit einen Schrank öffnen.
  7. Türkamera für das Ferienhaus: Lassen Sie sie wochenlang in einem leeren Haus und lesen Sie die Karte, wenn Sie zurückkommen.
  8. Protokoll für Fensteröffnungen: Bringen Sie den Sensor an einem Fenster statt an einer Tür an.
  9. Kamera für Hoftor oder Scheune: Überwachen Sie eine Tür weit weg von jedem Router.
  10. Ladentür-Zähler mit Fotos: Bewahren Sie ein Bild jedes Kunden auf, der die Tür öffnet.

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

  1. Einsteiger: Speichern Sie auch ein Foto, wenn die Tür wieder geschlossen wird, sodass Sie ein Bild von beiden Momenten haben.
  2. Fortgeschrittene: Schreiben Sie eine Textdatei auf die Karte mit einer Zeile pro Ereignis, zum Beispiel dem Fotonamen und der Zeit seit dem Start des Boards.
  3. Profis: Fügen Sie eine Echtzeituhr (RTC) hinzu und schreiben Sie das echte Datum und die Uhrzeit in den Dateinamen, zum Beispiel /2026-09-23_14-05-31.jpg.

※ 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!