mardi 27 août 2019

Écrire sur une carte SD avec l'ESP32

Voyons un peu comment procéder pour écrire ou lire des fichiers sur une carte SD avec un ESP32. Ça peut s'avérer utile pour archiver des valeurs mesurées par des capteurs branchés à l'ESP32, par exemple.

En plus de l'ESP32 et d'une carte SD, nous aurons besoin d'un lecteur de carte SD du genre illustré ci-dessous, qui communique avec le microcontrôleur au moyen du protocole SPI (en fait, il est possible de lier directement les broches de l'ESP32 aux connecteurs de la carte, mais ça ne me semble pas très pratique).



Nous programmerons l'ESP32 au moyen de l'IDE Arduino donc, au besoin, vous pouvez vous référer à ce précédent tutoriel pour obtenir des informations supplémentaires.

Connexions

Puisque le module communique par SPI, les connexions sont les suivantes:
  • GND du module SD --- GND de l'ESP32
  • +3.3 du module SD --- 3V3 de l'ESP32
  • +5 du module SD --- pas branché
  • CS du module SD --- GPIO 5 de l'ESP32*
  • MOSI du module SD --- GPIO 23 de l'ESP32
  • SCK du module SD --- GPIO 18 de l'ESP32
  • MISO du module SD --- GPIO 19 de l'ESP32

* La broche CS peut être modifiée dans le sketch, si désiré.

Exemple SD_Test

En général, une fois le module SD connecté, je recommande l'essai du sketch d'exemple CardInfo fourni avec l'IDE Arduino. Mais bien que ce sketch fonctionne correctement avec les cartes Arduino conventionnelles, avec l'ESP8266 et avec les cartes à base de STM32, il est incompatible avec l'ESP 32.

Nous allons plutôt nous rabattre sur le sketch SD_Test, accessible par le menu Fichier - Exemples - SD(esp32) - SD_Test.


Ce sketch comporte 8 routines utiles pour interagir avec une carte SD:
  • listDir: retourne la liste du contenu d'un répertoire
  • createDir: créé un répertoire
  • removeDir: efface un répertoire
  • readFile: lit le contenu d'un fichier
  • writeFile: remplace le contenu d'un fichier
  • appendFile: ajoute du contenu supplémentaire dans un fichier
  • renameFile: renomme un fichier
  • deleteFile: efface un fichier
L'auteur du sketch n'est pas du genre à abuser des commentaires, mais en lisant la section setup() du sketch, on parvient à avoir une assez bonne idée de la façon d'utiliser ces foncions.

Si vous exécutez ce sketch pendant qu'une carte SD se trouve dans le lecteur branché à l'ESP32, le moniteur série devrait vous présenter des informations concernant le contenu de votre carte, ce qui démontrera que vos branchements sont corrects. Si le module SD est mal branché, le moniteur série se contentera d'afficher le message "Card Mount Failed".



Exemple 1: écrire des valeurs mesurées dans un fichier texte

Dans le sketch ci-dessous, je mesure toutes les 5 secondes la valeur analogique de la broche GPIO 36, et j'enregistre le résultat dans un fichier nommé "Valeurs.txt" sur la carte SD (le fichier est créé s'il n'existe pas déjà).





Exemple 2: data logger consultable par WiFi

Ce deuxième sketch est la version ESP32 d'un projet préalablement réalisé sur l'ESP8266: en plus d'enregistrer la valeur mesurée (ainsi que la date et l'heure de la mesure) sur une carte SD, l'ESP32 produit une page web permettant de consulter les 10 mesures les plus récentes.



Articles similaires

D'autres tutoriels comportant un module lecteur de carte SD ont été publiés sur ce blog: carte SD et Arduino Uno, carte SD et ESP8266, carte SD et Bluepill, carte SD et STM32 Nucleo, carte SD et MSP430 Launchpad...

Vous pouvez également consulter la liste des articles concernant l'ESP32.


Yves Pelletier   (TwitterFacebook)

vendredi 23 août 2019

Écran couleur SPI ST7735 et ESP32 / ESP8266


Aujourd'hui, je vous prodigue quelques conseils sur l'utilisation d'un petit écran couleur de 128 X 160 pixels, utilisant le protocole SPI, et basé sur le contrôleur ST7735, avec une carte ESP32 ou ESP8266.

Il existe plusieurs écrans similaires mais comportant certaines différences (par exemple, ceux dont le contrôleur est le S6D02A1 ou encore le ILI9163). Il est possible que mes indications vous soient utiles même si votre écran n'est pas rigoureusement identique à celui que j'ai utilisé.

Mon modèle porte la mention "KMR-1.8 SPI". Il est muni d'un lecteur de carte SD (que je n'ai pas utilisé pour l'instant) et de 16 connecteurs.




Connexions

Voici la façon de brancher votre écran à l'ESP32 ou à l'ESP8266 pour pouvoir utiliser sans modification la bibliothèque de Bodmer, que je vous présente un peu plus loin.

Schéma du circuit pour un module de développement STM32 (voir description un peu plus loin).

Schéma du circuit pour une carte Wemos D1 mini (voir description ensuite).

Allons-y broche par broche ( la broche numéro 1 de l'écran est celle qui est en bas sur les schéma ci-dessus):
  • #1 GND du KMR-1.8: GND de l'ESP8266 ou de l'ESP32
  • #2 VCC du KMR-1.8: sortie 5 V de l'ESP8266 ou de l'ESP32 *
  • #3 NC du KMR-1.8: Pas branché
  • #4 NC du KMR-1.8: Pas branché
  • #5 NC du KMR-1.8: Pas branché
  • #6 RESET du KMR-1.8: GPIO 2 de l'ESP8266 ou GPIO 4 de l'ESP32
  • #7 AO du KMR-1.8: GPIO 0 de l'ESP8266 ou GPIO 2 de l'ESP32
  • #8 SDA du KMR-1.8: GPIO 13 de l'ESP8266 ou GPIO 23 de l'ESP32
  • #9 SCL du KMR-1.8: GPIO 14 de l'ESP8266 ou GPIO 18 de l'ESP32
  • #10 CS du KMR-1.8: GPIO 15 de l'ESP8266 ou GPIO 15 de l'ESP32
  • #11 SCK du KMR-1.8: pas branché (lecteur de carte SD)
  • #12 MISO du KMR-1.8: pas branché (lecteur de carte SD)
  • #13 MOSI du KMR-1.8: pas branché (lecteur de carte SD)
  • #14 SD_CS du KMR-1.8: pas branché (lecteur de carte SD)
  • #15 LED+ du KMR-1.8: 3.3 V **
  • #16 LED- du KMR-1.8: GND
* Mon écran comporte un régulateur de tension 65z5 (portant la désignation "U2" sur le circuit imprimé) qui permet d'alimenter le module avec une tension de 5 V (si vous préférez l'alimenter avec 3,3 V, il faut fermer par une soudure le jumper "JP1" au verso de l'écran). Notez que certains écrans en apparence identiques sont conçus pour être alimentés avec 3,3 V! Sur ma carte ESP32, la broche "VIN" est directement liée au 5 V de l'alimentation USB et constitue donc une excellente sortie 5 V.

** Pour le rétroéclairage, j'ai utilisé une résistance de protection d'une centaine de ohms, mais elle ne semble pas obligatoire.

Installation de la bibliothèque TFT_eSPI

TFT_eSPI est une bibliothèque spécialement conçue pour piloter des écrans TFT SPI avec l'ESP32 ou l'ESP8266. Elle est compatible avec les contrôleurs ILI9341, ILI9163, ST7735, S6D02A1, ILI9481, ILI9486, ILI9488, HX8357D et ST7789! Elle a été conçue par Bodmer, le même qui a fait des bibliothèques similaires pour l'Arduino. Vous pouvez installer la bibliothèque TFT_eSPI par l'entremise du gestionnaire de bibliothèque de l'IDE Arduino.

Modifications à apporter au fichier User_Setup.h

Une fois la bibliothèque installée, il est très important d'ouvrir le fichier "User_Setup.h" afin d'y sélectionner les paramètres qui conviennent à votre écran. Le chemin d'accès, à partir de votre dossier "libraries", est "libraries / TFT_eSPI / User_Setup.h".

Parmi tous les contrôleurs énumérés, il faut en choisir un seul: pour mon écran, c'est le ST7735.


Ensuite, je choisi la définition qui correspond à mon écran: 128 pixels de largeur et 160 pixels de hauteur.

Il existe plusieurs variantes d'écrans basés sur le ST7735, et Bodmer les a classés selon la couleur de l'onglet de la pellicule qui protégeait l'écran lors de l'achat. En général, on les essaie au hasard jusqu'à ce qu'on tombe sur celle qui fonctionne; dans mon cas, il s'agit du ST7735_BLACKTAB. Si vous choisissez la mauvaise variante, votre écran fonctionnera quand même, mais avec les mauvaises couleurs, ou avec des bandes de pixels aléatoires sur les bords de l'image.

Si vous utilisez un ESP8266, il faut décommenter les lignes qui indiquent le numéro des broches reliées à CS, DC et RST. Bodmer a utilisé la numérotation des cartes NodeMCU. Si vous utilisez une carte ESP8266 qui ne respecte pas la même convention, utilisez plutôt les numéros de GPIO: remplacez "PIN_D8" par "15", "PIN_D3" par "0", et "PIN_D4" par "2".
Si vous utilisez un ESP32, les lignes à décommenter se trouvent un peu plus bas:


Exécution des exemples fournis avec la bibliothèque

Pour vérifier le fonctionnement correct de votre écran, il est temps de faire l'essai de quelques-uns des nombreux exemples fournis avec la bibliothèque (Menu Fichier / Exemples / TFTeSPI / 160 X 128 ). Si tout va bien, vous devriez voir apparaître une image sur l'écran. Si rien n'apparaît à l'écran, ça peut être causé par une connexion incorrecte, ou un paramètre mal réglé dans le fichier User_Setup.h ... bonne chance!



Quelques sketches

Je vous présente un premier sketch qui ne fait rien de très utile sauf explorer quelques fonctions simples de la bibliothèque:
  • setRotation: pour régler l'écran en mode portrait ou en mode paysage
  • fillScreen: pour remplir tout l'écran avec la couleur désirée
  • setTextColor: pour choisir la couleur du texte à écrire
  • drawString: pour écrire un texte qui débute à la position choisie
  • drawCentreString: pour écrire un texte dont le centre se trouve à la position choisie
  • drawLine: pour tracer une droite entre deux positions
  • drawRect: pour tracer le contour d'un rectangle
  • drawCircle: pour tracer le contour d'un cercle
  • drawRoundRect: pour tracer le contour d'un rectangle à coins arrondis
  • drawTriangle: pour tracer un triangle
  • fillRect: pour tracer un rectangle plein
  • fillCircle: pour tracer un cercle plein
  • fillRoundRect: pour tracer un rectangle plein à coins arrondis
  • fillTriangle: pour tracer un triangle plein
  • drawPixel: pour tracer un point


La vidéo ci-dessous permet de constater le résultat.



Un deuxième sketch présente à l'écran la mesure de l'entrée analogique A0.


À lire aussi

Le même écran a également été utilisé avec une carte Arduino Uno et avec une carte STM32

D'autres écrans peuvent évidemment être pilotés par une carte ESP8266 ou ESP32, comme par exemple un écran OLED SH1106, un écran Nokia 5110 ou un classique afficheur 16 X 2.

Vous pouvez également consulter la liste de tous les articles concernant l'ESP8266 et l'ESP32.


Yves Pelletier
   (TwitterFacebook)


mardi 20 août 2019

Livre: 40 activités avec la carte micro:bit

40 activités avec la carte micro:bit
Programmation avec Makecode
par Dominique Nibart
Publié en 2019 chez Eyrolles

La carte micro:bit a été conçue d'abord et avant tout pour initier les écoliers britanniques à la programmation. En plus d'entrées/sorties programmables, elle comporte une matrice de 25 LEDs, des boutons, un accéléromètre, une boussole, un capteur de température, bluetooth, et un module de communication radio permettant à plusieurs cartes de communiquer entre elles.  On programme la carte au moyen de MakeCode, un environnement graphique similaire à Scratch qui permet de construire un programme en imbriquant des blocs.

Grâce à ce livre, le néophyte apprendra à transformer sa carte micro:bit en un jeu de pierre-ciseaux-papier, une boussole, un podomètre, un chronomètre, un système d'alarme, un sabre laser, un robot éviteur d'obstacles, et j'en passe, puisqu'il y a en tout une quarantaine de projets proposés.

Tout comme le précédent livre de Dominique Nibart (36 activités avec le robot mBot) , ne cherchez pas de blabla inutile dans cet ouvrage: la plupart des projets occupent une seule page comportant une photographie du montage, une brève description, ainsi que le code "makecode" complet sous forme de blocs imbriqués.

Articles similaires

Vous serez peut-être intéressé par ces autres billets portant sur des livres consacrés à l'électronique.

Yves Pelletier   (TwitterFacebook)

vendredi 16 août 2019

Modulation par largeur d'impulsion (PWM) sur ESP32

Que ce soit pour contrôler l'intensité lumineuse d'une LED, la vitesse de rotation d'un moteur ou la position angulaire d'un servomoteur, il est souvent utile de créer un signal modulé en largeur d'impulsion (MLI, ou PWM pour Pulse Width Modulation).

Un signal PWM alterne entre 0 V et 3,3 V. Son rapport cyclique est le pourcentage du temps total pendant lequel il se trouve à 3,3 V.

Voici donc un petit tuto sur la création et le contrôle d'un signal PWM avec l'EPS32.

Avant d'aller plus loin, rappelons que j'utilise l'IDE Arduino pour programmer l'ESP32.

"analogWrite" ne fonctionne pas

Si vous avez l'habitude de produire des signaux PWM avec une carte Arduino, vous supposerez probablement que l'ESP32 se débrouillera avec une commande du genre "analogWrite(16,100)".

Hé bien non! Toute tentative d'utiliser la fonction analogWrite avec l'ESP32 cause une erreur de compilation: "'analogWrite' was not declared in this scope".


C'est peut-être une bonne chose, remarquez: puisque l'ESP32 comporte un DAC (convertisseur numérique/analogique), il est possible de générer un véritable signal de sortie analogique grâce à la fonction DACWrite, alors que le signal PWM généré par une carte Arduino avec la fonction analogWrite n'est pas, à proprement parler, un véritable signal analogique.

21 broches peuvent être utilisées pour du PWM

En ce qui concerne les broches GPIO, nous avons l'embarras du choix: n'importe quelle broche capable d'être configurée comme sortie peut être utilisée pour produire un signal PWM. Nous excluons les broches GPIO 34 à 39 (qui ne peuvent être configurées qu'en entrée), ce qui laisse tout de même, sur la carte que j'utilise, 21 broches pouvant produire un signal PWM.
16 canaux PWM

Doit-on en déduire qu'il est possible de générer 21 signaux PWM indépendants? Pas tout à fait: l'ESP32 comporte 16 canaux PWM.

Ces canaux sont numérotés de 0 à 15. Comme nous le verrons plus loin, lorsqu'on désire produire un signal PWM sur une broche, on doit associer cette broche à un des 16 canaux au moyen de la fonction ledcAttachPin().

3 fonctions essentielles

Pour générer et contrôler notre signal PWM, notre sketch dispose de 3 fonctions LEDc (pour "LED control" puisqu'elles sont prévues avant tout pour contrôler l'intensité lumineuse d'une LED): ledcAttachPin, ledcSetup et ledcWrite.

  • ledcAttachPin(broche GPIO, canal)
Cette fonction sert à associer une broche GPIO à l'un des 16 canaux GPIO, qui sont numérotés de 0 à 15. Par exemple, si je désire produire un signal PWM sur la broche GPIO 18,  "ledcAttachPin(18, 0)" fera en sorte que le signal généré par le canal 0 sera acheminé à la broche 18. Si j'ai besoin d'un deuxième signal PWM différent du premier, j'utilise pour ce deuxième signal un numéro de broche et un numéro de canal différents. En général, cette fonction est placée dans la partie setup() du programme, puisqu'il est rarement utile de modifier cette assignation en cours d'exécution.

  • ledcSetup(canal, fréquence, résolution)
Cette fonction permet de régler la fréquence et la résolution d'un canal PWM. Le canal continue d'être un entier situé entre 0 et 15. La fréquence est en hertz; elle est typiquement de l'ordre du kilohertz lorsqu'on contrôle la luminosité d'une LED. La résolution, qui peut prendre n'importe quelle valeur entière située entre 1 et 13, détermine le nombre valeurs distinctes pouvant être prises par le rapport cyclique.

Par exemple: avec une résolution de 12 bits, le rapport cyclique pourra prendre 212 = 4096 valeurs différentes, alors qu'avec une résolution de 8 bits, le nombre de valeurs possibles ne sera que de 28= 256.

Par exemple, l'expression "ledcSetup(0, 5000, 12)" règle le canal PWM numéro 0 à une fréquence de 5000 Hz, avec une résolution de 12 bits. Si vous n'avez pas besoin de modifier la fréquence pendant l'exécution du programme, vous placerez probablement cette fonction dans la partie setup().

Quel est l'avantage d'utiliser une résolution plus faible que le maximum permis? Atteindre une fréquence plus élevée! La fréquence maximale permise pour un signal PWM généré par l'ESP32 est de 40 megaHertz! Mais à cette fréquence, la seule résolution possible est de 1 bit (permettant un rapport cyclique de 50% et rien d'autre). Plus la fréquence est grande, plus la résolution maximale possible est petite.

  • ledcWrite(canal, rapport cyclique)
Cette fonction permet de régler le rapport cyclique du signal PWM du canal spécifié.  Par exemple,  "ledcWrite(0, 250)" règle à 250 le rapport cyclique du canal 0.

Attention: le résultat de cette commande dépend de la résolution préalablement réglée avec la fonction ledcSetup: si la résolution est de 12 bits, 250/212 correspond à un rapport cyclique d'environ 6%; si la résolution est de 10 bits, 250/210 correspond plutôt à un rapport cyclique de 24%, et le rapport cyclique sera de 98%  (250/28 ) à une résolution de 8 bits.

Un sketch minimaliste

Le sketch ci-dessous constitue le strict minimum pour générer un signal PWM (qui, dans ce cas, demeure identique pendant toute l'exécution du programme).

Dans ce sketch, j'ai d'abord lié la broche GPIO 18 au canal PWM 0, puis j'ai réglé le canal 0 à une fréquence de 5000 Hz et une résolution de 12 bits. Finalement, j'ai réglé le rapport cyclique à 50% (2048 est la moitié de 212 ).


Observations

J'ai ensuite branché un oscilloscope à l'ESP32 afin d'observer le signal PWM généré.

Tout d'abord, le résultat de mon sketch sans modification:  fréquence de 5000 Hz, résolution de 12 bits,  rapport cyclique à 50%,


On obtient un signal dont le rapport cyclique est de 50%: la moitié du temps à 0 V, et la moitié du temps à 3,3 V:

La fonction statistique de mon oscilloscope confirme la fréquence de 5 kHz et le rapport cyclique de 50%.



Deuxième essai: cette fois, je modifie le rapport cyclique pour qu'il devienne 25%:


Résultat: la tension est de 3,3 V pendant un quart de cycle, et nulle ensuite.




J'ai ensuite doublé la fréquence (pour qu'elle soit de 10 kHz), et réglé le rapport cyclique à 75%.






Finalement, j'ai réglé la résolution à 8 bits. Pour un rapport cyclique de 50%, il faut maintenant utiliser 128.





Un potentiomètre pour régler le rapport cyclique

Terminons avec un sketch classique qui permet de modifier le rapport cyclique d'un signal PWM en tournant un potentiomètre. Ce sketch peut servir, par exemple, à varier la luminosité d'une LED.


Le circuit est constitué d'un potentiomètre relié à la broche GPIO 15, et d'une LED (accompagnée d'une résistance de protection) branchée à la broche GPIO 18.


Rien de bien compliqué ici: nous réglons le rapport cyclique de la broche GPIO 18 à la valeur lue par la broche GPIO 15. En tournant le potentiomètre, l'intensité lumineuse de la LED change. Puisque la résolution du canal PWM et celle de l'ADC sont toutes les deux de 12 bits, aucune conversion n'est nécessaire; les deux résultats prennent des valeurs situées entre 0 et 4095.



Yves Pelletier   (TwitterFacebook)

mardi 13 août 2019

Mise à jour de plusieurs tutos concernant l'ESP8266 et l'ESP32

Vous avez peut-être remarqué que, depuis quelques semaines, j'explore avidement l'ESP32, et j'ai publié quelques nouveaux tutoriels sur le sujet (ce n'est pas terminé: j'ai encore en réserve quelques articles sur l'ESP32, qui seront publiés dans les prochaines semaines).

Ce que vous pourriez ne pas avoir remarqué, toutefois, c'est que j'en ai profité pour remettre à jour 8 tutoriels déjà publiés, qui étaient initialement axés uniquement sur l'ESP8266, afin qu'ils deviennent également compatibles avec l'ESP32:
Dans bien des cas, la modification n'a impliqué que l'ajout de quelques lignes dans le sketch et d'un schéma de circuit supplémentaire. Mais c'est quand même avec une certaine fierté que je constate que, un mois après la publication de mon premier billet concernant l'ESP32, le blog comporte déjà 12 tutos sur l'ESP32.

Yves Pelletier   (TwitterFacebook)

samedi 10 août 2019

Retirer des cartes inutiles dans les menus de l'IDE Arduino

C'était devenu ridicule: après avoir installé, par l'entremise du gestionnaire de carte, les fichiers nécessaires à la programmation du STM32, de l'ESP8266 et de l'ESP32, le menu "Type de carte" de mon IDE Arduino comportait un grand total de 131 items. Chaque fois que je désirais modifier le type de carte, je perdais un temps fou à localiser la bonne option parmi toutes celles qui m'étaient proposées.

Arduino Esplora? Adafruit Circuit Playground? Dongsen Tech Pocket 32? Je ne sais même pas ce que c'est! Dans les faits, je ne possède qu'environ une dizaine de modèles de cartes différents. La goutte qui a fait déborder le vase, c'est l'installation de l'ESP32, qui a ajouté un impressionnant choix de 57 nouvelles cartes au menu, alors que je n'en possède qu'une seule...

Heureusement, il est possible de faire en sorte que les cartes que je n'utilise jamais n'apparaissent pas dans le menu: la propriété "hide" dans les fichier "boards.txt".

La capture d'écran ci-dessous montre ce que j'ai obtenu en faisant une recherche de tous les fichiers "boards.txt" situés sur mon ordinateur. Un de ces fichiers a été généré lors de l'installation de l'IDE Arduino: il comporte la liste des cartes Arduino officielles. Un autre a été installé lorsque j'ai ajouté l'ESP32 par l'entremise du gestionnaire de cartes, puis un autre pour l'ESP8266, etc. Dans mon cas, certains de ces fichiers concernent plutôt Energia, qui est aussi installé sur cet ordinateur.


Ouvrons un de ces fichiers... Voici celui qui apparaît toujours en haut du menu, et qui contient la liste des cartes Arduino officielles, en commençant par l'Arduino Yún.



Le fichier fait la liste de différents paramètres concernant l'Arduino Yún : yun.name, yun.upload.via_ssh, yun.upload.tool, yun.upload.speed, etc.

Supposons que je ne possède pas de carte Yún (ce qui n'est vraiment pas difficile à supposer puisqu' effectivement je ne possède pas de carte Yún) et que je souhaite qu'elle n'apparaisse plus dans le menu, je peux ajouter l'expression suivante, sur sa propre ligne: "yun.hide=" (sans les guillemets).



Le résultat, après avoir enregistré ce fichier "boards.txt" et redémarré l'IDE Arduino, c'est un menu "Type de carte" qui ne comporte plus l'Arduino Yún.


Un aspect intéressant de cette méthode, c'est que je n'ai effacé aucune information des fichiers. Si un jour je me procure une carte Yún, il s'agit de commenter ou d'effacer l'instruction "yun.hide=" pour que la carte réapparaisse dans le menu.

J'ai donc ajouté un "hide" à toutes les cartes de ce fichier que je ne désirais plus voir dans le menu. Je les ai placées toutes ensemble, à la fin du fichier, ce sera plus facile de faire des modifications en cas de besoin. J'ai aussi gardé la liste dans un autre fichier, au cas où ce serait à recommencer suite à une mise à jour de carte.



J'ai fait la même chose dans le fichier "boards.txt" réservé aux cartes ESP32, celui réservé aux cartes ESP8266, etc.

Voici finalement mon nouveau menu "Type de cartes" personnalisé, visible au complet:



Yves Pelletier   (TwitterFacebook)

mercredi 7 août 2019

ESP32: Utilisation des entrées analogiques

La mesure d'une tension analogique a toujours été un point faible de l'ESP8266: le premier module (ESP-01) ne donnait accès à aucune entrée analogique, alors que ses successeurs n'en comportent qu'une seule.

Le moins qu'on puisse dire, c'est que les choses sont différentes avec l'ESP32, qui comporte en principe un grand total de 18 broches pouvant être utilisées comme entrée analogique.

Mais avant de s'enthousiasmer outre mesure, faisons tout de suite remarquer que, sur la plupart des cartes de développement ESP32, 3 des entrées analogiques ne sont pas disponibles car elles sont réservées à un autre usage. Plus important encore, les 10 broches reliées à l'ADC2 ne peuvent pas être utilisées lorsque le WiFi est actif!

Le schéma ci-dessous montre la disposition des broches pouvant être utilisées comme entrées analogiques sur la carte ESP32 que j'utilise. J'ai mis en vert le numéro des 6 broches qui peuvent toujours être utilisées comme entrée analogique, alors que les numéros en rouge sont pour les 9 broches qui peuvent être utilisées comme entrée analogique à la condition que le WiFi soit inactif.
Notez les deux façons possibles de numéroter chaque broche. Pour lire l'état de la broche GPIO 33, je peux tout aussi bien écrire analogRead(33) ou analogRead(A5).

Sur ma carte, les broches GPIO 0, 37 et 38 ne sont pas disponibles. Les broches GPIO 36 et GPIO 39 sont disponibles, par contre, à la condition de savoir les reconnaître: elles portent respectivement la mention "VP" et "VN" sur la carte (attention: n'utilisez pas les broches GPIO 36 et GPIO 39 pendant que vous utilisez le capteur à effet Hall intégré de l'ESP32).

Essai avec un potentiomètre

J'ai branché un potentiomètre à ma carte ESP32 de façon à faire varier la tension de la broche GPIO 33 entre 0 V et 3,3 V.

J'ai ensuite utilisé un sketch minimaliste pour afficher la valeur mesurée dans le moniteur série: mis à part le numéro de broche, le même sketch conviendrait à une carte Arduino conventionnelle.

(Au besoin, vous pouvez vous référer à ce précédent billet pour apprendre comment programmer l'ESP32 au moyen de l'IDE Arduino)


En tournant le bouton du potentiomètre d'une extrémité à l'autre afin de faire passer la tension de 0 V à 3,3 V, on obtient des valeurs variant entre 0 et 4095, puisque la résolution de l'ADC est de 12 bits.


Conversion des valeurs en volts

Les choses se corsent un peu si on désire connaître la tension exacte en volts (ce qui est rarement nécessaire, faut-il le préciser). On pourrait croire qu'il s'agit de multiplier notre mesure par 3,3 , puis de la diviser par 4095. Mais si on procède de cette façon, nous obtiendrons systématiquement une tension plus faible que la tension réelle.  La raison, c'est que la réponse de l'ADC de l'ESP32 n'est pas parfaitement linéaire.

Pour le vérifier, j'ai branché un voltmètre au potentiomètre, et j'ai relevé la tension réelle en volts et le résultat d'analogRead() pour plusieurs positions différentes du potentiomètre.


Le problème principal se situe aux deux extrémités du graphique: la résolution de 12 bits devrait permettre de distinguer deux valeurs séparées d'environ un millivolt. Pourtant, toutes les valeurs inférieures à environ 125 mV retournent une mesure de 0. À l'autre extrémité, la valeur maximale de 4095 est atteinte dès 3,1 V, ce fait que nous obtenons le même résultat peu importe que la tension soit de 3,1, 3,2 ou 3,3 V...

Sur le graphique ci-dessous, j'ai ajouté, en orange, la droite correspondant au calcul analogRead() * 3,3 / 4095... ça donne un résultat presque toujours légèrement plus faible que ce qu'il devrait être:


Dans mon cas, la conversion sera plus fidèle si j'utilise l'équation 7,68E-4 * analogRead() + 0,1734 (sauf aux deux extrémités de la courbe). Je ne sais pas si cette courbe d'étalonnage s'applique à tous les exemplaires de l'ESP32, par contre.



Yves Pelletier   (TwitterFacebook)

samedi 3 août 2019

Piloter des LEDs par WiFi (ESP32 / ESP8266)

Nous explorons aujourd'hui un classique des projets impliquant un ESP8266 ou un ESP32: une page web nous permettra de contrôler à distance 3 LEDs connectées aux broches GPIO  de l'ESP8266 ou de l'ESP32.

Pour ce faire, nous programmerons notre microcontrôleur au moyen de l'IDE Arduino. Si ce n'est pas déjà fait, je vous invite donc à consulter ce précédent billet pour préparer votre IDE Arduino à la programmation de l'ESP32, ou celui-ci pour la programmation de l'ESP8266.

Le circuit

Chaque LED, accompagnée d'une résistance de protection, est branchée à une sortie de la carte. Nous avons choisi les broches GPIO 2, 4 et 5.

Le schéma ci-dessous montre les branchements sur la carte de développement ESP32 que j'ai utilisée.


...et voici le schéma des connexions sur une carte Wemos D1 Mini:


Sketch

Notre sketch transforme l'ESP32 / ESP8266 en serveur web. Heureusement, des bibliothèques font l'essentiel du travail, et la plus grande partie de notre sketch consiste à définir une page web comportant 3 cases à cocher et un bouton "Appliquer".


Lors du démarrage, le moniteur série nous indique l'adresse IP de notre ESP32 ou ESP8266. Il s'agit d'utiliser cette adresse dans un navigateur web pour accéder à la page web permettant de contrôler individuellement chacune des 3 LEDs.





Yves Pelletier   (TwitterFacebook)