ESP32-CAM : tutoriel pour la programmer, filmer et photographier

L'ESP32-CAM est une carte caméra Wi-Fi bon marché qui, malgré ses 27 × 40 mm, embarque un processeur ESP32, une caméra OV2640 de 2 mégapixels, un lecteur de carte microSD et une LED flash blanche. Toute seule, elle se connecte à ton réseau domestique, diffuse la vidéo en direct dans le navigateur, prend des photos et les enregistre sur la carte SD ou les envoie sur internet. C'est la carte préférée pour les caméras de surveillance, les sonnettes vidéo, les time-lapses de plantes et les voitures robots avec caméra, mais comme elle n'a pas de prise USB, sa prise en main diffère un peu de celle des cartes ESP32 que tu connais peut-être.

Dans ce guide, tu découvriras le brochage de l'ESP32-CAM d'AI-Thinker, comment la programmer avec l'adaptateur ESP32-CAM-MB ou un convertisseur USB-TTL (y compris la liaison IO0-GND), comment obtenir une image en direct dans le navigateur avec l'exemple CameraWebServer et quels réglages de PSRAM et de partition utiliser. Tu verras ensuite les causes des erreurs les plus courantes, Camera init failed with error 0x105 et brownout, tu piloteras la LED flash et tu écriras un programme qui enregistre une photo sur la carte microSD quand on appuie sur un bouton.

Qu'est-ce que l'ESP32-CAM et comment fonctionne-t-elle ?

Le cœur de la carte est le module ESP32-S, qui porte la puce ESP32 double cœur avec Wi-Fi et Bluetooth. La caméra se branche sur un connecteur 24 broches de la carte grâce à une fine nappe (FPC). L'ESP32 envoie à la caméra un signal d'horloge de 20 MHz (XCLK) sur le GPIO 0 et la configure via le bus SCCB, proche de l'I2C, sur les GPIO 26 et 27. Comme le capteur OV2640 sait compresser lui-même l'image en JPEG, l'ESP32 reçoit de petites images JPEG plutôt que des pixels bruts. Ces images transitent par un bus de données parallèle 8 bits jusqu'aux 4 Mo de PSRAM de la carte, puis le Wi-Fi les transmet au navigateur ou à un serveur.

Brochage de l'ESP32-CAM AI-Thinker : quelles broches sont libres ?

La carte compte 16 broches sur ses deux bords, mais seules quelques-unes sont vraiment libres : la caméra occupe à elle seule 15 GPIO et le lecteur microSD en partage six autres. Le tableau ci-dessous résume les broches des bords et indique quand tu peux les utiliser. Tu peux aussi consulter les caractéristiques générales des broches de l'ESP32 dans l'outil Pinout.

Comment programmer l'ESP32-CAM ? Deux méthodes

La puce USB-série qui permet aux cartes ESP32 classiques de dialoguer avec l'ordinateur est absente de l'ESP32-CAM. Pour téléverser ton code, tu as deux options : l'adaptateur ESP32-CAM-MB, qui se branche sous la carte (une petite carte support avec puce CH340 et prise micro USB), ou un convertisseur USB-TTL que tu possèdes déjà (FTDI, CH340, CP2102). Quelle que soit la méthode, le principe est le même : si le GPIO 0 est à LOW au démarrage, l'ESP32 passe en mode téléchargement (download mode) et attend du code ; s'il est à HIGH, il lance le programme en flash. Le bouton IO0 de l'adaptateur MB et le fil IO0-GND ajouté avec le convertisseur USB-TTL font exactement cela.

Si ton convertisseur possède un cavalier pour choisir entre 3,3 V et 5 V, place-le sur 3,3 V pour que la ligne TX reste à un niveau adapté aux broches de l'ESP32. Alimente en revanche la carte par la broche 5V du convertisseur. La sortie 3,3 V de la plupart des convertisseurs ne fournit qu'environ 50 à 100 mA ; dès que l'ESP32-CAM active le Wi-Fi, cette alimentation s'effondre et la carte redémarre.

Réglages de l'Arduino IDE : carte, schéma de partition et PSRAM

1. Ouvre le Gestionnaire de cartes de l'Arduino IDE et installe le paquet esp32 by Espressif Systems ; tout est détaillé dans installer l'Arduino IDE.
2. Choisis la carte AI Thinker ESP32-CAM dans Outils > Carte > esp32.
3. Vérifie que Partition Scheme est réglé sur Huge APP (3MB No OTA/1MB SPIFFS) ; l'exemple caméra a besoin d'au moins 3 Mo pour l'application.
4. Relie la carte à l'adaptateur ou au convertisseur et choisis le nouveau port dans Outils > Port (COMx sous Windows, /dev/cu.usbserial... ou /dev/cu.wchusbserial... sous macOS).
5. Si aucun port n'apparaît, installe le pilote CH340 ou CP2102 et utilise un câble USB qui transmet les données.

Le premier téléversement, étape par étape

1. Câble l'ensemble : enfiche la carte sur l'adaptateur MB en alignant les broches, ou relie le convertisseur USB-TTL comme dans le tableau ci-dessus. Avec un convertisseur USB-TTL, ajoute aussi le fil court entre IO0 et GND.
2. Passe la carte en mode téléchargement : sur l'adaptateur MB, maintiens le bouton IO0 enfoncé, appuie puis relâche RST, puis relâche IO0. Avec un convertisseur USB-TTL, il suffit d'appuyer sur RST pendant que le fil IO0-GND est en place. Certains adaptateurs MB dotés d'un circuit de réinitialisation automatique téléversent sans appui sur les boutons.
3. Clique sur Téléverser dans l'Arduino IDE. La sortie affiche d'abord Connecting..., puis la progression de l'écriture en pourcentage.
4. Quand la ligne Hard resetting via RTS pin... apparaît, le téléversement est terminé. Avec un convertisseur USB-TTL, retire maintenant le fil IO0-GND.
5. Ouvre le moniteur série à 115200 bauds et appuie sur RST : le nouveau programme démarre.

1// ESP32-CAM ilk yükleme testi / ESP32-CAM first upload test
2const int KIRMIZI_LED = 33;   // arkadaki kırmızı LED, ters mantık / red LED on the back, inverted logic
3
4void setup() {
5  Serial.begin(115200);
6  pinMode(KIRMIZI_LED, OUTPUT);
7  delay(500);
8
9  // PSRAM kontrolü / PSRAM check
10  if (psramFound()) {
11    Serial.print("PSRAM bulundu / PSRAM found: ");
12    Serial.print(ESP.getPsramSize());
13    Serial.println(" bayt / bytes");
14  } else {
15    Serial.println("PSRAM yok / No PSRAM");
16  }
17}
18
19void loop() {
20  digitalWrite(KIRMIZI_LED, LOW);    // LOW = yanar / LOW = on
21  delay(500);
22  digitalWrite(KIRMIZI_LED, HIGH);   // HIGH = söner / HIGH = off
23  delay(500);
24}

Si le téléversement a réussi, la petite LED rouge au dos de la carte clignote toutes les demi-secondes. Cette LED fonctionne en logique inversée : elle s'allume avec LOW et s'éteint avec HIGH. Le moniteur série doit afficher environ 4 millions d'octets de PSRAM ; s'il indique No PSRAM, vérifie la carte sélectionnée et, si rien ne change, ta carte n'a peut-être pas de puce PSRAM. Faire ce petit test avant l'exemple caméra te dit tout de suite si le problème vient du téléversement ou de la caméra.

L'exemple CameraWebServer : l'image en direct dans le navigateur

1. Ouvre Fichier > Exemples > ESP32 > Camera > CameraWebServer.
2. Choisis le modèle de caméra : dans la liste de l'onglet board_config.h (versions récentes) ou au début du fichier principal (anciennes versions), ajoute // devant la ligne CAMERA_MODEL_ESP_EYE et supprime les // devant CAMERA_MODEL_AI_THINKER.
3. Indique dans les lignes ssid et password le nom et le mot de passe de ton réseau Wi-Fi 2,4 GHz.
4. Passe la carte en mode téléchargement et téléverse le programme ; retire ensuite la liaison IO0 et appuie sur RST.
5. Le moniteur série affiche une ligne du type Camera Ready! Use 'http://192.168.1.45' to connect ; ouvre cette adresse dans le navigateur d'un téléphone ou d'un ordinateur connecté au même réseau.
6. Lance l'image en direct avec le bouton Start Stream ou prends une seule photo avec Get Still.

1// board_config.h (eski sürümlerde CameraWebServer.ino) / (CameraWebServer.ino in older versions)
2//#define CAMERA_MODEL_ESP_EYE      // Has PSRAM  <- kapat / comment out
3#define CAMERA_MODEL_AI_THINKER     // Has PSRAM  <- aç / enable
4
5// CameraWebServer.ino
6const char *ssid = "AgAdi";          // Wi-Fi adı / Wi-Fi name
7const char *password = "Sifre123";   // Wi-Fi şifresi / Wi-Fi password

L'interface repose sur deux serveurs distincts : la page de réglages et l'adresse /capture, qui renvoie une photo, sont sur le port 80, tandis que le flux en direct se trouve à l'adresse /stream sur le port 81 (ex. http://192.168.1.45:81/stream). Tu peux intégrer cette adresse de flux dans ta propre page web ou dans un logiciel domotique. Le menu de gauche permet de changer la résolution, la qualité JPEG, la luminosité, le contraste et la balance des blancs ; si l'image est à l'envers, utilise les interrupteurs V-Flip et H-Mirror, et les versions récentes ajoutent un curseur LED Intensity pour le flash. La carte ne sert généralement qu'un seul spectateur du flux à la fois : un flux ouvert dans un deuxième onglet peut se figer. Si la page ne s'ouvre pas, vérifie que le téléphone et la carte sont sur le même réseau ; pour les problèmes de connexion, consulte l'ESP32 ne se connecte pas au Wi-Fi.

Tableau des résolutions et FPS de l'ESP32-CAM

Sur le papier, le capteur OV2640 fournit 15 images par seconde en 1600×1200, 30 en 800×600 et 60 au format CIF. En pratique, la cadence dépend surtout de la liaison Wi-Fi et de la taille des images JPEG : plus la résolution et la qualité augmentent, plus chaque image est lourde et lente à traverser le réseau. Les valeurs ci-dessous sont des fourchettes approximatives obtenues avec CameraWebServer, un bon signal Wi-Fi et une qualité JPEG de 10 à 12. Pour mesurer ta propre carte, règle Core Debug Level sur Info : pendant le flux, le moniteur série affiche pour chaque image une ligne du type MJPG: ... (x fps).

Dans ton propre code, tu peux modifier la résolution, la qualité et l'orientation de l'image via l'objet capteur, une fois la caméra correctement démarrée. La qualité JPEG est un nombre de 0 à 63, et plus le nombre est petit, meilleure est la qualité ; descendre sous 10 alourdit les images et peut donner des images tronquées.

1// esp_camera_init() başarılı olduktan sonra / after esp_camera_init() succeeds
2sensor_t *s = esp_camera_sensor_get();
3s->set_framesize(s, FRAMESIZE_VGA);   // 640x480 çözünürlük / resolution
4s->set_quality(s, 12);                // 0-63: küçük = daha kaliteli, 10 altı önerilmez / lower = better, below 10 not advised
5s->set_vflip(s, 1);                   // görüntüyü dikey çevir / flip vertically
6s->set_hmirror(s, 1);                 // yatay ayna / mirror horizontally
7s->set_brightness(s, 1);              // parlaklık -2..2 / brightness -2..2

Pourquoi le réglage PSRAM de l'ESP32-CAM est-il si important ?

La mémoire interne de l'ESP32 est de 520 Ko, dont une bonne partie est utilisée par la pile Wi-Fi. Or une seule image JPEG en 1600×1200 peut peser de 100 à 250 Ko selon la scène et la qualité. C'est pourquoi le pilote de la caméra place ses tampons d'image (frame buffer) dans la PSRAM. CameraWebServer vérifie la présence de PSRAM avec la fonction psramFound() : s'il y en a, il démarre en résolution maximale avec deux tampons ; sinon, il limite la résolution au SVGA (800×600) et garde un seul tampon en mémoire interne.

Si tu demandes une haute résolution sans PSRAM activée, le moniteur série affiche frame buffer malloc failed puis Camera init failed with error 0xffffffff. La solution : choisir AI Thinker ESP32-CAM comme carte (avec ESP32 Dev Module, régler Outils > PSRAM: Enabled) ou baisser la résolution et passer à un seul tampon. Certains clones bon marché n'ont tout simplement pas de puce PSRAM ; la ligne PSRAM du premier programme de test le révèle immédiatement.

Camera init failed with error 0x105 et les autres erreurs de caméra

La plupart des erreurs de caméra ont l'une de ces trois causes : un mauvais modèle de caméra dans le code, une nappe mal enfoncée dans son connecteur ou une alimentation insuffisante. Lire le code d'erreur dans le moniteur série permet de cerner rapidement la cause :

Erreur brownout et bonne alimentation (5 V / 2 A)

Si le moniteur série affiche Brownout detector was triggered et que la carte redémarre sans cesse, la tension d'alimentation de l'ESP32 est passée un court instant sous un seuil sûr. L'ESP32-CAM tire des pics de courant brefs mais élevés dès qu'elle active son émetteur Wi-Fi et que la caméra commence à capturer. Un port USB faible, des câbles de liaison fins et longs ou la sortie 3,3 V du convertisseur ne suivent pas ces pics. Voici les solutions durables :

• Utilise une alimentation 5 V d'au moins 2 A reliée à la broche 5V de la carte ; le régulateur embarqué l'abaisse à 3,3 V.
• Garde des fils d'alimentation courts et épais ; la plaque d'essai et les longs câbles de liaison augmentent la chute de tension.
• Ajoute un condensateur électrolytique de 470 à 1000 µF entre les broches 5V et GND, au plus près de la carte (patte positive sur 5V).
• Si tu l'alimentes depuis l'ordinateur, branche-la directement sur un port à l'arrière plutôt que sur un hub USB.
• Pour un fonctionnement sur batterie, utilise un accu 18650 avec un module élévateur (boost) 5 V ; c'est bien plus stable que des piles AA en série.

Sur internet, tu croiseras souvent la ligne WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0), qui désactive le détecteur de brownout dans le code. Elle arrête les redémarrages mais ne règle pas le problème : la tension continue de chuter et la carte peut alors se figer, produire des images corrompues ou perdre des données en écrivant dans la flash. Ne l'utilise que pour un essai temporaire ; tous les messages de redémarrage sont expliqués dans ESP32 brownout et Guru Meditation. Pour estimer l'autonomie, compte une consommation moyenne de 180 mA en diffusion continue : un accu 18650 de 2600 mAh avec un élévateur à 85 % de rendement donne environ 1600 mAh côté 5 V, soit près de 9 heures de vidéo. Calcule tes propres valeurs avec le calculateur d'autonomie de batterie, et n'oublie pas que même en sommeil profond la carte consomme environ 6 mA à cause du régulateur et de la PSRAM.

Piloter la LED flash (GPIO 4)

La LED blanche très lumineuse à l'avant de la carte est commandée par un transistor relié au GPIO 4 : la broche ne fait que commuter le transistor et le fort courant de la LED vient de l'alimentation. digitalWrite(4, HIGH) l'allume et LOW l'éteint. Cette LED est très puissante et, si elle reste allumée longtemps, elle chauffe ainsi que la carte ; l'idéal est de n'allumer le flash que quelques centaines de millisecondes pendant la prise de vue. Le GPIO 4 est aussi la ligne DATA1 de la carte microSD : en mode 4 bits, le flash clignote donc tout seul à chaque lecture et écriture. Pour l'éviter, démarre la carte SD en mode 1 bit (SD_MMC.begin("/sdcard", true)) ; sur certaines cartes, la LED peut tout de même luire très faiblement.

Enregistrer des photos sur la carte microSD avec l'ESP32-CAM

Le programme ci-dessous allume le flash, prend une photo en 1600×1200 et l'enregistre sur la carte microSD sous les noms foto1.jpg, foto2.jpg... à chaque appui sur un bouton relié au GPIO 13. Formate la carte en FAT32 sur ton ordinateur ; même si la documentation officielle parle de cartes jusqu'à 4 Go, les cartes FAT32 de 16 à 32 Go fonctionnent généralement sans problème. Relie une patte du bouton-poussoir au GPIO 13 et l'autre à GND ; le programme active la résistance de pull-up interne, aucune résistance supplémentaire n'est donc nécessaire. Pour comprendre le câblage d'un bouton, consulte brancher un bouton sur l'Arduino.

1#include "esp_camera.h"
2#include "FS.h"
3#include "SD_MMC.h"
4
5// AI-Thinker ESP32-CAM kamera pinleri / AI-Thinker ESP32-CAM camera pins
6#define PWDN_GPIO_NUM     32
7#define RESET_GPIO_NUM    -1
8#define XCLK_GPIO_NUM      0
9#define SIOD_GPIO_NUM     26
10#define SIOC_GPIO_NUM     27
11#define Y9_GPIO_NUM       35
12#define Y8_GPIO_NUM       34
13#define Y7_GPIO_NUM       39
14#define Y6_GPIO_NUM       36
15#define Y5_GPIO_NUM       21
16#define Y4_GPIO_NUM       19
17#define Y3_GPIO_NUM       18
18#define Y2_GPIO_NUM        5
19#define VSYNC_GPIO_NUM    25
20#define HREF_GPIO_NUM     23
21#define PCLK_GPIO_NUM     22
22
23#define FLAS_LED  4    // beyaz flaş LED'i / white flash LED
24#define BUTON    13    // butonun diğer ucu GND'de / other button leg to GND
25
26int fotoNo = 1;        // sıradaki dosya numarası / next file number
27bool hazir = false;    // kamera ve SD hazır mı? / are camera and SD ready?
28
29bool kameraBaslat() {
30  camera_config_t config = {};
31  config.ledc_channel = LEDC_CHANNEL_0;
32  config.ledc_timer   = LEDC_TIMER_0;
33  config.pin_d0 = Y2_GPIO_NUM;
34  config.pin_d1 = Y3_GPIO_NUM;
35  config.pin_d2 = Y4_GPIO_NUM;
36  config.pin_d3 = Y5_GPIO_NUM;
37  config.pin_d4 = Y6_GPIO_NUM;
38  config.pin_d5 = Y7_GPIO_NUM;
39  config.pin_d6 = Y8_GPIO_NUM;
40  config.pin_d7 = Y9_GPIO_NUM;
41  config.pin_xclk     = XCLK_GPIO_NUM;
42  config.pin_pclk     = PCLK_GPIO_NUM;
43  config.pin_vsync    = VSYNC_GPIO_NUM;
44  config.pin_href     = HREF_GPIO_NUM;
45  config.pin_sccb_sda = SIOD_GPIO_NUM;
46  config.pin_sccb_scl = SIOC_GPIO_NUM;
47  config.pin_pwdn     = PWDN_GPIO_NUM;
48  config.pin_reset    = RESET_GPIO_NUM;
49  config.xclk_freq_hz = 20000000;           // 20 MHz kamera saati / 20 MHz camera clock
50  config.pixel_format = PIXFORMAT_JPEG;
51
52  if (psramFound()) {
53    config.frame_size   = FRAMESIZE_UXGA;   // 1600x1200
54    config.jpeg_quality = 10;               // küçük = daha kaliteli / lower = better quality
55    config.fb_count     = 2;
56    config.fb_location  = CAMERA_FB_IN_PSRAM;
57    config.grab_mode    = CAMERA_GRAB_LATEST;
58  } else {
59    config.frame_size   = FRAMESIZE_SVGA;   // PSRAM yoksa 800x600 / 800x600 without PSRAM
60    config.jpeg_quality = 12;
61    config.fb_count     = 1;
62    config.fb_location  = CAMERA_FB_IN_DRAM;
63    config.grab_mode    = CAMERA_GRAB_WHEN_EMPTY;
64  }
65
66  esp_err_t err = esp_camera_init(&config);
67  if (err != ESP_OK) {
68    Serial.printf("Camera init failed 0x%x (%s)\n", err, esp_err_to_name(err));
69    return false;
70  }
71  return true;
72}
73
74void fotoCek() {
75  digitalWrite(FLAS_LED, HIGH);              // flaşı yak / flash on
76  delay(150);                                // pozlama otursun / let exposure settle
77
78  camera_fb_t *fb = esp_camera_fb_get();     // eski kareyi at / discard the stale frame
79  if (fb) esp_camera_fb_return(fb);
80  fb = esp_camera_fb_get();                  // asıl fotoğraf / the real photo
81  digitalWrite(FLAS_LED, LOW);               // flaşı söndür / flash off
82
83  if (!fb) {
84    Serial.println("Kare alinamadi / Capture failed");
85    return;
86  }
87
88  String yol = "/foto" + String(fotoNo) + ".jpg";
89  File dosya = SD_MMC.open(yol, FILE_WRITE);
90  if (dosya) {
91    dosya.write(fb->buf, fb->len);           // JPEG verisini yaz / write the JPEG data
92    dosya.close();
93    Serial.printf("Kaydedildi / Saved: %s (%u bayt / bytes)\n", yol.c_str(), (unsigned)fb->len);
94    fotoNo++;
95  } else {
96    Serial.println("Dosya acilamadi / Could not open file");
97  }
98  esp_camera_fb_return(fb);                  // tamponu geri ver / return the buffer
99}
100
101void setup() {
102  Serial.begin(115200);
103  pinMode(BUTON, INPUT_PULLUP);
104
105  if (!kameraBaslat()) return;               // kamera yoksa dur / stop without a camera
106
107  // 1-bit mod: GPIO 4, 12 ve 13 boşta kalır / 1-bit mode keeps GPIO 4, 12 and 13 free
108  if (!SD_MMC.begin("/sdcard", true)) {
109    Serial.println("SD kart takilamadi / SD card mount failed");
110    return;
111  }
112  if (SD_MMC.cardType() == CARD_NONE) {
113    Serial.println("SD kart yok / No SD card");
114    return;
115  }
116
117  pinMode(FLAS_LED, OUTPUT);
118  digitalWrite(FLAS_LED, LOW);
119
120  // Var olan fotoğrafların üzerine yazma / don't overwrite existing photos
121  while (SD_MMC.exists("/foto" + String(fotoNo) + ".jpg")) fotoNo++;
122
123  hazir = true;
124  Serial.println("Hazir, butona bas / Ready, press the button");
125}
126
127void loop() {
128  if (!hazir) {                              // hata varsa bekle / wait if setup failed
129    delay(1000);
130    return;
131  }
132  if (digitalRead(BUTON) == LOW) {
133    delay(30);                               // buton sıçramasını (bounce) önle / debounce
134    if (digitalRead(BUTON) == LOW) {
135      fotoCek();
136      while (digitalRead(BUTON) == LOW) delay(10);   // bırakılmasını bekle / wait for release
137    }
138  }
139}

Comme le programme démarre la carte SD en mode 1 bit, il n'utilise que les GPIO 2, 14 et 15, ce qui laisse le GPIO 4 au flash et le GPIO 13 au bouton. Avant la photo, une image est récupérée puis rendue aussitôt : la caméra produit des images en continu, la première image du tampon peut donc dater d'avant l'allumage du flash, et l'exposition automatique a besoin d'une courte pause pour s'adapter à la nouvelle lumière. Le numéro de fichier est déterminé à partir des fichiers déjà présents sur la carte, si bien que les anciennes photos ne sont pas écrasées même après un redémarrage. Pour les règles générales d'enregistrement de données sur carte SD, jette un œil à le module carte SD.

MicroPython et cartes caméra plus récentes

On peut aussi programmer l'ESP32-CAM en MicroPython, mais la version officielle de MicroPython n'inclut pas de pilote caméra : il faut flasher un firmware communautaire qui l'ajoute. Pour débuter, la voie Arduino IDE est donc bien plus simple. Si tu préfères éviter une carte sans prise USB, regarde aussi les cartes caméra à base d'ESP32-S3, avec USB et davantage de mémoire (par ex. Seeed XIAO ESP32S3 Sense ou ESP32-S3-EYE) ; elles figurent elles aussi dans la liste des modèles de CameraWebServer.

Idées de projets avec l'ESP32-CAM

• Photo à la détection de mouvement : prends une photo quand un capteur PIR repère quelqu'un et envoie-la sur ton téléphone ; le guide pas à pas se trouve dans photos de l'ESP32-CAM vers Telegram.
• Time-lapse : la carte se réveille toutes les 10 minutes, prend une photo, l'enregistre sur la SD et retourne en sommeil profond ; observe une plante pousser ou la météo évoluer.
• Caméra de sonnette : photographie le pas de ta porte quand on sonne et envoie une notification avec un bot Telegram.
• Voiture robot avec caméra : pilote la voiture en regardant sur ton téléphone une vidéo fluide en QVGA.
• Caméra pour animaux : regarde le flux en direct sur ton réseau domestique et allume le flash depuis la page web si besoin.
• Ton propre tableau de bord : intègre le flux dans ta propre page web et ajoute à côté des commandes de relais et des mesures de capteurs ; le guide ESP32 WebSocket te montre comment faire.

Erreurs fréquentes et solutions

L'ESP32-CAM est le moyen le plus simple de réaliser une caméra Wi-Fi avec une carte bon marché, et presque toutes les difficultés viennent de la liaison de programmation ou de l'alimentation. Une fois ces deux points maîtrisés, la carte diffuse la vidéo en direct depuis son propre serveur web, prend des photos et les enregistre sur la carte SD. Dans l'application BlueGrays, tu trouveras des projets ESP32 comme la connexion Wi-Fi, un serveur web, le mDNS, l'enregistrement de données sur microSD et une alarme de mouvement avec notifications Telegram, chacun avec son schéma de câblage pas à pas et son code prêt à l'emploi.