CAPTEURS/ACTIONNEURS

Caméra ESP32 S3 - Enregistrer une Photo sur Carte SD Toutes les Quelques Secondes

Ce tutoriel vous explique comment faire une caméra ESP32 S3 qui prend une photo toutes les quelques secondes et l'enregistre sur une carte microSD. La carte fonctionne seule. Elle n'a pas besoin de WiFi, et elle n'a pas besoin d'ordinateur. Vous lui donnez juste de l'alimentation, et elle remplit la carte de photos.

Ce que vous allez construire :

Une caméra ESP32 S3 qui prend une photo toutes les 30 secondes
Des photos enregistrées sur une carte microSD sous les noms photo_00001.jpg, photo_00002.jpg, etc.
Un code qui n'écrase jamais vos anciennes photos, même après un redémarrage de la carte
Une caméra time-lapse que vous pouvez laisser seule pendant des heures

Matériel Requis

1	×	ESP32 S3 N16R8 OV5640 Camera
1	×	Alternativement: ESP32 S3 N16R8 OV2640 Camera
1	×	microSD Card
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	×	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 à gauche et 2 broches restent libres à droite.

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

À propos de la Carte microSD sur ESP32 S3

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

Une photo est trop grande pour la mémoire de l'ESP32 S3. La carte peut contenir des milliers de photos.
La carte garde les photos même quand l'alimentation s'éteint.
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 fonctionne le mieux
Système de fichiers	FAT32
Classe de vitesse	Classe 10 ou plus rapide

※ Note:

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

Mode 1 Bit et Mode 4 Bits

Une carte microSD peut communiquer avec l'ESP32 S3 de deux façons :

Mode	Broches de données	Vitesse	Pouvons-nous l'utiliser ?
4 bits	4 broches	Rapide	Non. La caméra utilise déjà ces broches.
1 bit	1 broche	Plus lent	Oui. C'est ce que nous utilisons.

Le mode 1 bit est plus lent, mais il est assez rapide. Une photo de 200 Ko est enregistrée en moins d'une seconde.

Le code active le mode 1 bit avec le mot true :

SD_MMC.begin("/sdcard", true); // true means 1-bit mode

Les Broches de l'Emplacement de Carte

L'emplacement de 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:

Différentes cartes utilisent différentes broches pour l'emplacement de carte. Si votre carte n'est pas trouvée, regardez le schéma de votre carte et changez les trois lignes SD_CLK_GPIO_NUM, SD_CMD_GPIO_NUM et SD_D0_GPIO_NUM en haut du code.

Schéma de Câblage

Il n'y a pas de câblage dans ce projet. Vous insérez seulement la carte microSD dans l'emplacement.

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

Débranchez le câble USB.
Assurez-vous que le module caméra est connecté avec son câble plat.
Poussez la carte microSD dans l'emplacement jusqu'à entendre un petit clic.
Branchez le câble USB.

Notes de Sécurité

Ne retirez jamais la carte pendant que la carte enregistre une photo. La photo, et parfois toute la carte, devient corrompue. Débranchez toujours d'abord le câble USB, attendez deux secondes, puis retirez la carte.

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 changer 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 OPI PSRAM, et Partition Scheme doit être Huge APP. Changez d'abord Flash Size, car la liste des options de Partition Scheme change après cela.

Comment Enregistrer une Photo sur la Carte SD

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

Incluez les deux fichiers en haut de votre code.

#include "FS.h" #include "SD_MMC.h"

Indiquez à la bibliothèque quelles broches utilise l'emplacement de carte, puis démarrez la carte 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"); }

Vérifiez qu'une carte est vraiment présente dans l'emplacement.

if (SD_MMC.cardType() == CARD_NONE) { Serial.println("No SD card inside the slot"); }

Ouvrez un fichier, écrivez la photo, et fermez le fichier. La photo se trouve dans fb->buf, et sa taille se trouve dans fb->len.

camera_fb_t *fb = esp_camera_fb_get(); File file = SD_MMC.open("/photo.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 dans la mémoire et n'atteint jamais la carte.

Donnez à chaque photo un nom différent, sinon la nouvelle photo écrase l'ancienne.

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

%05d signifie « écrire le nombre avec 5 chiffres ». Ainsi les noms sont photo_00001.jpg, photo_00002.jpg, ... Votre ordinateur affiche alors les photos dans le bon ordre.

Quand la carte redémarre, le compteur recommence à 1. Pour garder les anciennes photos, cherchez le premier nom libre :

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

Utilisez millis() pour attendre entre deux photos. N'utilisez pas delay(), car delay() arrête tout.

if (millis() - lastPhotoTime >= PHOTO_INTERVAL) { lastPhotoTime = millis(); takeAndSavePhoto(); }

Code ESP32 S3

Le code suivant prend une photo toutes les 30 secondes et l'enregistre sur la carte microSD. Pour changer le temps, changez la ligne #define PHOTO_INTERVAL 30000. Le nombre est en millisecondes, donc 30000 veut dire 30 secondes.

/* * 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-every-few-seconds */ #include "esp_camera.h" #include "FS.h" #include "SD_MMC.h" #define PHOTO_INTERVAL 30000 // take one photo every 30 seconds (30000 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; 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 /photo_00001.jpg String makeFileName(int number) { char name[32]; sprintf(name, "/photo_%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 photo_%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); if (!initCamera()) { Serial.println("Stopped"); while (true) delay(1000); } if (!initSDCard()) { Serial.println("Stopped"); while (true) delay(1000); } findFirstFreeNumber(); takeAndSavePhoto(); // take the first photo now lastPhotoTime = millis(); } void loop() { if (millis() - lastPhotoTime >= PHOTO_INTERVAL) { lastPhotoTime = millis(); takeAndSavePhoto(); } }

Étapes Rapides

Nouveau sur ESP32 S3 ? Terminez d'abord notre guide ESP32 S3 - Premiers pas.
Formatez votre carte microSD en FAT32 sur votre ordinateur.
Débranchez le câble USB, puis insérez la carte dans l'emplacement sur la carte.
Copiez le code ci-dessus et collez-le dans l'Arduino IDE.
Changez les réglages dans le menu Tools. Voir le tableau ci-dessus.
Compilez et téléversez le code sur la carte ESP32 S3 en cliquant sur le bouton Upload dans l'Arduino IDE.

Ouvrez le Serial Monitor dans l'Arduino IDE.

Appuyez une fois sur le bouton RESET de la carte.
Attendez quelques minutes. Pointez la caméra vers quelque chose qui change, par exemple une plante ou une fenêtre.
Débranchez le câble USB, retirez la carte, et lisez-la sur votre ordinateur.
Astuce : Une vidéo time-lapse est faite à partir de ces photos. Beaucoup de programmes gratuits peuvent joindre les photos en une seule vidéo.

Serial Monitor

Le Serial Monitor vous indique le nom et la taille de chaque photo. 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 11:00:01] Camera sensor: OV5640 (5 MP, max QSXGA 2592x1944) [2026-09-23 11:00:01] SD card size: 15193 MB [2026-09-23 11:00:01] The next photo will be photo_00001.jpg [2026-09-23 11:00:02] Saved /photo_00001.jpg (184320 bytes) [2026-09-23 11:00:32] Saved /photo_00002.jpg (183104 bytes) [2026-09-23 11:01:02] Saved /photo_00003.jpg (185876 bytes) [2026-09-23 11:01:32] Saved /photo_00004.jpg (182992 bytes)

Ln 11, Col 1

ESP32S3 Dev Module on COM15

Quand vous redémarrez la carte, le compteur ne recommence pas à 1. Il continue après votre dernière photo :

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 11:05:00] The next photo will be photo_00005.jpg [2026-09-23 11:05:01] Saved /photo_00005.jpg (184028 bytes)

Ln 11, Col 1

ESP32S3 Dev Module on COM15

Combien de Photos Tiennent sur la Carte ?

Une photo en 1600×1200 fait environ 180 Ko. Ce tableau vous aide à planifier :

Taille de la Carte	Nombre de Photos	Une photo toutes les 30 secondes dure
8 Go	environ 44 000	environ 15 jours
16 Go	environ 88 000	environ 30 jours
32 Go	environ 177 000	environ 61 jours

※ Note:

Vous voulez des photos plus petites ? Changez config.frame_size en FRAMESIZE_SVGA (800×600). Une photo fait alors environ 50 Ko, donc la carte contient quatre fois plus de photos.

Dépannage

Le Serial Monitor affiche SD card not found.

Essayez ceci, un par un :

Repoussez la carte jusqu'à entendre un clic.
Formatez la carte en FAT32, pas exFAT et pas NTFS.
Utilisez une carte de 32 Go ou moins.
Vérifiez les trois numéros de broches en haut du code par rapport au schéma de votre carte.

Le Serial Monitor affiche No SD card inside the slot.

La carte a trouvé l'emplacement mais pas de carte. Repoussez la carte. Essayez aussi une autre carte, car les vieilles cartes échouent souvent.

Le Serial Monitor affiche Cannot write the file.

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

Les photos sont toutes noires ou toutes blanches.

La caméra a besoin d'un moment pour la lumière. Augmentez PHOTO_INTERVAL, et assurez-vous que la pièce n'est pas trop sombre.

Le Serial Monitor n'affiche rien après les messages de démarrage.

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

Le Serial Monitor 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

Une caméra qui prend une photo toutes les quelques secondes et l'enregistre sur une carte est le moyen le plus simple de faire une vidéo time-lapse, et elle n'a pas besoin de WiFi. Voici des projets pratiques que vous pouvez construire avec ce code :

Time-lapse de croissance de plante : Une photo toutes les heures montre une fleur s'ouvrant en quelques secondes de vidéo.
Journal de chantier : Gardez une image du travail de chaque jour, et montrez-la à votre client.
Time-lapse du ciel et de la météo : Photographiez le ciel toute la journée et regardez les nuages bouger.
Time-lapse d'imprimante 3D : Enregistrez une longue impression et faites-en une courte vidéo.
Journal de magasin et de bureau : Gardez un enregistrement photo de la pièce sans connexion internet.
Projet de sciences scolaire : Observez de la glace fondre, du pain lever, une bougie brûler, ou une graine pousser.
Vidéo de lever et coucher du soleil : Laissez la caméra à une fenêtre toute la journée et joignez les photos en une vidéo.
Observateur d'aquarium et de terrarium : Voyez ce que fait votre poisson ou votre reptile quand personne n'est dans la pièce.
Étude de route et de trafic : Comptez les voitures qui passent dans votre rue pendant une journée.
Test de machine longue durée : Gardez une photo d'une machine toutes les 30 secondes, pour pouvoir trouver le moment où elle a échoué.

Vidéo

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

Défis

Débutant : Changez le temps entre les photos de 30 secondes à 5 secondes, puis à 5 minutes.
Intermédiaire : Enregistrez les photos dans des dossiers, un dossier par jour, par exemple /2026-09-23/photo_00001.jpg.
Avancé : Ajoutez une horloge temps réel (RTC) et mettez la vraie date et l'heure dans le nom du fichier.

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 !