CAPTEURS/ACTIONNEURS

Caméra ESP32 S3 - Économiser la batterie avec le mode veille profonde

Tous les autres projets de caméra ont besoin d'un câble USB en permanence. Ce tutoriel est différent. L'ESP32 S3 dort et n'utilise presque pas d'énergie. Quand le capteur de mouvement détecte quelqu'un, la carte se réveille, prend une photo, l'enregistre sur la carte microSD, puis se rendort. Comme la carte n'est éveillée que pendant environ deux secondes à chaque fois, elle consomme très peu d'énergie, ce qui vous permet de l'alimenter avec une batterie et de placer la caméra à un portail, dans un jardin, ou sur une boîte à colis.

Ce que vous allez construire :

Une caméra qui dort jusqu'à ce qu'il se passe quelque chose
Une photo enregistrée sur la carte microSD à chaque réveil
Un compteur qui survit à la veille profonde, afin que les numéros de photo ne recommencent jamais à 1
Une caméra qui fonctionne sur batterie ou sur batterie externe, sans câble

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 mouvement HC-SR501
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 possède 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, afin qu'il reste 2 broches libres du côté gauche et 2 broches 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 connecteurs à broches faciles à utiliser pour une breadboard.

Comment ça fonctionne

Tous les autres projets de caméra tournent en boucle : la carte est éveillée en permanence, et elle demande encore et encore si quelque chose s'est produit. C'est simple, mais cela consomme de l'énergie toute la journée pour rien.

Ce projet renverse l'idée. La carte dort, et le capteur la réveille.

Voici toute la vie de la caméra :

Étape	Ce qui se passe	Durée	Énergie
1	La carte dort. Seule une petite partie à l'intérieur surveille une broche.	Des heures, ou des jours	Presque aucune
2	Quelqu'un passe. Le capteur PIR met la broche GPIO21 à HIGH.	Immédiatement	Aucune, le capteur n'est pas la carte
3	Ce HIGH réveille la carte. Elle redémarre depuis le début, comme après un RESET.	Environ 1 seconde	Pleine
4	La caméra et la carte mémoire démarrent. La carte prend une photo et l'écrit sur la carte mémoire.	Environ 1 seconde	Pleine
5	La carte éteint la caméra et la carte mémoire, puis se rendort.	Immédiatement	Retour à presque aucune

Comment fonctionne la caméra ESP32 S3 en veille profonde

Ainsi, la carte n'est éveillée que pendant environ deux secondes pour chaque visiteur. Tout le reste du temps, elle dort. C'est toute l'astuce, et c'est pourquoi cette caméra peut fonctionner sans câble.

※ Note:

Le capteur PIR ne dort jamais. Il surveille la pièce en permanence, et il n'utilise qu'un tout petit courant pour le faire. Le capteur est la partie qui décide quand la carte est nécessaire.

Trois choses le font fonctionner

Quoi	Pourquoi c'est nécessaire
esp_sleep_enable_ext0_wakeup()	Indique à la carte quelle broche peut la réveiller, et à quel niveau
RTC_DATA_ATTR	Garde le compteur de photos en vie pendant le sommeil. Les variables normales perdent leur valeur.
esp_camera_deinit() et SD_MMC.end()	Éteignent la caméra et la carte mémoire, afin qu'elles ne consomment rien pendant le sommeil

Chacun de ces points est expliqué ci-dessous.

À propos de la veille profonde

La veille profonde (deep sleep) éteint presque tout à l'intérieur de l'ESP32 S3 : les deux processeurs, le WiFi et la mémoire. Seule une toute petite partie reste éveillée, et son seul rôle est de surveiller une broche.

État	Ce qui fonctionne	Courant utilisé
Normal, WiFi activé	Tout	environ 150 mA
Normal, WiFi désactivé	Deux processeurs	environ 40 mA
Veille profonde	Presque rien	moins de 1 mA

※ Note:

Ces chiffres sont indicatifs, pas une promesse. Votre carte, votre capteur et votre batterie externe changent tous le résultat. De nombreuses batteries externes s'éteignent d'elles-mêmes quand le courant est très faible, ce qui est le problème le plus courant dans les projets sur batterie.

La carte redémarre à chaque fois

C'est la partie qui surprend tout le monde : après une veille profonde, la carte ne continue pas là où elle s'était arrêtée. Elle redémarre depuis le tout début, exactement comme après un RESET. setup() s'exécute à nouveau, et loop() ne s'exécute jamais.

Donc tout le programme vit à l'intérieur de setup() :

void setup() { // wake up, take the photo, save it goToSleep(); // this line never returns } void loop() { // Empty. This board never reaches loop(). }

Comment se souvenir de quelque chose pendant le sommeil

Les variables normales perdent leur valeur pendant la veille profonde. Les variables marquées RTC_DATA_ATTR ne la perdent pas, car elles vivent dans la petite partie qui reste éveillée :

RTC_DATA_ATTR int photoNumber = 1; RTC_DATA_ATTR int wakeCount = 0;

※ Note:

RTC_DATA_ATTR conserve la valeur pendant la veille profonde, mais pas en cas de coupure d'alimentation ou de RESET. Le code vérifie aussi sur la carte les noms de fichiers libres, afin qu'aucune photo ne soit jamais écrasée.

Se réveiller sur une broche

ext0 réveille la carte quand une broche atteint le niveau que vous choisissez. Le nombre 1 signifie « réveiller quand la broche est HIGH » :

esp_sleep_enable_ext0_wakeup(GPIO_NUM_21, 1); esp_deep_sleep_start();

※ Note:

Seules les broches GPIO0 à GPIO21 peuvent réveiller l'ESP32 S3 de la veille profonde. On les appelle broches RTC. GPIO21 en fait partie, donc cela fonctionne. Une broche comme GPIO40 ne réveillerait jamais la carte.

À propos du capteur de mouvement PIR

Un capteur de mouvement PIR détecte la chaleur d'un corps humain. Sa broche OUT passe à HIGH quand quelque chose de chaud bouge devant lui, et c'est ce HIGH qui réveille l'ESP32 S3.

Le capteur possède deux petites vis orange. Tournez la vis du délai entièrement vers la gauche, afin que la sortie reste à HIGH pendant environ 3 secondes seulement. Pour plus de détails, consultez le tutoriel ESP32 S3 - Capteur de mouvement.

※ Note:

Le capteur PIR lui-même ne dort jamais. Il utilise environ 50 µA, ce qui est très peu, et il doit rester éveillé, car c'est lui qui réveille la carte.

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

Schéma de câblage de la caméra ESP32 S3 en veille profonde

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

Broche du capteur PIR	Broche ESP32 S3
VCC	5V
GND	GND
OUT	GPIO21

Insérez ensuite la carte microSD dans le slot de la carte.

Consignes de sécurité

Le capteur PIR a besoin de 5V sur sa broche VCC, pas de 3,3V. Sa broche OUT donne 3,3V, ce qui convient pour l'ESP32 S3.

La broche OUT doit aller sur GPIO21, car seules les broches GPIO0 à GPIO21 peuvent réveiller la carte de la veille profonde.

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

Comment programmer la caméra qui dort

Découvrez pourquoi la carte s'est réveillée. C'est utile, car le premier démarrage n'est pas un réveil.

esp_sleep_wakeup_cause_t reason = esp_sleep_get_wakeup_cause(); if (reason == ESP_SLEEP_WAKEUP_EXT0) Serial.println("The PIR sensor saw a movement"); else Serial.println("The board was switched on");

Laissez un instant à la caméra. Les premières photos après un démarrage sont toujours trop sombres, car la caméra n'a pas encore réglé la lumière.

delay(400); for (int i = 0; i < 2; i++) { camera_fb_t *old = esp_camera_fb_get(); if (old) esp_camera_fb_return(old); }

※ Note:

C'est l'erreur la plus courante dans les caméras à veille profonde : la photo est noire. La caméra a besoin d'environ une demi-seconde de lumière avant de produire une bonne première image.

Éteignez la caméra et la carte mémoire avant de dormir, afin qu'elles ne consomment aucune énergie.

esp_camera_deinit(); SD_MMC.end();

Maintenez la broche à un niveau bas pendant le sommeil, afin qu'une broche flottante ne puisse pas réveiller la carte toute seule.

rtc_gpio_pulldown_en(GPIO_NUM_21); rtc_gpio_pullup_dis(GPIO_NUM_21);

※ Note:

Sans cela, une broche non connectée capte du bruit électrique, la carte se réveille des centaines de fois, et la batterie est vide en une nuit.

Passez en veille. Rien après cette ligne ne s'exécute jamais.

esp_deep_sleep_start();

Code ESP32 S3

Les photos sont nommées wake_00001.jpg, wake_00002.jpg, et ainsi de suite. Le compteur vit dans RTC_DATA_ATTR, il continue donc de compter à travers chaque sommeil.

/* * 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-battery-with-deep-sleep */ #include "esp_camera.h" #include "FS.h" #include "SD_MMC.h" #include "driver/rtc_io.h" #define PIR_PIN GPIO_NUM_21 // the PIR motion sensor is connected to GPIO21 #define WARMUP_TIME 400 // give the camera 400 ms to set the light // 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 // RTC_DATA_ATTR keeps the value during deep sleep. // Normal variables lose their value, these do not. RTC_DATA_ATTR int photoNumber = 1; RTC_DATA_ATTR int wakeCount = 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_SVGA; // 800x600 - smaller photo, shorter awake time 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; } return true; } // Makes a file name like /wake_00001.jpg String makeFileName(int number) { char name[32]; sprintf(name, "/wake_%05d.jpg", number); return String(name); } void takeAndSavePhoto() { // The first pictures after a start are too dark, so we throw two away for (int i = 0; i < 2; i++) { camera_fb_t *old = esp_camera_fb_get(); if (old) esp_camera_fb_return(old); } camera_fb_t *fb = esp_camera_fb_get(); if (!fb) { Serial.println("Photo capture failed"); return; } // The counter may be behind after a card change, so find a free name while (SD_MMC.exists(makeFileName(photoNumber))) photoNumber++; 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); } // Turns everything off and goes to sleep until the PIR sensor goes HIGH void goToSleep() { Serial.println("Going to sleep. Bye."); Serial.flush(); esp_camera_deinit(); SD_MMC.end(); // Wake up when the PIR pin becomes HIGH (the number 1 means HIGH) esp_sleep_enable_ext0_wakeup(PIR_PIN, 1); // Hold the pull-down during sleep, so the pin does not float rtc_gpio_pulldown_en(PIR_PIN); rtc_gpio_pullup_dis(PIR_PIN); esp_deep_sleep_start(); // Nothing after this line ever runs. The board starts again at setup(). } void setup() { Serial.begin(115200); delay(500); wakeCount++; esp_sleep_wakeup_cause_t reason = esp_sleep_get_wakeup_cause(); if (reason == ESP_SLEEP_WAKEUP_EXT0) Serial.printf("Wake up number %d: the PIR sensor saw a movement\n", wakeCount); else Serial.printf("Wake up number %d: the board was switched on\n", wakeCount); if (!initCamera()) { Serial.println("The camera failed. Sleeping anyway."); goToSleep(); } if (!initSDCard()) { Serial.println("The card failed. Sleeping anyway."); goToSleep(); } delay(WARMUP_TIME); takeAndSavePhoto(); goToSleep(); } void loop() { // Empty. This board never reaches loop(), because setup() ends in deep sleep. }

Étapes rapides

Nouveau sur l'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 le slot, et câblez le capteur PIR comme dans le tableau ci-dessus.
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 Arduino IDE.

Ouvrez le moniteur série dans Arduino IDE.

Appuyez une fois sur le bouton RESET. La carte prend une photo puis dort.
Agitez votre main devant le capteur. La carte se réveille, vous voyez une nouvelle ligne, puis elle se rendort.
Quand vous êtes satisfait, débranchez le câble USB et utilisez plutôt une batterie externe.
Astuce pro : Gardez le moniteur série ouvert pendant vos tests. C'est le seul moyen de voir que la carte se réveille vraiment.

Moniteur série

Chaque réveil affiche deux lignes. Les lectures suivantes ont été capturées 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-28 11:00:01] Wake up number 1: the board was switched on [2026-09-28 11:00:02] Camera sensor: OV5640 (5 MP, max QSXGA 2592x1944) [2026-09-28 11:00:03] Saved /wake_00001.jpg (51353 bytes) [2026-09-28 11:00:03] Going to sleep. Bye. [2026-09-28 11:04:41] Wake up number 2: the PIR sensor saw a movement [2026-09-28 11:04:43] Saved /wake_00002.jpg (52180 bytes) [2026-09-28 11:04:43] Going to sleep. Bye. [2026-09-28 11:19:07] Wake up number 3: the PIR sensor saw a movement [2026-09-28 11:19:09] Saved /wake_00003.jpg (50992 bytes) [2026-09-28 11:19:09] Going to sleep. Bye.

Ln 11, Col 1

ESP32S3 Dev Module on COM15

※ Note:

La carte n'est éveillée que pendant environ 2 secondes à chaque fois. Tout le reste du temps, elle dort et n'utilise presque rien. C'est toute l'idée de ce projet.

Comment économiser encore plus d'énergie

La batterie est utilisée de deux façons : une toute petite quantité en permanence pendant que la carte dort, et une quantité bien plus grande pendant les deux secondes de chaque photo. Il n'y a donc que deux façons d'en consommer moins :

Quoi faire	Comment	Pourquoi ça aide
Rester éveillé moins longtemps	Utilisez un FRAME_SIZE plus petit, par exemple FRAMESIZE_VGA	Une photo plus petite est prise et écrite plus vite
Se réveiller moins souvent	Baissez la vis de sensibilité du capteur, et pointez-le loin de la rue	Chaque réveil coûte bien plus qu'une heure de sommeil

Observez le moniteur série pour voir combien de temps votre carte est vraiment éveillée. Le temps entre Wake up number ... et Going to sleep. Bye. est la partie qui coûte de l'énergie. Tout ce qui se passe entre deux réveils est presque gratuit.

※ Note:

Nous ne disons pas ici combien de jours ou de semaines une batterie dure, car cela dépend de trop de choses : quelle batterie, son âge, la fraîcheur de la nuit, la fréquence de passage de quelqu'un, et la consommation propre de votre batterie externe. Mesurez-le chez vous, avec votre propre batterie.

※ Note:

De nombreuses batteries externes s'éteignent d'elles-mêmes quand un appareil ne prend presque aucun courant, ce qui est exactement ce que fait la veille profonde. Si votre caméra s'arrête pendant la nuit, c'est généralement la raison. Utilisez une batterie externe qui prend en charge le « mode faible courant », ou utilisez une batterie avec un support approprié.

Dépannage

La carte ne se réveille jamais.

La broche OUT du capteur doit être sur GPIO21. Une broche au-dessus de GPIO21 ne peut pas réveiller la carte.
Vérifiez que le capteur a bien 5V, pas 3,3V.
Attendez une minute après le premier démarrage. Le capteur PIR est encore en train de chauffer.

La carte se réveille encore et encore alors qu'il n'y a rien devant elle.

Le capteur est trop sensible. Tournez la vis de sensibilité un peu vers la gauche.
Pointez le capteur loin des fenêtres, des chauffages et des climatiseurs.

Chaque photo est noire ou très sombre.

La caméra n'a pas eu le temps de régler la lumière. Augmentez WARMUP_TIME de 400 à 800, et changez la boucle de 2 à 3 photos.

Les photos s'arrêtent après quelques heures sur une batterie externe.

La batterie externe s'est éteinte elle-même, car la veille profonde prend un courant trop faible pour elle. Utilisez une batterie externe avec un mode faible courant, ou une batterie.

Le moniteur série perd la connexion après chaque sommeil.

C'est normal sur le port USB natif, car la carte disparaît quand elle dort. Utilisez le port UART pour les tests, et réglez USB CDC On Boot sur Disabled.

Les numéros recommencent à 1 après une coupure de courant.

RTC_DATA_ATTR ne survit pas à une coupure de courant. Ce n'est pas un problème : le code cherche le premier nom libre sur la carte, donc aucune photo n'est jamais écrasée.

Applications

Une caméra qui n'a besoin d'aucun câble peut aller là où les autres projets ne peuvent pas aller. Voici des projets pratiques que vous pouvez construire avec ce code :

Caméra de piste et de faune : Placez-la dans une forêt ou un champ sans aucune alimentation.
Caméra de boîte à colis : Une petite batterie à l'intérieur de la boîte, et aucun câble à travers le mur.
Surveillance de portail de jardin : Surveillez un portail loin de la maison, sans câble à poser.
Caméra de vélo et de garage : Gardez une photo de tous ceux qui s'approchent, sans travail de câblage.
Caméra de maison de vacances : Laissez-la dans une maison vide pendant votre absence.
Caméra de ferme et de grange : Surveillez des animaux ou une machine loin de toute prise.
Caméra de chantier : Déplacez-la chaque jour, car il n'y a rien à brancher.
Surveillance de ruche : Surveillez la ruche sans câble à travers le jardin.
Caméra de voiture : Prenez une photo quand quelqu'un s'approche de votre voiture garée.
Caméra de sécurité temporaire : Placez-la n'importe où pour un temps, puis retirez-la.

Vidéo

Regardez ci-dessous la vidéo pas à pas de ce projet ESP32 S3.

Défis

Débutant : Changez la taille de photo de FRAMESIZE_SVGA à FRAMESIZE_UXGA et voyez de combien de temps supplémentaire la carte reste éveillée.
Intermédiaire : Ajoutez aussi un réveil par minuterie, afin que la carte prenne également une photo chaque heure, même sans mouvement. Utilisez esp_sleep_enable_timer_wakeup().
Avancé : Connectez le WiFi après le réveil et envoyez la photo sur Telegram, puis dormez. Observez le moniteur série et voyez de combien de temps supplémentaire la carte doit rester éveillée.

Références du langage

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 !