CAPTEURS/ACTIONNEURS

Caméra ESP32 S3 - Afficher une vidéo en direct sur un écran TFT

Tous les autres projets de caméra ont besoin de WiFi et d'un navigateur web. Celui-ci n'a besoin ni de l'un ni de l'autre. L'ESP32 S3 envoie l'image en direct directement vers un écran TFT placé juste à côté. Vous obtenez une petite caméra avec son propre écran, et elle fonctionne sans aucun réseau.

ESP32 S3 Camera - Show Live Video on a TFT Display

Ce que vous allez construire :

Une caméra ESP32 S3 avec un écran TFT
Une image en direct à l'écran, sans WiFi et sans routeur
Un compteur d'images dans le Serial Monitor, pour voir à quelle vitesse ça tourne
Une petite caméra que vous pouvez emporter partout, avec seulement une batterie externe

Matériel nécessaire

1	×	ESP32 S3 N16R8 OV5640 Camera
1	×	Alternativement: ESP32 S3 N16R8 OV2640 Camera
1	×	TFT SPI Écran
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	×	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 (breakout board) ont 44 broches. Elles fonctionnent tout de même ensemble. Placez la carte caméra au centre de la carte à 44 broches, pour 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 plaque d'essai.

Comment ça fonctionne

Une image de caméra et une image d'écran sont presque la même chose, si vous choisissez les bons paramètres.

Paramètre	Valeur	Pourquoi
Format d'image	RGB565	L'écran veut exactement ce format. Deux octets font une couleur.
Taille d'image	QVGA, 320 x 240	L'écran en mode paysage fait aussi 320 x 240
Rotation	1 (paysage)	Fait passer le panneau de la position debout à la position couchée

Le code est donc court. Demandez une image à la caméra, puis donnez-la à l'écran :

camera_fb_t *fb = esp_camera_fb_get(); TFT_display.drawRGBBitmap(0, 0, (uint16_t *)fb->buf, fb->width, fb->height); esp_camera_fb_return(fb);

※ Note:

N'utilisez pas PIXFORMAT_JPEG pour ce projet. Un JPEG est compressé, et l'écran ne peut pas le lire. PIXFORMAT_RGB565 donne les couleurs brutes, ce dont l'écran a besoin.

Pourquoi les couleurs peuvent sembler fausses

Une couleur fait deux octets, et la caméra et l'écran ne sont pas d'accord sur l'octet qui vient en premier. Si vous envoyez l'image sans y penser, le ciel devient orange et les visages deviennent bleus.

Le code inverse les deux octets avant de dessiner :

uint8_t *p = fb->buf; for (size_t i = 0; i < fb->len; i += 2) { uint8_t keep = p[i]; p[i] = p[i + 1]; p[i + 1] = keep; }

※ Note:

Si votre image semble étrange, changez la ligne #define SWAP_BYTES true en false. L'une des deux valeurs est la bonne pour votre écran, et cela ne coûte rien d'essayer les deux.

Quelles broches restent libres ?

La caméra utilise 14 broches, vous devez donc choisir les broches de l'écran avec soin :

Utilisé par	Broches
Caméra	GPIO4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18
Logement de carte microSD	GPIO38, 39, 40
USB	GPIO19, 20
Serial Monitor	GPIO43, 44
Boot (à ne jamais utiliser)	GPIO0, 3, 45, 46
Libre pour l'écran	GPIO1, 2, 14, 21, 41, 42, 47 (nous en utilisons 6, GPIO14 reste libre)

Il y a assez de broches libres pour l'écran, donc tout rentre.

Des broches différentes du tutoriel d'écran normal

Si vous avez déjà suivi le tutoriel ESP32 S3 - Écran tactile TFT LCD ILI9341 ILI9488 ST7789 interface SPI, deux fils changent dans ce projet :

Broche de l'écran	Tutoriel d'écran normal	Ce projet caméra	Pourquoi
CS	GPIO1	GPIO1	Identique
DC / RS	GPIO42	GPIO42	Identique
RST	GPIO2	GPIO2	Identique
SDI / MOSI	GPIO11	GPIO21	GPIO11 est une broche de données de la caméra
SCK	GPIO12	GPIO47	GPIO12 est une broche de données de la caméra
SDO / MISO	GPIO13	non connecté	GPIO13 est l'horloge de pixel de la caméra

※ Note:

GPIO11, GPIO12 et GPIO13 sont les broches SPI normales de l'ESP32 S3, c'est pourquoi l'autre tutoriel les utilise. Sur la carte caméra, ces trois broches appartiennent à la caméra, nous devons donc en choisir d'autres. C'est la seule différence. Les trois fils de contrôle, CS, DC et RST, restent exactement les mêmes.

Schéma de câblage entre l'écran TFT et l'ESP32 S3

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

Broche de l'écran TFT	Broche ESP32 S3	Signification
VCC	3.3V	Alimentation
GND	GND	Masse
CS	GPIO1	Sélection de puce
DC / RS	GPIO42	Données ou commande
RESET	GPIO2	Réinitialisation
SDI / MOSI	GPIO21	Données vers l'écran
SCK	GPIO47	Horloge
LED / BL	GPIO41	Rétroéclairage
SDO / MISO	non connecté	Nécessaire seulement pour lire depuis l'écran

Notes de sécurité

Utilisez 3,3V pour VCC, pas 5V. L'ESP32 S3 fonctionne en 3,3V, et un écran alimenté en 5V peut endommager les broches de la carte.

La broche LED ou BL est le rétroéclairage. Cette carte n'a qu'une seule broche 3,3V, et le fil VCC l'utilise déjà. Nous plaçons donc le rétroéclairage sur GPIO41 à la place, et le code l'allume :

TFT_display.initBacklight(TFT_LED_PIN); // the backlight goes on

C'est plus simple à câbler, et vous obtenez deux avantages gratuits : TFT_display.backlightOff() éteint l'écran pour économiser l'énergie, et TFT_display.setBacklight(128) le règle à moitié luminosité.

Vous n'avez pas besoin du fil SDO / MISO. Ce projet ne fait qu'écrire sur l'écran, il ne lit jamais depuis celui-ci.

※ Note:

Utilisez-vous aussi le logement de carte microSD ? Gardez alors GPIO38, 39 et 40 libres. Les broches de l'écran ci-dessus n'y touchent pas, donc la carte et l'écran fonctionnent ensemble.

Installer la bibliothèque DIYables TFT SPI

Ouvrez Arduino IDE.
Cliquez sur l'icône Libraries sur la barre de gauche.
Tapez DIYables TFT SPI dans le champ de recherche.
Trouvez la bibliothèque de DIYables.io et cliquez sur INSTALL.
Quand l'IDE demande d'installer d'autres bibliothèques, cliquez sur INSTALL ALL, car cette bibliothèque utilise Adafruit GFX.

Search for DIYables TFT SPI created by DIYables.io and click the Install button.

Newbiely | Arduino IDE 2.3.8

──

☐

Library Manager

DIYables TFT SPI

All

DIYables TFT SPI by DIYables.io

Works with both touch and non-touch versions of the same SPI TFT modules. Supports ILI9341 (240x320, 16-bit RGB565), ILI9488 (320x480, 18-bit RGB666), and ST7789 (240x320, 16-bit RGB565) displays over SPI. Includes built-in driver for XPT2046 / HR2046 / ADS7843 SPI touch controllers and 4-wire resistive touch panels - no separate touch library required. Use the display-only API for non-touch panels, or add initTouchSPI() to enable touch on modules that include a touch controller. Extends Adafruit GFX for full graphics support. Works with any Arduino-compatible board that has SPI. More info

1.0.3

INSTALL

Newbiely.ino

···

1 void setup() {

Output

Serial Monitor

Ln 1, Col 1

ESP32S3 Dev Module on COM15

La bibliothèque fonctionne avec trois types d'écran. Le code utilise le ST7789. Utilisez la ligne qui correspond à votre propre module :

Votre écran	Ligne dans le code	Taille
ST7789 (utilisé dans ce tutoriel)	DIYables_ST7789_SPI TFT_display(...)	240 x 320
ILI9341	DIYables_ILI9341_SPI TFT_display(...)	240 x 320
ILI9488	DIYables_ILI9488_SPI TFT_display(...)	320 x 480

Pour un autre écran, mettez // devant la ligne ST7789 et retirez le // de la ligne de votre propre écran. Rien d'autre ne change.

Paramètres Arduino IDE pour la caméra ESP32 S3

La caméra ne fonctionne pas avec les paramètres par défaut d'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:

Le PSRAM est très important ici. Une image RGB565 de 320 x 240 prend 153600 octets, ce qui ne tient pas dans la mémoire normale de la puce. Sans PSRAM, le code retombe sur une image très petite.

Comment programmer l'affichage de la caméra

Incluez la bibliothèque et choisissez votre écran.

#include <DIYables_TFT_SPI.h> SPIClass tftBus(FSPI); DIYables_ST7789_SPI TFT_display(240, 320, TFT_CS_PIN, TFT_DC_PIN, TFT_RST_PIN, &tftBus);

※ Note:

L'ESP32 S3 a plus d'un bus SPI. Nous utilisons FSPI, pour que l'écran n'entre jamais en conflit avec autre chose sur la carte.

Indiquez au bus SPI quelles broches utiliser, puis démarrez l'écran. Les deux -1 signifient "nous ne lisons pas depuis l'écran".

tftBus.begin(TFT_SCK_PIN, -1, TFT_MOSI_PIN, -1); TFT_display.begin(); TFT_display.setRotation(1); // 1 means landscape TFT_display.fillScreen(BLACK);

Demandez à la caméra l'image dans le format voulu par l'écran.

config.pixel_format = PIXFORMAT_RGB565; config.frame_size = FRAMESIZE_QVGA; // 320x240

Dessinez l'image. Cette seule ligne place toute l'image de la caméra à l'écran.

TFT_display.drawRGBBitmap(0, 0, (uint16_t *)fb->buf, fb->width, fb->height);

Rendez la mémoire, sinon la caméra s'arrête après quelques images.

esp_camera_fb_return(fb);

Vous pouvez aussi écrire du texte à l'écran, car la bibliothèque utilise Adafruit GFX.

TFT_display.setTextColor(WHITE); TFT_display.setTextSize(2); TFT_display.setCursor(20, 110); TFT_display.print("Starting camera...");

Code ESP32 S3

/* * 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-show-live-video-on-a-tft-display */ #include <DIYables_TFT_SPI.h> // DIYables TFT SPI library #include "esp_camera.h" // Pins of the TFT display. // CS, DC and RST are the same as in the ESP32 S3 TFT LCD Touch Display SPI tutorial. // SCK and MOSI had to be moved, because the camera uses GPIO11, 12 and 13. #define TFT_SCK_PIN 47 #define TFT_MOSI_PIN 21 #define TFT_CS_PIN 1 #define TFT_DC_PIN 42 #define TFT_RST_PIN 2 #define TFT_LED_PIN 41 // the backlight. The board has only one 3.3V pin, so we use a GPIO. // The size of the panel when it stands up (portrait) #define TFT_WIDTH 240 #define TFT_HEIGHT 320 // The camera and the display do not agree about the order of the two bytes // of one pixel. Change this to false if the colours look wrong. #define SWAP_BYTES true // 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 // The ESP32 S3 has more than one SPI bus. We use FSPI for the display. SPIClass tftBus(FSPI); // Use the line that matches your display module DIYables_ST7789_SPI TFT_display(TFT_WIDTH, TFT_HEIGHT, TFT_CS_PIN, TFT_DC_PIN, TFT_RST_PIN, &tftBus); // DIYables_ILI9341_SPI TFT_display(TFT_WIDTH, TFT_HEIGHT, TFT_CS_PIN, TFT_DC_PIN, TFT_RST_PIN, &tftBus); // DIYables_ILI9488_SPI TFT_display(320, 480, TFT_CS_PIN, TFT_DC_PIN, TFT_RST_PIN, &tftBus); #define BLACK DIYables_TFT_SPI::colorRGB(0, 0, 0) #define WHITE DIYables_TFT_SPI::colorRGB(255, 255, 255) unsigned long frameCount = 0; unsigned long lastReport = 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.jpeg_quality = 10; config.fb_count = 1; config.fb_location = psramFound() ? CAMERA_FB_IN_PSRAM : CAMERA_FB_IN_DRAM; config.grab_mode = CAMERA_GRAB_WHEN_EMPTY; // RGB565 gives the picture in the same form that the display wants. // QVGA is 320x240, which is exactly the size of the display in landscape. config.pixel_format = PIXFORMAT_RGB565; config.frame_size = FRAMESIZE_QVGA; if (!psramFound()) { Serial.println("WARNING: PSRAM not found. Please set PSRAM to OPI PSRAM in the Tools menu."); config.frame_size = FRAMESIZE_QQVGA; // 160x120, the only size that fits without PSRAM } 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; } void setup() { Serial.begin(115200); delay(1000); // Tell the SPI bus which pins to use. -1 means we do not read from the display. tftBus.begin(TFT_SCK_PIN, -1, TFT_MOSI_PIN, -1); TFT_display.begin(); TFT_display.initBacklight(TFT_LED_PIN); // switches the backlight on TFT_display.setRotation(1); // 1 means landscape, so the screen is 320 x 240 TFT_display.fillScreen(BLACK); TFT_display.setTextColor(WHITE); TFT_display.setTextSize(2); TFT_display.setCursor(20, 110); TFT_display.print("Starting camera..."); Serial.println("Display is ready"); if (!initCamera()) { TFT_display.fillScreen(BLACK); TFT_display.setCursor(20, 110); TFT_display.print("Camera failed"); while (true) delay(1000); } TFT_display.fillScreen(BLACK); Serial.println("Showing the live picture on the display"); lastReport = millis(); } void loop() { camera_fb_t *fb = esp_camera_fb_get(); if (!fb) { Serial.println("Frame capture failed"); delay(100); return; } // Turn the two bytes of every pixel around, if needed if (SWAP_BYTES) { uint8_t *p = fb->buf; for (size_t i = 0; i < fb->len; i += 2) { uint8_t keep = p[i]; p[i] = p[i + 1]; p[i + 1] = keep; } } TFT_display.drawRGBBitmap(0, 0, (uint16_t *)fb->buf, fb->width, fb->height); esp_camera_fb_return(fb); // give the memory back to the camera frameCount++; // Every 5 seconds, tell the Serial Monitor how fast we are if (millis() - lastReport >= 5000) { Serial.printf("%lu pictures in 5 seconds (%.1f per second)\n", frameCount, frameCount / 5.0); frameCount = 0; lastReport = millis(); } }

Étapes rapides

Nouveau sur ESP32 S3 ? Suivez d'abord notre guide ESP32 S3 - Premiers pas.
Installez la bibliothèque DIYables TFT SPI, et cliquez sur INSTALL ALL quand l'IDE le demande.
Débranchez le câble USB, puis câblez l'écran comme indiqué dans le tableau ci-dessus.
Copiez le code ci-dessus et collez-le dans Arduino IDE.
Si votre écran n'est pas un ST7789, changez la ligne d'écran. Voir le tableau ci-dessus.
Modifiez les paramètres 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 Serial Monitor dans Arduino IDE.

Appuyez une fois sur le bouton RESET.
L'écran affiche Starting camera..., puis l'image en direct apparaît.
Astuce pro : les couleurs semblent fausses ? Changez #define SWAP_BYTES true en false et téléversez de nouveau.

Serial Monitor

Le Serial Monitor vous indique combien d'images la carte dessine. 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-28 14:00:01] Display is ready [2026-09-28 14:00:02] Camera sensor: OV5640 (5 MP, max QSXGA 2592x1944) [2026-09-28 14:00:02] Showing the live picture on the display [2026-09-28 14:00:07] 61 pictures in 5 seconds (12.2 per second) [2026-09-28 14:00:12] 63 pictures in 5 seconds (12.6 per second) [2026-09-28 14:00:17] 62 pictures in 5 seconds (12.4 per second)

Ln 11, Col 1

ESP32S3 Dev Module on COM15

※ Note:

Environ 12 images par seconde est normal. La partie lente est le fil SPI vers l'écran, pas la caméra. Une image plus petite est plus rapide, et une image plus grande est plus lente.

Dépannage

L'écran est sombre, mais je vois une image faible quand j'éclaire dessus.

Le rétroéclairage est éteint. Vérifiez le fil LED / BL sur GPIO41, et vérifiez que initBacklight() est dans votre code.

Le rétroéclairage est faible, ou la carte redémarre quand l'écran s'allume.

Votre module d'écran demande plus de courant qu'une seule broche de l'ESP32 S3 ne peut en donner. Connectez plutôt LED / BL au 3,3V en même temps que VCC, et supprimez la ligne initBacklight(). Vous perdez alors le contrôle d'allumage et d'extinction, mais le rétroéclairage est toujours au maximum.

L'écran reste blanc ou reste noir.

Vérifiez les fils CS, DC et RESET. Ce sont les trois que l'on inverse le plus souvent.
Vérifiez le fil LED / BL sur GPIO41. Sans lui, le rétroéclairage reste éteint et vous ne voyez rien, même quand l'image est vraiment là.
Vérifiez que VCC est bien sur 3,3V.

Les couleurs sont fausses. Le ciel est orange, les visages sont bleus.

Changez #define SWAP_BYTES true en false et téléversez de nouveau.

L'image est à l'envers ou sur le côté.

Changez TFT_display.setRotation(1) en 0, 2 ou 3 jusqu'à ce que ça semble correct.

L'image est là mais très petite dans un coin.

Votre écran est plus grand que l'image, par exemple un ILI9488 de 320 x 480. C'est normal. Vous pouvez déplacer l'image vers le centre en changeant les deux premiers nombres de drawRGBBitmap(0, 0, ...).

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.

La vidéo est très lente, seulement 2 ou 3 images par seconde.

Assurez-vous que le PSRAM est sur OPI PSRAM, pas Disabled.
Utilisez des fils courts. Des fils de raccordement longs rendent le SPI lent et instable.
Essayez FRAMESIZE_QQVGA (160 x 120) pour voir si le câblage est le problème.

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.

Applications

Une caméra avec son propre écran n'a besoin ni de WiFi, ni de routeur, ni de téléphone. Voici des projets pratiques que vous pouvez construire avec ce code :

Caméra portable : une caméra et un écran avec une batterie externe, et vous pouvez l'emporter partout.
Loupe numérique : pointez-la vers un petit texte ou un circuit imprimé et lisez-le sur l'écran.
Caméra d'inspection : regardez à l'intérieur d'une machine, d'un tuyau ou d'une boîte sombre, et observez sur l'écran.
Judas de porte : un écran à l'intérieur de la maison montre qui est à la porte dehors.
Caméra de recul pour une voiture miniature : affichez l'image de l'arrière sur un petit écran.
Assistant microscope : placez la caméra sur une lentille et affichez l'image en grand.
Photobooth : laissez les gens se voir avant que la photo soit prise.
Robot avec un visage : donnez à un robot un écran qui montre ce qu'il voit.
Outil pédagogique : montrez aux étudiants comment l'image d'une caméra devient des pixels sur un écran.
Caméra dans un lieu sans réseau : une usine, une cave, ou un champ où le WiFi ne porte pas.

Vidéo

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

Défis

Débutant : écrivez le texte "LIVE" dans le coin de l'écran, par-dessus l'image.
Intermédiaire : ajoutez un bouton. Quand vous appuyez dessus, l'image se fige pendant trois secondes, comme une photo.
Avancé : ajoutez le logement de carte microSD. Quand vous appuyez sur le bouton, enregistrez l'image en fichier JPEG, et affichez "Saved!" à l'écran. N'oubliez pas d'utiliser esp_camera_reconfigure() pour basculer entre RGB565 et JPEG.

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 !