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.

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)
Related Posts Plugin for WordPress, Blogger...