2021-12-14
md
Présentation du module ESP32-CAM
Le ESP32-CAM comme serveur video-> <-Radio internet avec le ESP32

Photo du module ESP32-CAM Comme son nom le laisse deviner, le module ESP32-CAM est basé sur le microcontrôleur ESP32 d'Espressif auquel est intégré une caméra vidéo. Pour un prix très modeste on obtient l'équivalent d'une caméra Wi-Fi bas de gamme idéale pour les bricoleurs.

Puisque ce type de module est disponible depuis au moins deux ans, il y a déjà de très nombreux articles sur ce sujet dont plusieurs sont offerts en français. Alors, encore une fois, ce billet ne prétend pas ajouter grand-chose. Ce n'est que le récit de mes premières expériences avec ce module acheté il y a plus d'un an sans but précis sauf celui d'atteindre le seuil de livraison gratuite. Ce n'est qu'à la suite de la lecture d'un article il y a deux semaines que l'idée d'installer le module dans le garage est venue. Avant de compléter ce projet, il fallait me familiariser avec le ESP32 que je ne connais pas bien.

Table des matières

  1. Système sur puce ESP32
  2. Historique des modules de caméra ESP32
  3. Le ESP32-CAM de AI Thinker
  4. Brochage du ESP32-CAM
  5. La caméra OV2640
  6. Connexions pour le téléversement du micrologiciel
  7. Blinks dans PlatformIO
  8. Blinks dans Arduino
  9. Autre croquis
  10. Conclusion

Système sur puce ESP32 toc

L'ESP32 est le second système sur puce avec radio Wi-Fi conçu par Espressif deux ans après le ESP8266. Il est donc naturel que l'on compare ces deux puces.

ESP32ESP8266
Processeurdouble coeurs 32-bit LX6 de Xtensa coeur unique 32-bit L106 de Xtensa
Fréquence80 à 240MHz 80 ou 160 MHz
Co-processeurULP-
Protocole WiFi802.11 b/g/n (2.4 Ghz)
Modes WiFiStation/SoftAP/SoftAP+Station/P2P
Vitesse du WiFi (802.11n)jusqu’à 150 Mbpsjusqu’à 72,2 Mbps
Protocoles de réseauIPv4, IPv6, SSL, TCP/UDP/HTTP/FTP/MQTTIPv4, TCP/UDP/HTTP/MQTT
Bluetooth4.2 BR/EDR et BLE-
Mémoire statique520 Ko160 Ko
Mémoire RTC16 Ko-
ROM448 Ko0
Mémoire flash sécuriséOTP 1024-bit (démarrage sécuritaire crypté)-
CryptographieRSA, RNG, EEC, SHA-2, AES-
Entrées/sorties3617
CDA (convertisseur digital à analogue)2 canaux 8 bits-
CAD (convertisseur analogue à digital)18 canaux de 9 à 12 bits1 canal 10 bits
Référence ADC V1100mV
SPI/I2C/I2S/UART/CAN4/2/2/3/12/1/2/2/0
PMW8 canaux matériels0
Capteurs tactiles8 canaux0
Capteur de température10
Capteur à effet Hall10
Plage de température de fonctionnement-40°C ~ +85°C-40°C ~ 125°C
Tension de fonctionnement2,5V ~ 3,6V
Courant de fonctionnement moyenne80 mA
Courant en deep sleep10 uA20 uA
Dimension6x6 mm5x5 mm
Source

En réalité, ESP32 créé en 2016 dénote maintenant le premier membre d'une famille de systèmes sur puce. Le ESP-S2 est disponible depuis 2019. Cette version est moins puissante, car elle est basée sur le processeur 32-bits à simple coeur LX7 de Xtensa, à moins de mémoire et moins de connectivité dont l'absence de Bluetooth. Le ESP32-C3 qui date de 2020 et qui semble être destiné à remplacer le ESP8266 puisqu'il a le même brochage, est basé sur un processeur 32-bits à simple coeur RISC-V et implémente Bluetooth BLE 5.

Pour compliquer un peu, il y a plus d'une « revision » du ESP32. Actuellement, c'est la revision 3 qui est en production, mais une grande proportion des dispositifs couramment sur le marché est équipée du ESP32 revision 1.

Puce ESP32 format QFN Le ESP32, disponible dans un boîtier QFN48 dont la taille est un minuscule 6mm carré, est trop petit pour être facilement manipulé. Heureusement, Espressif et d'autres fabricants produisent différents modules contenant la puce ESP32, un oscillateur à cristal, une mémoire flash typiquement de 4 Mo et quelques composants passifs, dont une antenne intégrée ou un connecteur pour une antenne externe. On peut voir une représentation d'un tel module, le ESP32-WROOM, sans son couvert métallique ce qui révèle les composants. Ce couvert est probablement nécessaire pour obtenir la certification FCC. Cette certification est coûteuse et complexe, mais dès que le fabricant du module l'obtient il n'est pas nécessaire d'obtenir une nouvelle certification pour tout dispositif le contenant. De plus, le support de ces modules est une mince carte dont les créneaux de bord rendent facile le brasage sur un circuit imprimé. Conséquemment, des cartes dites de développement constituées d'un module comme le ESP32-WROOM, d'un connecteur USB, d'un convertisseur USB-TTY, d'un ou deux boutons-poussoirs, d'un régulateur de tension, de quelques composants passifs et des connecteurs en broche compatibles avec les platines d'expérimentation pullulent. Il me semble qu'il a nettement plus de ces cartes ESP32 qu'il y a de cartes ESP8266. Il y a aussi des dispositifs plus complexes; Espressif a développé une carte avec un connecteur Ethernet, une autre spécialisée dans le traitement du son digital (I2S) et une qui prend en charge des caméras. C'est évidemment cette dernière qui nous intéresse ici.

Historique des modules de caméra ESP32 toc

Photos recto/verso du ESP-EYE Pour autant que je sache, c'est Espressif, qui a élaboré la première carte de développement ESP32 avec caméra intégré. Le ESP-EYE a été enregistré auprès du FCC en mars 2019, mais il devait être disponible en fin 2018. Puisque cette carte contient un microphone intégré aussi, elle est indiquée comme prototype pour les sonnettes de porte sans fil. Ce module est toujours offert par d'importants distributeurs dont Digikey et Mouser. Espressif n'est pas un fabricant de matériel électronique, mais un concepteur sans usine (fabless) ce qui explique qu'il ait rendu public le schéma du ESP-EYE. Ai-Thinker a repris le projet et développer le ESP32-CAM dont il est question ici. Le module est moins cher que le ESP-EYE, mais en contrepartie le matériel audio ainsi que l'interface USB ont été éliminés. Cependant, il ajoute un lecteur de cartes de mémoire microSD. Depuis, M5Stack et LLILYGO ont présenté divers modèles plus évolués que le ESP32-CAM avec interface USB, microphone, capteur infrarouge, bouton, écran LCD et autres options avec des coûts additionnels en conséquence.

On retrouve plusieurs clones du ESP32-CAM de Ai-Thinker sur le marché. Il me semble bien que la version que je possède en soit un, car ce n'est pas le logo d'Ai-Thinker, mais plutôt celui de Espressif avec le libellé ESP32-S qui est sur le boitier du microcontrôleur. De plus, il n'y a pas de numéro d'enregistrement FCC même si le sigle y est. Selon Wikipedia le ESP32-S de Ai-Thinker est l'équivalent du ESP-WROOM-32 d'Espressif tant pour ce qui est de ses dimensions physiques que pour ses caractéristiques électriques. Puisqu'il est fort douteux qu'Espressif utilise le nom ESP32-S, l'identification du fabricant du module n'est pas possible avec un simple examen visuel.

Le ESP32-CAM de AI Thinker toc

Le graphique ci-dessous expose la disposition des composants les plus importants de cette carte de développement.

recto et verso de la carte avec composants

En plus du module ESP32-S de AI Thinker, on retrouve sur cette carte un régulateur de tension d'approximativement 5 volts vers 3,3 volts qui est la tension requise par le ESP32. Il y a un bouton-poussoir de réinitialisation étiqueté RST (du mot reset ou restart). Il n'y a pas de bouton-poussoir pour mettre le ESP32 en mode programmation, on verra plus tard comment cela se fait. On retrouve aussi un diode électroluminescente (DEL ou LED pour les anglophiles) rouge. Celle-ci est reliée à l'entrée/sortie (E/S) 33 du microcontrôleur. Enfin il y a une mémoire sérielle pseudostatique (PSRAM). Il s'agit de la puce ESP PSRAM64H, qui a une capacité de 8 Mo.

Y a-t-il quatre ou huit méga-octets de PSRAM à bord ? La version chinoise de la fiche technique de Ai Thinker, ESP32-CAM Wi-Fi+BT SoC 模组 V1.0, chiffre la quantité de PSRAM à 8Mo alors qu'on retrouve 4Mo dans la traduction, ESP32-CAM Wi-Fi+BT SoC Module V1.0, et ailleurs sur le web. En fait, il n'y a aucun doute que le dispositif a une capacité de 8 Mo, mais si j'ai bien compris, les fonctions d'allocation de mémoire malloc() et free() n'ont accès qu'aux quatre premiers méga-octets.

Au verso, il y a un lecteur de carte de mémoire de type microSD (auparavant dénommé TF, T-Flash ou TransFlash pour une technologie dont est dérivée la norme microSD), une DEL qui émet une lumière d'un blanc très intense qui sert de flash et un connecteur pour le câble plat flexible de la caméra. L'entrée/sortie 4 du ESP32 contrôle le flash à l'aide d'un transistor vu le courant nécessaire au fonctionnement de cette DEL. Les deux autres puces qui ressemblent à des transistors sont en fait des régulateurs de tension pour alimenter la caméra.

On allume la DEL rouge en ramenant la sortie 33 du ESP32 à la masse (soit à LOW ou 0 (volt) si l'on préfère). En revanche, il faut que la sortie 4 soit à 3,3 volts (HIGH ou 1) pour allumer la DEL flash. L'entrée/sortie 4 utilisée pour contrôler l'état de la DEL flash est aussi connectée au signal DATA1 du lecteur microSD. Le résultat est paradoxal, car si l'on conserve des images provenant de la caméra intégrée sur une carte microSD, le flash sera activé pendant le transfert des données. Cet arrangement est maladroit et il me semble qu'il serait préférable que l'entrée/sortie 33 contrôle la DEL flash indépendamment de tout autre périphérique. C'est la DEL rouge qui devrait être en parallèle avec le bus de données du lecteur de carte microSD ou avec l'entrée ou peut-être la sortie du port sériel, de préférence en passant par une résistance de 0 ohm pour faciliter sa déconnexion si désirée. N'étant pas expert, je n'insiste pas, car il y a peut-être des contre-indications à cette proposition.

Brochage du ESP32-CAM toc

P1 et P2 sont deux connecteurs de broche mâle, dont l'écart et le pas(2,54mm ou 0.1") sont tels que la carte peut être enfichée sur une platine d'expérimentation. Lorsqu'on présente les connexions d'une carte de développement, l'usage est de le faire côté microcontrôleur.

connexions du ESP32-CAM côté ESP32-S

Or le ESP32-S sera invisible si le carte de développement est branchée sur une platine d'expérimentation. Dès lors, c'est le côté caméra qui est visible et il est plus pratique de voir le brochage de ce point de vue. D'ailleurs c'est sur ce côté que sont imprimés les noms des broches.

connexions du ESP32-CAM côté ESP32-S

Si en principe on peut alimenter la carte avec 3,3 volts ou 5 volts, en pratique seuls 5 volts assurent un fonctionnement stable. D'ailleurs, cette carte est énergivore et un article suggérait l'utilisation d'une alimentation de 10 watts (5 volts à 2 ampères) ce qui me semble un peu excessif. Cependant, il est notoire que la transmission Wi-Fi exige des pics de courants et plusieurs recommandent l'addition de condensateurs le plus près possible de l'alimentation des cartes de développement basées sur le ESP32. Selon Ai-Thinker, il devrait y en avoir deux comme on peut le voir sur la figure ci-dessous tirée de la dernière page de da description technique du ESP32-CAM.

conditionnement du l'alimentation photographie de la connexion Vcccircuit de Vcc

La broche P1-4, étiquetée Vcc, est une sortie qui ne doit pas être utilisée pour alimenter le dispositif. La tension de cette sortie, par défaut 3,3 volts, est fixée selon l'emplacement d'une toute petite résistance de 0 ohm. Cet arrangement est l'équivalent d'un chevalier monté sur des plots pour choisir entre une sortie de 5 volts (si possible) et une sortie de 3,3 volts. Sur la carte que je possède, les libellés 3V3 et 5V ne sont pas visibles. La photographie provient de l'excellent article ESP32-CAM AI-Thinker Pinout Guide: GPIOs Usage Explained. Le circuit de la broche Vcc est tiré de la version 1.6 du schéma du ESP32_CAM de Ai-Thinker.

Le tableau suivant montre les connexions entre le module ESP32-S et les autres composants principaux de la carte de développement incluant les connecteurs.

ESP32-SPSRAMCaméraLecteur TFMatérielConnecteurs
No.NomTypeFonction
1GNDPGround
23.3VPPower SupplyP1-8
3ENIENABLERST button
4SENSOR_VPIGPIO36, ADC1_CH0D4
5SENSOR_VNIGPIO39, ADC1_CH3D5
6IO34IGPIO34, ADC1_CH6D6
7IO35IGPIO35, ADC1_CH7D7
8IO32I/OGPIO32, XTAL_32K_PPOWER PIN
9IO33I/OGPIO33, XTAL_32K_NLED1
10IO25I/OGPIO25, DAC_1VSYNC
11IO26I/OGPIO26, DAC_2SDA
12IO27I/OGPIO27, ADC2_CH7SCL
13IO14I/OGPIO14, ADC2_CH6CLKP2-3
14IO12I/OGPIO12, ADC2_CH5DATA2P2-6
15GNDPGround
16IO13I/OGPIO13, ADC2_CH4DATA3P2-5
17SHD/SD2*I/OGPIO9, SD_DATA2SIO3
18SWP/SD3*I/OGPIO10, SD_DATA3SIO2
19SCS/CMD*I/OGPIO11, SD_CMD
20SCK/CLK*I/OGPIO6, SD_CLK
21SDO/SD0*I/OGPIO7, SD_DATA0SIO1
22SDI/SD1*I/OGPIO8, SD_DATA1SIO0
23IO15I/OGPIO15, ADC2_CH3CMDP2-4
24IO2I/OGPIO2, ADC2_CH2DATA0P2-2
25IO0I/OGPIO0, ADC2_CH1XCLKP1-6
26IO4I/OGPIO4, ADC2_CH0DATA1LED_FLASHP2-1
27IO16I/OGPIO16, HS1_DATA4CS#P1-7
28IO17I/OGPIO17, HS1_DATA5SCLK
29IO5I/OGPIO5, VSPICS0D0
30IO18I/OGPIO18, VSPICLKD1
31IO19I/OGPIO19, VSPIQD2
32NC -
33IO21I/OGPIO21, VSPIHDD3
34RXD0I/OGPIO3, U0RXDP1-3
35TXD0I/OGPIO1, U0TXDP1-2
36IO22I/OGPIO22, VSPIWPPCLK
37IO23I/OGPIO23, VSPIDHREF
38GNDPGround
Autres broches des connecteurs5V entrantP2-8
3.3V entrantP1-8
Vcc sortantP1-4
MasseP1-1
P1-5
P2-7

Le bus SPI, identifié avec l'astérisque *, est connecté en parallèle à la mémoire pseudostatique et la mémoire flash à l'intérieur du module ESP32-S et les deux E/S (19 et 20) qui ne semblent pas utilisées sont en fait branchées à la mémoire flash. Toutes les entrées sorties du microcontrôleur ESP32 sont utilisées à l'exception des ports 1, 3 et 16. En d'autres mots, si la caméra et le lecteur microSD sont activés, cette carte de développement offre peu de connexions externes. Si le lecteur TF n'est pas activé, on gagne 6 connexions. Si la caméra n'est pas activée on a une seule connexion supplémentaire facilement exploitée, car toutes les autres entrées sorties de la caméra ne sont atteignables qu'avec le connecteur de câble plat.

La caméra OV2640 toc

Le plus souvent, la carte est livrée avec un capteur d'images OV2640 d'OmniVision qui a été introduit en 2005 et dont la production a cessé en 2009 (source: OV2640 – Specs, Datasheets, Cameras, Features, Alternatives. Voici ses caractéristiques.

capteur2 mega pixels
résolutionde 96×96 à 1600×1200 pixels
format de sortieYUV422, YUV420, RGB565, RGB555 et compression de données 8 bits
cadence15 à 60 images à la seconde
champ de vue52°

Il y a une relation inverse entre la résolution et la cadence du flux vidéo provenant de cette caméra. Selon un document récupéré chez un vendeur de composants électroniques bien connu, la table suivante est valable pour un module semblable fabriqué pare M5Stack.

résolutioncadence maximum
UXGA1600×120015 i/s
SXGA1280×102415 i/s
SVGA800×60030 i/s
CIF400×29660 i/s

D'autres capteurs d'images sont compatibles avec le ESP32-CAM dont les modèles OV3660 et OV5640 de OmniVision qui ont respectivement 3,3 et 5 millions de pixels. Et il semble qu'il soit possible d'obtenir le ESP32-CAM avec un capteur d'image compatible avec une lentille grand angle.

Connexions pour le téléversement du micrologiciel toc

On peut se servir d'un Arduino UNO pour programmer un module ESP32; techstudycell montre comment procéder dans un article intitulé Program ESP32-CAM using Arduino UNO. On peut sans doute le faire avec un Raspberry Pi comme je l'avais fait pour le ESP8266. Le plus simple est d'utiliser un adaptateur USB-TTL 3,3 volts comme illustré ci-dessous.

connexions 3,3 volts seulement pour la programmation de l'ESP32-CAM

Attention de placer le cavalier sur les bons plots de l'adaptateur pour que la tension de ses signaux soit limitée à 3,3 volts. Il se peut que le ESP32, qui fonctionne sur 3,3 volts, tolère 5 volts sur ses entrés, mais aussi bien ne rien risquer. Attention aussi d'inverser les connexions pour que le signal transmis par un dispositif soit acheminé à la broche de réception de l'autre dispositif. Donc les liens à faires sont TXD---UORXD et RXD---U0TXD. J'ai pu téléverser divers croquis vers le ESP avec cet arrangement. Toutefois il s'est avéré impossible de faire fonctionner la caméra ce qui rendait la vérification du bon fonctionnement de certains micrologiciels plus difficile. Comme mentionné ci-dessus, il faut alimenter le ESP32-CAM avec 5 volts avec de préférence des capacitances supplémentaires entre l'alimentation et la masse si l'on veut un comportement stable.

connexions pour la programmation de l'ESP32-CAM avec alimentation 5 volts

On pourrait essayer le schéma montré ci-dessus avec un adaptateur USB - TTY qui avec une sortie de 5 volts tirée du port USB. Je n'ai pas essayé cette configuration sachant qu'il est très peu probable qu'elle fonctionne, car le port USB de mon ordinateur n'est pas en mesure de fournir un courant suffisant. En principe, le port devrait être capable de fournir 1 ampère à 5 volts, mais il est protégé par une carte d'isolation basée sur le ADUM3160 qui est elle-même alimentée depuis le port USB. On peut utiliser un deuxième port USB de l'ordinateur pour l'alimentation, j'ai choisi de préférence une batterie externe ce qui a l'avantage de ne pas réduire la protection des ports USB de l'ordinateur.

connexions pour la programmation de l'ESP32-CAM

J'ai finalement abandonné l'utilisation de la batterie parce qu'elle arrêtait d'alimenter la carte de développement lors des téléversements de micrologiciels plus volumineux. J'en ai conclu que le courant consommé par le ESP32-CAM lors de ces téléversements est tellement faible que la batterie coupait le courant pour préserver sa charge. Un chargeur secteur pour téléphone de 1 A fonctionne très bien à la place de la batterie. Il n'est pas nécessaire d'ajouter les condensateurs recommandés par Espressif. Il faudra quand même les ajouter plus tard pour voir si leur présence éliminerait les nombreux artefacts du flux vidéo éventuellement causés par l'utilisation concurrente du Wi-Fi.

Pour mettre le ESP32 dans le mode programmation, il faut que la broche E/S 0 soit raccordée à la masse lors du démarrage de la puce. Un bouton-poussoir avec autoverrouillage est peut-être la meilleure façon de réaliser cette connexion, mais on peut le remplacer avec un cavalier ou un câble Dupont. On peut aussi utiliser un bouton-poussoir momentané, car la connexion à la masse n'est nécessaire que pendant quelques secondes au démarrage; dès que l’ESP est en mode programmation on peut couper la connexion à la masse sans conséquences.

Pour redémarrer la puce au besoin, il suffit d'appuyer sur le bouton de réinitialisation RST du ESP32-CAM. Malheureusement, il sera difficile de rejoindre ce bouton si la carte de développement est fixée sur une platine d'expérimentation. Dans ce cas on peut débrancher l'alimentation 5 volts puis, avec E/0 connecté à la masse, rebrancher l'alimentation. On pourrait faire plus élégant en ajoutant un second bouton poussoir avec auto-verrouillage ou un interrupteur sur le câble d'alimentation.

Blink dans PlatformIO toc

Traditionnellement, l'apprivoisement d'une nouvelle carte de développement commence avec le clignotement d'une DEL avec le croquis Blink. C'est l'équivalent du « Hello World! » qui est le premier programme qu'on élabore quand on s'initie à un langage de programmation. Je préfère l'environnent de programmation PlatformIO à celui d'Arduino. Ceux qui préfèrent l'EDI Arduino ou qui commencent peuvent consulter la section suivante.

Icônes de PlatformIO dans Codium PlatformIO ajoute six icônes dans la barre de statut de Visual Studio (ou VSCodium). Pour créer un nouveau projet nommé Blinks (notez le pluriel) on clique sur l'icône d'accueil de PIO et puis on clique sur le bouton New Project. Voici ce que j'ai saisi dans la fenêtre Project Wizard.

Et pour la localisation du projet, j'ai saisi le dossier ~/Documents/PlatformIO/Projects/esp32/, car je préfère répartir mes projets dans une hiérarchie de répertoires plus ou moins L'environnement a créé automatiquement les fichiers de base à partir desquels on peut construire le projet.

michel@hp:~/Documents/PlatformIO/Projects/esp32/Blinks$ tree --dirsfirst
. ├── include │   └── README ├── lib │   └── README ├── src │   └── main.cpp ├── test │   └── README └── platformio.ini

À noter que deux autres répertoires et un fichier, tous cachés qu'il n'est pas nécessaire d'examiner, sont créés dans le dossier ~/Documents/PlatformIO/Projects/esp32/Blinks. En réalité je n'ai pas eu à créer ce projet, puisque je l'avais fait auparavant pour deux autres cartes de développement. J'ai simplement eu à ajouter le ESP32-CAM dans le fichier de configuration platformio.ini. On peut voir cet ajout dans la dernière section du fichier intitulé [env:esp32cam].

[platformio] default_envs = esp32cam [extra] baud = 115200 [env] platform = espressif32 framework = arduino monitor_speed = ${extra.baud} [env:esp32dev] board = esp32dev build_flags = -D BAUD=${extra.baud} -D LED_ON=HIGH -D LED_BUILTIN=2 [env:esp32doit-devkit-v1] board = esp32doit-devkit-v1 monitor_speed = ${extra.baud} build_flags = -D BAUD=${extra.baud} -D LED_ON=LOW ;LED_BUILTIN set in board definition [env:esp32cam] board = esp32cam red_led = 33 ; standard red LED on same side as ESP32 module red_led_on = LOW flash_led = 4 ; white flash LED on same side as microSD card reader flash_led_on = HIGH build_flags = -D BAUD=${extra.baud} -D LED_ON=${env:esp32cam.red_led_on} -D LED_BUILTIN=${env:esp32cam.red_led}

J'ai aussi modifié l'environnent par défaut dans la première section intitulée [platformio] pour spécifier que le micrologiciel est destiné au ESP32-CAM. Puisque la valeur qui allume la DEL peut être LOW ou HIGH, la macro LED_ONest définie dans les paramètres de chaque carte du fichier de configuration platformio.ini et puisque l'entrée/sortie qui contrôle la DEL est différente d'une carte à l'autre la macro LED_BUILTIN est également définie dans les paramètres de chaque carte de développement. À noter que LED_BUILTIN est déjà définie dans la définition de base d'une carte de développement comme la carte ESP32 de Doit.

Il n'est pas nécessaire de définir la valeur qui éteint la DEL dans le fichier de configuration, car il s'agit du complément de LED_ON qui est facilement calculé et consigné dans la macro LED_OFF dans le croquis. Il y a deux DEL sur le ESP32-CAM alors les entrées/sorties qui leur sont associées sont définies dans la section [env:esp32cam]. On peut choisir à laquelle de ces DELs LED_BUILTIN fait référence. Et il faut ajuster LED_ON en conséquence.

Le croquis Blinks, qui est dans le fichier source/main.cpp, étant déjà écrit, il ne restait qu'à téléverser le micrologiciel exécutable sur le ESP32-CAM. Avant j'ai ouvert le moniteur série dans l'environnement PlatformIO en cliquant sur l'icône appropriée.

--- Miniterm on /dev/ttyUSB0 115200,8,N,1 --- --- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H --- ets Jun 8 2016 00:22:57

Après avoir redémarré la carte alors que E/S 0 était connecté à la masse, les messages suivants s'affichent dans le terminal.

rst:0x1 (POWERON_RESET),boot:0x3 (DOWNLOAD_BOOT(UART0/UART1/SDIO_REI_REO_V2)) waiting for download

Dès que waiting for download est affiché, il n'est plus nécessaire de maintenir E/S 0 à la masse. Puisque le ESP32 est en attente du micrologiciel, c'est alors qu'il faut procédé à son téléversement en cliquant sur l'icône (upload) qui se charge de la compilation si nécessaire.

... Auto-detected: /dev/ttyUSB0 Uploading .pio/build/esp32cam/firmware.bin esptool.py v3.1 Serial port /dev/ttyUSB0 Connecting.... Chip is ESP32-D0WD (revision 1) Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None Crystal is 40MHz MAC: f4:cf:a2:xx:xx:xx Uploading stub... Running stub... Stub running... Changing baud rate to 460800 Changed. Configuring flash size... Auto-detected Flash size: 4MB Flash will be erased from 0x00001000 to 0x00005fff... Flash will be erased from 0x00008000 to 0x00008fff... Flash will be erased from 0x0000e000 to 0x0000ffff... Flash will be erased from 0x00010000 to 0x00052fff... Compressed 17104 bytes to 11191... Writing at 0x00001000... (100 %) Wrote 17104 bytes (11191 compressed) at 0x00001000 in 0.6 seconds (effective 229.3 kbit/s)... Hash of data verified. Compressed 3072 bytes to 119... Writing at 0x00008000... (100 %) Wrote 3072 bytes (119 compressed) at 0x00008000 in 0.1 seconds (effective 291.1 kbit/s)... Hash of data verified. Compressed 8192 bytes to 47... Writing at 0x0000e000... (100 %) Wrote 8192 bytes (47 compressed) at 0x0000e000 in 0.1 seconds (effective 462.3 kbit/s)... Hash of data verified. Compressed 272128 bytes to 127444... Writing at 0x00010000... (12 %) Writing at 0x00025ea4... (25 %) Writing at 0x0002ca18... (37 %) Writing at 0x00032376... (50 %) Writing at 0x00039532... (62 %) Writing at 0x000419ac... (75 %) Writing at 0x00048012... (87 %) Writing at 0x0004db18... (100 %) Wrote 272128 bytes (127444 compressed) at 0x00010000 in 3.7 seconds (effective 592.5 kbit/s)... Hash of data verified. Leaving... Hard resetting via RTS pin... ======================================================= [SUCCESS] Took 6.68 seconds ======================================================= Environment Status Duration ------------- -------- ------------ esp32cam SUCCESS 00:00:06.683 ======================================================= 1 succeeded in 00:00:06.683 =======================================================

Comme on peut voir, le micrologiciel du ESP32-CAM était remplacé en moins de 7 secondes. Il faut redémarrer le ESP32-CAM en appuyant sur son bouton-poussoir RST. Il sera peut être nécessaire de redémarrer le moniteur série de PlatformIO pour voir que le croquis fonctionne.

Blinks LED_BUILTIN (33) set to OUTPUT. The LED is turned on by writing LOW to the pin. Blink setup() completed. Starting loop(). On, On, On, OFF... On, On, On, OFF... On, On, On,

Voici le croquis lui-même, qui est un peu plus complexe que les versions élémentaires comme dans Blink Interactive Tutorial.

#include <Arduino.h> //parameters that can be adjusted : #define CYCLES 3 // number of consecutive flashes (on-off cycles) in each burst #define FLASH_TIME 100 // period of LED on then off time (in ms) per flash in the burst #define OFF_TIME 1900 // period of time (in ms) the LED is off between bursts //do not change this #define LED_OFF 1-LED_ON void setup() { Serial.begin(BAUD); // wait up to 3 seconds for serial device to come up while (!Serial && millis() < 3000) delay(10); // initialize LED digital pin as an output. pinMode(LED_BUILTIN, OUTPUT); Serial.println("\n"); Serial.println("Blink"); Serial.print("LED_BUILTIN ("); Serial.print(LED_BUILTIN); Serial.println(") set to OUTPUT."); Serial.print("The LED is turned on by writing "); Serial.print((LED_ON) ? "HIGH" : "LOW"); Serial.println(" to the pin."); Serial.println("Blink setup() completed."); Serial.println("Starting loop().\n"); } void loop() { for (int i=0; i<CYCLES; i++) { digitalWrite(LED_BUILTIN, LED_ON); Serial.print("On, "); delay(FLASH_TIME); digitalWrite(LED_BUILTIN, LED_OFF); delay(FLASH_TIME); } Serial.println("OFF..."); delay(OFF_TIME); }

Au lieu d'allumer et d'éteindre la DEL pour des périodes égales à une fréquence très lente, il y a d'abord une rafale de clignotements rapides puis la DEL s'éteint pendant une période plus longue avant de recommencer le cycle. Le nombre de clignotements rapides est fixé par la macro CYCLES, la période pendant laquelle la DEL est allumée et éteinte est fixée par la macro ON_TIME. La durée de temps plus longue pendant laquelle la DEL est éteinte entre les rafales de clignotements est donnée par la macro OFF_TIME. Cette asymétrie permet de vérifier que l'on a correctement identifié la valeur du signal qui allume la DEL.

Ce croquis est disponible ici : blinks-pio.zip.

Blinks dans Arduino toc

La version 1.8.18 de l'EDI Arduino est actuellement disponible et il y a déjà un candidat stable de la version 2.0 qui sera intéressante à regarder. Cependant, pour le moment, c'est la version 1.18.13 qui sur mon ordinateur. Je suppose que l'EDI est entièrement fonctionnel, mais que le paquet ESP32 n'a pas été installé. La première étape pour compiler le programme Blink obligatoire consiste à fournir l'URL du fichier de définition de paquet ESP32 au gestionnaire de cartes. On commence en ouvrant la fenêtre Preferences. Cliquez sur le menu Files, puis sélectionnez le menu Arduino IDE Preference comme indiqué dans les deux images suivantes.

Arduion IDE File / Preferences menu selection

Arduino IDE Preferences window

Si la zone de texte Additonal Boards Manager URLs de la fenêtre Preferences est vide, l'URL peut être saisie directement. Si elle contient déjà une URL, cliquez sur le bouton à droite pour ouvrir l'éditeur

Arduino IDE adding EPS32 package in the boards manager

Voici la fenêtre, intitulée Additional Boards Manager URLs, dans laquelle la URL

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

est facilement insérée. Chaque URL doit être sur une ligne distincte, mais leur ordre n'a aucune importance.

L'étape suivante consiste à enfin télécharger le noyau ESP32 dans l'environnement de programmation. Cliquez sur le menu Tools, puis sélectionnez Board: "Arduino Yun" (le nom de la carte n'a pas d'importance). Dans le sous-menu qui apparaît à droite, cliquez sur le premier choix Boards Manager...

Arduino IDE Tools / Board: / Boards Manager... menu selection

Dans la fenêtre contextuelle Boards Manager, recherchez le esp32 by Espressif Systems. Il peut être utile de saisir esp32 dans le filtre de recherche en haut. Cliquez sur le bouton Install.

installing the ESP32 package

La dernière version du noyau arduino-esp32 d'Espressif sera installée, soit la version 2.0.1 à partir de décembre 2021. Une fois cela terminé, il est temps de sélectionner la carte Ai Thinker ESP32-CAM. Cliquez à nouveau sur le menu Tools, puis sélectionnez Board: "Arduino Yun" (comme avant, le nom de la carte n'a pas d'importance). Dans le sous-menu qui apparaît à droite, cliquez sur le ESP32 Arduino cette fois.

selecting board

Il faut un peu de patience pour retrouver Ai Thinker ESP32-CAM dans la longue de liste de cartes affichés sans aucun ordre apparent.

AI Thinker ESP32-CAM selected and empty sketch compiled

Le nom de la carte choisie est affiché en bas de la fenêtre de l'EDI et puisque le convertisseur USB-TTY était déjà branché sur l'ordinateur de bureau, on peut voir le nom du périphérique qui sera utilisé pour téléverser éventuellement un micrologiciel (soit le croquis compilé) vers la carte de développement. Comme on peut voir, j'ai immédiatement compilé le croquis vide en cliquant sur la première icône de la barre des outils (voir la figure ci-dessous). Il y a d'autres façons de lancer la compilation : avec le menu de l'EDI, Croquis/Vérifier/Compiler (Sketch/Verify/Compile), ou avec la combinaison de touches CtrlR.

Icônes de l'EDI Arduino

Selon ce qu'affiche la fenêtre de messages, la compilation s'est complétée sans problèmes.

En réalité, la première fois que j'ai essayé de compiler le croquis, l'opération s'est soldée par un échec parce qu'il manquait le module serial. Une petite recherche sur le web a vite apporté une solution, le module Python nommé pyserial n'était pas installé. C'est dans l'environnent Python 3 qu'il faut installer ce module. En premier, j'ai vérifié que c'est bien cette version qui roule par défaut, car j'ai eu des difficultés à ce sujet auparavant. Puisque c'était le cas, il a été possible d'installer le module manquant.

michel@hp:~$ pip3 -V pip 20.0.2 from /usr/lib/python3/dist-packages/pip (python 3.8) michel@hp:~$ pip -V pip 20.0.2 from /usr/lib/python3/dist-packages/pip (python 3.8) michel@hp:~$ pip install pyserial Collecting pyserial Using cached pyserial-3.5-py2.py3-none-any.whl (90 kB) Installing collected packages: pyserial Successfully installed pyserial-3.5

Pour éviter un autre problème rencontré auparavant dans Linux, il faut s'assurer que l'utilisateur est un membre du groupe dialout.

michel@hp:~$ groups michel adm dialout cdrom sudo dip plugdev lpadmin ...

Si le groupe n'apparaît pas dans la liste, rajoutez-le.

michel@hp:~$ sudo adduser $USER dialout ...

Même si la commande se termine en indiquant que l'addition est complétée, elle ne prendra effet qu'à la prochaine session. Donc pour continuer il faudra fermer la session courante et en ouvrir une nouvelle ou bien redémarrer l'ordinateur.

Si ces deux procédures ne règlent pas le problème, consultez Problem with “No module named serial” dans Getting started with ESP32 de DroneBot Workshop. J'espère sincèrement qu'il ne sera pas nécessaire de faire quelque chose d'aussi complexe, que je n'ai pas testé d'ailleurs.

Supposant maintenant qu'il a été possible de compiler le croquis vide, on peut maintenant passer au croquis Blinks. Sauvegarder le croquis vide sous le nom blinks dans le répertoire sketchbook ou ailleurs selon vos préférences. L'EDI créera un répertoire nommé blinks et sauvegardera le croquis vide dans un fichier nommé blinks.ino dans le nouveau répertoire.

Remplaçons le contenu du croquis vide.

#include "ini.hpp" //parameters that can be adjusted : #define CYCLES 3 // number of consecutive flashes (on-off cycles) in each burst #define FLASH_TIME 100 // period of LED on then off time (in ms) per flash in the burst #define OFF_TIME 1900 // period of time (in ms) the LED is off between bursts //do not change this #define LED_OFF 1-LED_ON void setup() { Serial.begin(BAUD); // wait up to 3 seconds for serial device to come up while (!Serial && millis() < 3000) delay(10); // initialize LED digital pin as an output. pinMode(LED_BUILTIN, OUTPUT); Serial.println("\n"); Serial.println("Blink"); Serial.print("LED_BUILTIN ("); Serial.print(LED_BUILTIN); Serial.println(") set to OUTPUT."); Serial.print("The LED is turned on by writing "); Serial.print((LED_ON) ? "HIGH" : "LOW"); Serial.println(" to the pin."); Serial.println("Blink setup() completed."); Serial.println("Starting loop().\n"); } void loop() { for (int i=0; i<CYCLES; i++) { digitalWrite(LED_BUILTIN, LED_ON); Serial.print("On, "); delay(FLASH_TIME); digitalWrite(LED_BUILTIN, LED_OFF); delay(FLASH_TIME); } Serial.println("OFF..."); delay(OFF_TIME); }

Ce croquis est essentiellement celui élaboré dans l'environnement PlatformIO. On notera l'absence de l'inclusion de Arduino.h au tout début du croquis, c'est nécessaire quand la compilation se fait dans PlatformIO, mais pas dans l'EDI Arduino. Il y a des macros, comme BAUD et LED_ON, qui étaient définies dans le fichier de configuration platformio.ini. Puisque l'EDI Arduino n'a pas de tel fichier, il faut créer l'équivalent. La directive au début du croquis #include "ini.hpp" révèle le nom de ce fichier. Pour ajouter un fichier au projet, on clique sur l'icône du menu des onglets à l'extrême droite de la ligne des onglets et l'on choisi la première option Nouvel onglet (New Tab).

Il faut saisir le nom de fichier dans la zone de texte nommée Name for new file: dans la barre safran. L'EDI n'accepte que certaines extensions des programmes C, C++ et Arduino dont .c, .h, .cpp, .hpp et .ino. D'ou l'extension .hpp qui dénote les fichiers d'en-tête C++. Voici son contenu.

#ifndef INI_HPP #define INI_HPP // common macros #define BAUD 115200 // Select one and only one board //#define ESP32_DEV //#define ESP32_DOIT_DEVKIT_V1 #define ESP32_CAM // board dependant macros #if defined(EPS32_DEV) #define LED_ON HIGH #define LED_BUILTIN 2 #endif #if defined(ESP32_DOIT_DEVKIT_V1) #define LED_ON LOW #define LED_BUILTIN 2 #endif #if defined(ESP32_CAM) #define RED_LED 33 // standard red LED on same side as ESP32 module #define RED_LED_ON LOW #define FLASH_LED 4 // white flash LED on same side as microSD card reader #define FLASH_LED_ON HIGH #define LED_ON FLASH_LED_ON #define LED_BUILTIN FLASH_LED #endif #endif

Si le ESP32-CAM est branché à l'alimentation et à l'ordinateur de bureau avec un câble convertisseur USB-UART on peut téléverser le croquis. Commençons en démarrant le moniteur série de l'EDI. Le plus simple est d'activer l'icône sur la barre des outils. On peut aussi avoir recours au menu de l'application Outils / Moniteur série (Tools / Serial Monitor).

Arduino IDE open serial monitor

Enfin, on peut utiliser la combinaison de touches de clavier CtrlMajM pour lancer le moniteur. N'oubliez pas qu'il faut préalablement mettre le ESP32 en mode programmation connectant l'entrée/sortie 0 à la masse puis en appuyant sur le bouton RST. Garder E/S 0 à la masse jusqu'à ce que le message suivant soit affiché dans le moniteur.

rst:0x1 (POWERON_RESET),boot:0x3 (DOWNLOAD_BOOT(UART0/UART1/SDIO_REI_REO_V2)) waiting for download

Cela ne devrait pas exigé plus de trois ou quatre secondes. L'entrée/sortie 0 peut être déconnecté de la masse et l'on peut téléverser le croquis en activant l'icône Téléverser, ou avec le menu Croquis / Téléverser (Sketch / Upload). Quand le téléversement est complété

Leaving... Hard resetting via RTS pin...

est affiché dans la fenêtre des messages. Le micrologiciel sera activé dès que le ESP32 est redémarré en appuyant momentanément sur le bouton RST.

Blinks' output in Arduino IDE's serial monitor

En plus de clignoter la DEL, le logiciel affiche son état dans le moniteur série comme on peut voir.

Cette version Arduino du croquis est téléchargeable depuis ce lien : blinks-arduino.zip.

Autre croquis toc

J'ai aussi téléversé un autre croquis, chipinfo, vers la carte ESP32-CAM pour obtenir un peu plus d'information à son sujet.

ESP32 Chip Information Chip model: ESP32-D0WDQ5, Revision: 1 Core count: 2 CPU frequency: 240 MHz Cycle count: 237201865 MAC: f4:cf:a2:xx:xx:xx SDK version: v3.3.5-1-g85c43024c InternalRam Heap size: 386620 Free heap: 360440 Min free heap: 353712 Max heap alloc size: 126424 SketchSize Sketch size: 285136 Free sketch space: 3145728 Flash Memory Flash size: 4194304 Flash speed: 40000000 Flash mode: FM_DIO (2) SPI RAM Memory (PSRAM) PSRAM size: 4194252 Free PSRAM: 4194252 Min free PSRAM: 4194252 Max PSRAM alloc size: 4194252

Si le croquis est compilé dans Arduino les résultats sont un peu différents, sans doute parce qu'une version plus récente du noyau Arduino-ESP32 d'Espressif est utilisée.

ESP32 Chip Information Chip model: ESP32-D0WDQ5, Revision: 1 Core count: 2 CPU frequency: 240 MHz Cycle count: 236061421 MAC: f4:cf:a2:xx:xx:xx SDK version: v4.4-dev-3569-g6a7d83af19-dirty InternalRam Heap size: 365844 Free heap: 341192 Min free heap: 334504 Max heap alloc size: 65524 SketchSize Sketch size: 257472 Free sketch space: 3145728 Flash Memory Flash size: 4194304 Flash speed: 80000000 Flash mode: FM_DIO (2) SPI RAM Memory (PSRAM) PSRAM size: 4192139 Free PSRAM: 4192139 Min free PSRAM: 4192139 Max PSRAM alloc size: 2097140

Voilà la confirmation que seulement la moitié du PSRAM est accessible et que le dispositif contient une revision 1 de la puce ESP32.

Ce croquis est disponible.

Conclusion toc

Les cartes de développement ESP8266 et ESP32 avec une interface USB sont bien pratiques, mais je m'interrogeais sur l'intérêt de cette interface pour certains projets. Lorsqu'il n'est pas pratique de brancher un ordinateur au dispositif par câble USB et si l'on se fie à la mise à jour sans fil du micrologiciel alors l'interface USB n'est qu'une façon complexe et énergivore d'alimenter la carte. À force de téléverser des croquis sur le ESP32-CAM, alors que je m'initie au ESP32 et que je peaufine ma version du serveur vidéo, je suis de plus en plus convaincu que l'interface USB n'apporte pas grand-chose d'utile à long terme. Il me semble qu'il y aurait un marché pour des cartes ESP8266 et ESP32 sans port USB comme le ESP32-CAM, mais qui exposent la majorité des entrées/sorties du module ESPxxxx à l'instar des cartes de développement classiques.

Puisque tout fonctionne bien, il est temps de passer au croquis qui donne toute sa valeur au module : le ESP32-CAM comme serveur vidéo.

Pour ce qui est des liens vers d'autres sites, je ne sais pas par où commencer. Google fournit plus de 10 millions références pour la recherche esp32. Sur seulement GitHub, il y a delà de 28 000 référentiels quand on fait une recherche avec esp32 comme critère. En se limitant à esp32 cam il reste quand même 1 255 référentiels. Impossible de prétendre en avoir consulté un échantillon assez grand pour recommander des sites qui seraient parmi les meilleurs. Je vais donc ne signaler que trois sites dont les deux premiers appartiennent à compatriotes.

Le ESP32-CAM comme serveur video-> <-Radio internet avec le ESP32