CAPTEURS/ACTIONNEURS

Caméra ESP32 S3 - Enregistrer une photo sur carte SD à l'ouverture de la porte

Ce tutoriel vous explique comment construire une caméra de porte avec l'ESP32 S3. Un capteur de porte magnétique surveille votre porte. Dès que quelqu'un l'ouvre, l'ESP32 S3 prend une photo et l'enregistre sur une carte microSD. La carte fonctionne seule. Elle n'a besoin ni de WiFi, ni d'un ordinateur.

Ce que vous allez construire :

Une caméra ESP32 S3 avec un capteur de porte magnétique
Une photo enregistrée sur la carte microSD à chaque ouverture de la porte
Une détection propre, si bien qu'un mouvement de porte enregistre exactement une photo
Une caméra de porte qui fonctionne sans aucun internet

Matériel requis

1	×	ESP32 S3 N16R8 OV5640 Camera
1	×	Alternativement: ESP32 S3 N16R8 OV2640 Camera
1	×	Câble USB Type-A vers Type-C (pour PC USB-A)
1	×	Câble USB Type-C vers Type-C (pour PC USB-C)
1	×	Capteur de porte
1	×	microSD Card
1	×	Fils de connexion
1	×	Optionnel: Connecteur d'alimentation DC
1	×	Recommandé: Screw Terminal Expansion Board for ESP32 S3
1	×	Recommandé: Breakout Expansion Board for ESP32 S3
1	×	Recommandé: Power Splitter for ESP32 S3

Ou vous pouvez acheter les kits suivants:

Kit de Capteurs DIYables (18 capteurs/écrans)

Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.

※ Note:

La carte caméra ESP32 S3 a 40 broches, mais le bornier à vis et la carte d'extension ont 44 broches. Elles fonctionnent quand même ensemble. Placez la carte caméra au centre de la carte 44 broches, de sorte que 2 broches restent libres du côté gauche et 2 broches restent libres du côté droit.

Le bornier à vis vous permet de connecter des fils avec un tournevis, sans soudure. La carte d'extension vous donne des broches faciles à utiliser pour une breadboard.

À propos du capteur de porte

Un capteur de porte comporte deux parties :

Un petit boîtier en plastique avec deux fils. Cette partie contient un interrupteur à lame souple (reed switch). Vous la placez sur le cadre de la porte.
Un second boîtier en plastique sans fils. Cette partie contient un aimant. Vous la placez sur la porte elle-même.

Lorsque la porte est fermée, l'aimant se trouve à côté de l'interrupteur à lame souple et le ferme. Lorsque la porte s'ouvre, l'aimant s'éloigne, et l'interrupteur s'ouvre à nouveau.

Pour plus de détails sur le capteur de porte, consultez le tutoriel ESP32 S3 - Capteur de Porte.

Spécifications clés

Élément	Valeur
Type	Interrupteur à lame souple magnétique (normalement ouvert)
Fils	2, sans polarité
Écart de fonctionnement	environ 15 mm à 25 mm
Alimentation	Aucune. Ce n'est qu'un interrupteur.

※ Note:

Les deux fils n'ont ni plus ni moins. Vous pouvez les connecter dans n'importe quel sens.

Comment l'ESP32 S3 lit la porte

Le capteur de porte n'est qu'un interrupteur, l'ESP32 S3 doit donc lui fournir lui-même une tension. Nous utilisons la résistance de tirage interne (pull-up) :

pinMode(DOOR_PIN, INPUT_PULLUP);

Avec INPUT_PULLUP, la broche est à l'état HIGH lorsque rien ne la tire vers le bas. Le tableau montre ce qui se passe :

Porte	Aimant	Interrupteur à lame souple	La broche lit
Fermée	À côté de l'interrupteur	Fermé (connecté à GND)	LOW
Ouverte	Éloigné de l'interrupteur	Ouvert (rien de connecté)	HIGH

Donc dans le code :

#define DOOR_CLOSED LOW #define DOOR_OPEN HIGH

Pourquoi le code attend 50 millisecondes

Un interrupteur métallique ne change jamais proprement d'état. Dans les premières millisecondes, il bascule plusieurs fois entre ouvert et fermé. C'est ce qu'on appelle le rebond (bouncing). Sans protection, un seul mouvement de porte enregistrerait cinq photos.

Le code attend que la valeur reste la même pendant 50 millisecondes :

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 }

Capteur de mouvement ou capteur de porte ?

Les deux permettent de construire une petite caméra de sécurité, mais ils ne sont pas identiques :

	Capteur de porte	Capteur de mouvement (PIR)
Détecte	Seulement l'ouverture de la porte	Tout corps chaud qui bouge
Fausses alarmes	Presque jamais	Parfois (radiateurs, fenêtres, animaux)
Temps de préchauffage	Aucun	30 à 60 secondes
Besoin d'alimentation	Non	Oui, 5V
Fonctionne à travers le verre	Oui	Non

Un capteur de porte est le meilleur choix lorsque vous voulez connaître un événement précis. Voir aussi le tutoriel Caméra ESP32 S3 - Enregistrer une photo sur carte SD lors d'une détection de mouvement.

À propos de la carte microSD sur l'ESP32 S3

La carte caméra ESP32 S3 dispose d'un emplacement pour carte microSD. La carte est un très bon endroit pour les photos, car :

Une photo est trop volumineuse pour la mémoire de l'ESP32 S3. La carte peut contenir des milliers de photos.
La carte conserve les photos même en cas de coupure de courant.
Vous pouvez retirer la carte et la lire sur votre ordinateur.

Exigences de la carte

Élément	Valeur
Type de carte	microSD ou microSDHC
Taille	Jusqu'à 32 Go, c'est ce qui fonctionne le mieux
Système de fichiers	FAT32
Classe de vitesse	Classe 10 ou plus rapide

※ Note:

Une carte de plus de 32 Go est généralement fournie avec le système de fichiers exFAT. L'ESP32 S3 ne peut pas lire l'exFAT. Formatez la carte en FAT32 avant de l'utiliser.

L'emplacement de la carte est déjà connecté à l'intérieur de la carte. Vous n'avez pas besoin de le câbler. Mais le code doit connaître les broches :

Broche de la carte	Broche ESP32 S3	Signification
CLK	GPIO39	Horloge
CMD	GPIO38	Commandes
D0	GPIO40	Données

※ Note:

La caméra utilise les autres broches de la carte, donc le code doit ouvrir la carte en mode 1 bit. C'est le mot true dans SD_MMC.begin("/sdcard", true). Apprenez-en plus dans le tutoriel Caméra ESP32 S3 - Enregistrer une Photo sur Carte SD Toutes les Quelques Secondes.

Schéma de câblage entre le capteur de porte et l'ESP32 S3

Connectez les deux fils du capteur de porte à votre ESP32 S3.

Schéma de câblage capteur de porte et carte SD ESP32 S3

Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.

Fil du capteur de porte	Broche ESP32 S3
Premier fil	GPIO2
Second fil	GND

Ensuite, insérez la carte microSD dans l'emplacement, et placez les deux parties du capteur sur votre porte :

Placez la partie avec les fils sur le cadre de la porte.
Placez la partie sans fils sur la porte elle-même.
Déplacez la porte jusqu'à ce que les deux parties soient l'une à côté de l'autre. Elles doivent presque se toucher, avec un écart inférieur à 15 mm.
Orientez la caméra vers la porte.

Notes de sécurité

Le capteur de porte n'a besoin d'aucune alimentation. Ne le connectez pas au 5V ni au 3.3V. Un fil va à GPIO2, l'autre va à GND. Rien ne peut casser, car ce n'est qu'un interrupteur.

Ne retirez jamais la carte microSD pendant que la carte écrit une photo. Débranchez toujours d'abord le câble USB, attendez deux secondes, puis retirez la carte.

N'utilisez pas une broche de la caméra pour le capteur. La caméra utilise déjà les broches GPIO4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17 et 18. L'emplacement de la carte utilise les broches GPIO38, 39 et 40. GPIO2 est libre, nous l'utilisons donc.

Réglages de l'Arduino IDE pour la caméra ESP32 S3

La caméra ne fonctionne pas avec les réglages par défaut de l'Arduino IDE. Vous devez modifier certains éléments dans le menu Tools avant de téléverser le code.

Élément du menu Tools	Sélectionnez ceci
Board	ESP32S3 Dev Module
Flash Size	16MB (128Mb)
PSRAM	OPI PSRAM
Partition Scheme	Huge APP (3MB No OTA/1MB SPIFFS)
CPU Frequency	240MHz (WiFi)
USB Mode	Hardware CDC and JTAG
Upload Mode	UART0 / Hardware CDC
Upload Speed	921600
USB CDC On Boot	Enabled

※ Note:

PSRAM doit être réglé sur OPI PSRAM, et Partition Scheme doit être Huge APP. Changez d'abord Flash Size, car la liste des options de Partition Scheme change ensuite.

Comment programmer la caméra de porte

Vous n'avez besoin d'installer aucune bibliothèque. SD_MMC et esp_camera sont déjà inclus dans le package de carte ESP32.

Configurez la broche du capteur comme entrée avec une résistance de tirage (pull-up).

#define DOOR_PIN 2 pinMode(DOOR_PIN, INPUT_PULLUP);

Lisez l'état de la porte une fois dans setup(), afin que le code connaisse l'état au démarrage.

doorState = digitalRead(DOOR_PIN); lastReadState = doorState;

Dans loop(), attendez que la valeur soit stable, puis recherchez le changement vers l'état ouvert.

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(); }

※ Note:

Le code enregistre une photo uniquement lorsque la porte s'ouvre. Rien ne se passe lorsque la porte se referme. Vous voulez une photo dans les deux cas ? Appelez alors takeAndSavePhoto() dans la partie else également.

Démarrez la carte microSD en mode 1 bit.

SD_MMC.setPins(39, 38, 40); // CLK, CMD, D0 if (!SD_MMC.begin("/sdcard", true)) { Serial.println("SD card not found"); }

Donnez à chaque photo un nom différent, afin qu'une nouvelle photo n'écrase jamais une ancienne.

String makeFileName(int number) { char name[32]; sprintf(name, "/door_%05d.jpg", number); return String(name); }

Lorsque la carte redémarre, le compteur repart à 1. Pour conserver les anciennes photos, recherchez le premier nom libre :

while (SD_MMC.exists(makeFileName(photoNumber))) photoNumber++;

Ouvrez un fichier, écrivez la photo, puis fermez le fichier.

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);

※ Note:

Vous devez appeler file.close(). Si vous l'oubliez, la photo reste en mémoire et n'atteint jamais la carte.

Code ESP32 S3

Le code suivant enregistre une photo nommée door_00001.jpg, door_00002.jpg, et ainsi de suite, à chaque ouverture de la porte. Le temps de silence est de 3 secondes. Pour le modifier, changez la ligne #define QUIET_TIME 3000.

/* * Ce code ESP32 S3 a été développé par newbiely.fr * Ce code ESP32 S3 est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/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."); } } }

Étapes rapides

Nouveau sur ESP32 S3 ? Suivez d'abord notre guide ESP32 S3 - Premiers pas.
Formatez votre carte microSD en FAT32 sur votre ordinateur.
Débranchez le câble USB. Insérez la carte dans l'emplacement, et connectez les deux fils du capteur de porte comme indiqué dans le tableau ci-dessus.
Copiez le code ci-dessus et collez-le dans l'Arduino IDE.
Modifiez les réglages dans le menu Tools. Voir le tableau ci-dessus.
Compilez et téléversez le code vers la carte ESP32 S3 en cliquant sur le bouton Upload dans l'Arduino IDE.

Ouvrez le moniteur série dans l'Arduino IDE.

Appuyez une fois sur le bouton RESET.
Placez les deux parties du capteur l'une à côté de l'autre. Le moniteur série indique que la porte est fermée.
Éloignez les deux parties l'une de l'autre, comme une porte qui s'ouvre.
Regardez le moniteur série. Vous voyez The door is open! et le nom de la photo.
Débranchez le câble USB, retirez la carte, et lisez les photos sur votre ordinateur.

Moniteur série

Les relevés suivants ont été capturés en 2026 :

Newbiely | Arduino IDE 2.3.8

──

☐

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

Lorsque la porte est ouverte à nouveau trop vite, le code le signale et n'enregistre rien :

Newbiely | Arduino IDE 2.3.8

──

☐

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

Dépannage

Le moniteur série indique toujours que la porte est ouverte, même quand elle est fermée.

Les deux parties sont trop éloignées l'une de l'autre. Elles doivent presque se toucher, avec un écart inférieur à 15 mm.
Vérifiez le fil sur GPIO2 et le fil sur GND.
Certains capteurs de porte sont "normalement fermés" au lieu de "normalement ouverts". Dans ce cas, les deux lignes #define DOOR_CLOSED LOW et #define DOOR_OPEN HIGH doivent échanger leurs valeurs.

Le moniteur série indique toujours que la porte est fermée.

Les deux fils se touchent probablement, ou un fil est sur la mauvaise broche. Un fil va à GPIO2, l'autre à GND.

Un mouvement de porte enregistre deux ou trois photos.

Augmentez DEBOUNCE_TIME de 50 à 150.

Le moniteur série affiche SD card not found.

Formatez la carte en FAT32, utilisez une carte de 32 Go ou moins, et repoussez la carte dans son emplacement. Vous pouvez aussi vérifier les trois numéros de broches en haut du code par rapport au schéma de votre carte.

Le moniteur série affiche No SD card inside the slot.

La carte a trouvé l'emplacement mais pas de carte. Repoussez la carte, ou essayez une autre carte.

Le moniteur série affiche Cannot write the file.

La carte est pleine, verrouillée ou endommagée. Vérifiez l'espace libre sur votre ordinateur.

La photo est sombre.

La caméra ne voit pas dans l'obscurité. Ajoutez une lumière près de la porte, ou une lampe qui s'allume avec la porte.

Le moniteur série n'affiche rien après les messages de démarrage.

Si votre câble USB est branché sur le port nommé UART, réglez USB CDC On Boot sur Disabled. S'il est branché sur le port nommé USB, réglez-le sur Enabled.

Le moniteur série affiche Camera init failed with error 0x105.

Réglez PSRAM sur OPI PSRAM dans le menu Tools, et vérifiez le câble plat de la caméra.

Applications

Un capteur de porte vous donne un événement clair avec presque aucune fausse alarme, et la carte microSD signifie pas de WiFi, pas d'internet et pas de paiement mensuel. Voici des projets pratiques que vous pouvez construire avec ce code :

Caméra de porte d'entrée hors ligne : Voyez qui a ouvert votre porte d'entrée pendant votre absence, sans aucune connexion internet.
Caméra de boîte à colis : Gardez une photo de la personne qui ouvre votre boîte à colis ou votre boîte aux lettres.
Enregistrement de boîte à outils, coffre-fort ou casier : Obtenez une image à chaque ouverture, même dans un endroit sans WiFi.
Caméra de garage et d'abri de jardin : Sachez qui a ouvert votre porte de garage la nuit.
Surveillance d'armoire à pharmacie : Gardez une photo quand un enfant ouvre une armoire qui doit rester fermée.
Baie de serveurs et armoire de contrôle : Gardez un enregistrement photo de tous ceux qui ouvrent une armoire au travail.
Caméra de porte de maison de vacances : Laissez-la dans une maison vide pendant des semaines, et lisez la carte à votre retour.
Enregistrement d'ouverture de fenêtre : Placez le capteur sur une fenêtre au lieu d'une porte.
Caméra de portail de ferme ou de grange : Surveillez une porte loin de tout routeur.
Compteur de porte de magasin avec photos : Gardez une photo de chaque client qui ouvre la porte.

Vidéo

Regardez le tutoriel vidéo étape par étape pour ce projet ESP32 S3 ci-dessous.

Défis

Débutant : Enregistrez aussi une photo lorsque la porte se referme, afin d'avoir une image des deux moments.
Intermédiaire : Écrivez un fichier texte sur la carte avec une ligne par événement, par exemple le nom de la photo et le temps écoulé depuis le démarrage de la carte.
Avancé : Ajoutez une horloge temps réel (RTC) et insérez la date et l'heure réelles dans le nom du fichier, par exemple /2026-09-23_14-05-31.jpg.

Références du langage

Commentaires

Tutoriels connexes

※ NOS MESSAGES

N'hésitez pas à partager le lien de ce tutoriel. Cependant, veuillez ne pas utiliser notre contenu sur d'autres sites web. Nous avons investi beaucoup d'efforts et de temps pour créer ce contenu, veuillez respecter notre travail !