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)

lundi 29 juillet 2019

ESP 32: Utilisation des broches tactiles

L'ESP32 comporte 10 broches tactiles, c'est à dire des entrées qui peuvent détecter si on les touche du doigt. Cette fonctionnalité peut servir, par exemple, à remplacer des boutons poussoirs par des surfaces conductrices. Voyons comment les utiliser.

(Dans le présent tuto, nous programmons l'ESP32 au moyen de l'IDE Arduino. Si vous n'avez jamais programmé l'ESP32 avec l'IDE Arduino, vous pouvez vous référer à ce précédent billet).

Identification des broches tactiles

Les broches qui peuvent être utilisées pour détecter un contact avec le doigt sont:

GPIO 0 (si disponible), GPIO 2, GPIO 4, GPIO 12, GPIO 13, GPIO 14, GPIO 15, GPIO 27, GPIO 32 et GPIO 33.

Le schéma ci-dessous montre la position des broches tactiles sur la carte de développement que j'utilise. Sur cette carte, GPIO 0 n'est pas accessible, car elle est utilisée pour autre chose, ce qui laisse la possibilité d'utiliser jusqu'à 9 broches tactiles.

Notez les deux façons possibles d'identifier les broches dans un sketch: pour lire l'état de la broche GPIO 32, par exemple, on pourra écrire touchRead(32) ou touchRead(T9), avec le même résultat.



Fabrication d'un pavé tactile

On pourrait se contenter de toucher directement les broches de la carte de développement ESP32 mais, pour une meilleure ergonomie, j'ai fabriqué un pavé tactile rudimentaire comportant 3 "boutons", chaque bouton étant constitué d'un petit carré découpé dans une feuille d'aluminium et relié par un fil conducteur à une broche tactile.




Pour mes tests, j'ai branché le bouton de gauche (bouton A) à la broche GPIO 13, le bouton du centre (bouton B) à la broche GPIO 12, et le bouton de droite (bouton C) à la broche GPIO 14.

Premier sketch: affichage des valeurs brutes

Côté programmation, rien de plus facile: la fonction touchRead() retourne un entier qui n'a pas la même valeur selon qu'on touche la broche ou non. Il s'agit de passer le numéro de la broche en argument: touchRead(13) pour lire la broche GPIO 13, etc. Puisque GPIO 13 est la broche tactile numéro 4, on obtiendra le même résultat avec touchRead(T4).

Voici donc un sketch qui affiche dans le moniteur série la valeur retournée par touchRead() pour chacun de nos 3 "boutons":


Lorsqu'on ne touche aucun des carrés conducteurs, touchRead() retourne une valeur située entre 70 et 80 (la valeur exacte peut dépendre de la taille du carré d'aluminium).


Lorsqu'on touche du doigt un carré d'aluminium, la valeur retournée par touchRead() diminue pour atteindre une valeur inférieure à 20. Dans la capture ci-dessous, j'avais le doigt sur le bouton A:


Deuxième sketch: interprétation des valeurs mesurées

Maintenant qu'on a une idée des valeurs retournées par touchRead() selon qu'on touche ou non chaque bouton, la stratégie à adopter est évidente: il s'agit d'établir une valeur seuil en-deça de laquelle nous sommes certains qu'un doigt est en contact avec le bouton. Dans le sketch ci-dessous, j'ai utilisé 30.  Ce sketch affiche chaque seconde le nom de chaque bouton pour lequel il y a contact (nous pouvons toucher plus d'un bouton à la fois, si désiré).

-----------------



Voilà! Il ne reste plus qu'à décider ce que fera votre ESP32 lorsque vous toucherez une de ses broches tactiles.

Yves Pelletier   (TwitterFacebook)

mardi 23 juillet 2019

Livre: Circuits électroniques pour les Kids


Circuits électroniques pour les kids
Øyvind Nydal Dahl
Éditions Eyrolles, 2019
Collection "Pour les kids"

Ce nouveau livre, à ne pas confondre avec "L'électronique pour les kids", du même auteur, propose aux électroniciens néophytes 10 circuits classiques :

- une simple LED qui s'allume
- un jeu d'adresse
- un interrupteur sensitif
- une alarme antivol (buzzer qui s'active à partir d'une certaine intensité lumineuse)
- une veilleuse de nuit  (LED qui s'allume quand il fait noir)
- une LED clignotante
- un feu de signalisation (deux LEDs qui clignotent en alternance)
- un éclairage de fête (plusieurs LEDs clignotantes)
- un piano numérique
- chenillard de LED

Tous ces montages sont réalisés au moyen de composants classiques: résistances, condensateurs, transistors bipolaires, LEDs, photorésistance, et trois circuits intégrés incontournables: le temporisateur NE555, le compteur décimal CD4017, et les portes inverseuses 74C14.

L'approche pédagoque m'a semblé simple et efficace. Dans les premières pages du livre, on explique comment construire sur breadboard un circuit simple qui correspond à un schéma conventionnel. Pour les autres circuits, on ne fournit que le schéma. Le lecteur est donc encouragé à comprendre comment passer de la représentation schématique à un circuit réel.

Pour la plupart des circuits, on fournit d'abord le schéma, on donne quelques recommandations sur la marche à suivre, puis on fournit une liste "d'erreurs fréquentes" à surveiller si le circuit ne fonctionne pas au premier essai. Finalement, on explique pourquoi le circuit se comporte comme il le fait: il ne s'agit donc pas de suivre une recette sans avoir la moindre idée de la théorie qui explique son fonctionnement.

Le livre cible un public jeune (à partir de 10 ans). À mon avis, ça peut tout aussi bien être utile à un adulte, peu importe son âge, qui désire faire ses tous premiers pas en électronique.

Yves Pelletier   (TwitterFacebook)

samedi 20 juillet 2019

Test de vitesse: Arduino Uno / STM32 / ESP8266 / ESP32

Aujourd'hui, j'organise une petite course afin de comparer la vitesse de quatre cartes programmables au moyen de l'IDE Arduino:
  • Arduino Uno (ATmega328P, 8 bits, 16 MHz)
  • Blue Pill (STM32F103, 32 bits, 72 MHz)
  • Wemos D1 R1 (ESP8266, 32 bits, 80 MHz)
  • ESP32 (32 bits, 240 MHz)

Pour ce faire, j'ai utilisé le sketch Arduino Speed Test, une version améliorée d'un programme initialement publié sur arduino.cc. Le fonctionnement de ce programme n'a rien de bien compliqué: il consiste à chronométrer le temps nécessaire pour effectuer une même tâche plusieurs fois de suite, et à calculer la moyenne.

Un aspect intéressant, c'est que nous obtenons une comparaison des performances lorsque les 4 cartes sont programmées de la même manière, au moyen de l'IDE Arduino. La simplicité du "langage" Arduino se fait souvent au détriment de la performance, mais cette contrainte ne devrait pas désavantager une carte par rapport aux autres.

De plus, aucune des 4 cartes ne coûte significativement plus cher que les autres: il s'agit strictement de cartes offertes à très bas prix, et faciles à trouver.

Le tableau ci-dessous présente la durée de chaque test, pour chacune des 4 cartes analysées. Plus le temps mesuré est court, plus la carte est rapide.

Signification des couleurs:

Le plus rapide Le deuxième Le troisième Le plus lent

Tous les temps sont en microsecondes:

Test Uno Blue Pill ESP8266 ESP32
1/F_CPU 0,0625 0,0139 0,0125 0,0042
nop (overload) 0,26 0,07 0,05 0,021
digitalRead 4,842 0,604 0,54 0,141
digitalWrite 4,184 0,626 1,045 0,106
pinMode 4,467 2,211 1,475 2,744
multiply byte 0,632 0,11 0,1 0,037
divide byte 5,412 0,114 0,403 0,049
add byte 0,568 0,098 0,1 0,032
multiply int 1,386 0,082 0,148 0,053
divide integer 14,272 0,096 0,437 0,054
add integer 0,883 0,082 0,135 0,053
multiply long 6,102 0,084 0,148 0,051
divide long 38,662 0,096 0,422 0,049
add long 1,764 0,083 0,135 0,053
multiply float 7,49 0,989 0,738 0,051
divide float 80,187 6,971 3,772 0,224
add float 9,417 1,236 0,683 0,049
itoa() 12,957 NA 2,582 0,699
ltoa() 12,987 NA 9,297 0,699
dtostrf() 80,687 93,321 NA 11,149
random() 92,612 1,571 0,998 0,699
y |= (1<<x) 0,568 0,069 0,11 0,045
bitSet() 0,568 0,069 0,11 0,045


Les résultats sont conformes à ce que la vitesse d'horloge de chaque microcontrôleur nous permettait de prévoir: l'Arduino Uno est le plus lent, et de loin, pour la grande majorité des tests. La STM32 Blue Pill et l'ESP8266 offrent souvent des performances assez comparables, et l'ESP32 est beaucoup plus rapide que tous les autres.

La fréquence d'horloge de l'ESP32 est 15 fois plus rapide que celle de l'Arduino Uno, mais quand vient le temps de diviser deux entiers de type "long", l'ESP32 effectue l'opération...789 fois plus rapidement que le Uno!

Contrairement à ce qu'on pourrait croire à prime abord, l'utilisation d'un ESP32 n'est pas uniquement pertinente dans les applications qui nécessitent du WiFi: on peut très bien choisir de l'utiliser purement à cause de sa vitesse.

Bien sûr, ce n'est pas une raison pour jeter votre Arduino Uno à la poubelle: pour la plupart des applications, sa "faible" vitesse d'exécution est amplement suffisante.

Yves Pelletier   (TwitterFacebook)

mardi 16 juillet 2019

Programmer l'ESP32 avec l'IDE Arduino (premiers pas)

Puisque je me suis beaucoup amusé avec l'ESP8266 au cours des derniers mois, il était inévitable que je fasse un jour ou l'autre la connaissance de son cousin, l'ESP32.

En bref, l'ESP32, c'est la même chose que l'ESP8266: un microcontrôleur 32 bits avec WiFi intégré.  Sauf que l'ESP32 est plus rapide et dispose de plus de mémoire, de Bluetooth intégré, de broches GPIO deux fois plus nombreuses, de beaucoup plus d'entrées analogiques, de deux sorties analogiques, d'un capteur à effet Hall intégré... et même s'il est un tout petit peu plus cher que l'ESP8266, l'ESP32 est quand même offert à un prix inexplicablement dérisoire.

Je me suis procuré sur eBay le module de développement photographié ci-dessus (l'annonce était intitulée "ESP-32S ESP32 NodeMCU Development Board").

Le présent billet constitue une marche à suivre pour programmer ce module au moyen de l'IDE Arduino.

Préparation de l'IDE Arduino

Si l'IDE Arduino n'est pas déjà installé sur votre ordinateur, la première étape consiste à l'installer!

Il faut ensuite ajouter des fichiers supplémentaires qui permettent d'utiliser l'IDE Arduino afin de programmer l'ESP32. Pour ce faire, on accède d'abord au dialogue de préférences de l'IDE, grâce au menu Fichier / Préférences.

Au bas du dialogue de Préférences, dans le champ intitulé "URL de gestionnaire de cartes supplémentaires", vous écrivez cette adresse:

https://dl.espressif.com/dl/package_esp32_index.json


S'il y a déjà d'autres adresses dans ce champ, vous pouvez les séparer par des virgules.
On clique évidemment sur le bouton "OK" pour enregistrer les changements.

On se dirige ensuite vers le gestionnaire de carte, en passant par le menu "Outils / Type de carte / Gestionnaire de cartes"


À l'intérieur du gestionnaire de carte, on localise "esp32 by Espressif Systems". Un clic dans cette zone fait apparaître le bouton "Installer", sur lequel nous allons évidemment cliquer.


Le message "Téléchargement des définitions de cartes" devrait s'afficher dans le bas de la fenêtre. Lorsque c'est terminé, la mention "INSTALLED" apparaît à gauche de "esp32 by Espressif Systems". Vous pouvez maintenant fermer le gestionnaire de carte.


Téléversement d'un premier sketch dans l'ESP32

Le temps est venu de brancher le module ESP32 à un port USB de l'ordinateur. Sur ma carte, une LED rouge s'allume pour indiquer qu'elle est alimentée.

Le menu "Outils / Type de carte" nous donne maintenant accès à une rubrique "ESP32 Arduino" qui comporte près d'une soixantaine de cartes ESP32 différentes! Si vous reconnaissez le nom spécifique de votre carte dans la liste, sélectionnez-le, bien sûr, mais si votre carte vous a simplement été vendue sous le nom de ESP32, le premier choix du menu, intitulé "ESP32 Dev Module", fera parfaitement l'affaire.


Si vous êtes curieux de savoir ce qu'implique le choix d'un modèle de carte plutôt qu'un autre, vous pouvez aller jeter un oeil sur le gitHub d'Arduino core for ESP32. Le fichier boards.txt décrit le contenu du menu "Outils" pour chaque carte: certaines cartes offrent plus d'options avancées que d'autres. De plus, le répertoire "variants" comporte les définitions de broches pour chaque carte.

Par exemple, la plupart des cartes définissent la constante "LED_BUILTIN", qui contient le numéro de la broche permettant de contrôler la LED intégrée à la carte. Puisque cette LED n'est pas nécessairement associée à la même broche pour toutes les cartes, notre choix générique "ESP32 Dev Module" ne définit pas cette constante.


Ensuite, c'est la routine habituelle (en supposant que vous êtes déjà familier avec la programmation d'un Arduino): on sélectionne le port série correspondant à notre carte. Dans mon cas, j'ai dû appuyer sur le bouton "BOOT" de ma carte pour que le port devienne disponible dans le menu. J'ai aussi diminué un peu la vitesse de téléversement ("Upload Speed"), car la valeur par défaut de 921600 bauds semble trop optimiste pour la qualité douteuse de mon câble USB.


L'exemple "WiFiScan" (accessible par le menu "Fichier / Exemples / WiFi / WiFiScan" est un bon moyen de vérifier le fonctionnement correct de votre module ESP32, puisqu'aucune modification à ce sketch n'est nécessaire.


Ma première tentative de téléversement a échoué, avec le message d'erreur "A fatal error occured: Failed to connect to ESP32: Timed out waiting for packet header".


Pas de panique: ce problème très fréquent indique que le dispositif qui permettrait à ma carte de se mettre en mode programmable ne fonctionne pas correctement. Le remède consiste à appuyer sur le bouton "BOOT" de la carte ESP32 au moment où le messsage "Connecting....." apparaît au bas de la fenêtre, et de maintenir ce bouton enfoncé jusqu'à ce que d'autres messages soient affichés ("Chip is ESP32D0WDQ6 (revision 1)").

Cette fois, ça fonctionne...


Le moniteur série affiche la liste des réseaux WiFi détectés.


Essai d'une broche GPIO

Le premier essai d'un microcontrôleur ne pourrait pas être complet sans le clignotement d'une LED grâce à l'exemple Blink (menu "Fichier / Exemples / 01.Basics / Blink ).

Puisque cet exemple utilise la constante "LED_BUILTIN" qui n'est pas définie pour la carte générique "ESP32 Dev Module" que j'ai sélectionnée, j'ai remplacé dans le sketch l'expression "LED_BUILTIN" par le nombre 2 puisque la LED intégrée à ma carte est branchée à la broche GPIO 2.


Résultat: la LED bleue se met à clignoter sur la carte.


J'ai ensuite branché une LED à une broche choisie au hasard  (celle portant l'identification "D21" sur la carte) et je l'ai fait clignoter avec succès en écrivant "digitalWrite(21, HIGH);" dans le sketch.



Compatibilité des sketches écrits pour l'ESP8266

Un aspect important à considérer lorsqu'on a déjà fait quelques projets impliquant l'ESP8266: nos programmes écrits pour l'ESP8266 fonctionneront-ils sans problème sur l'ESP32?

Je n'ai fait qu'un seul test, mais il s'est avéré encourageant: j'ai fait l'essai de mon sketch qui sert à lire les flux RSS, et la seule modification nécessaire a consisté à remplacer l'instruction #include "ESP8266WiFi.h" par #include "WiFi.h". Pour d'autres sketches, je ne serais pas surpris de devoir modifier quelques numéros de broches de temps à autre mais, à première vue, les modifications requises ne semblent pas très nombreuses.

Yves Pelletier   (TwitterFacebook)
Related Posts Plugin for WordPress, Blogger...