Livre: micro:bit Programmez la carte avec MakeCode et MicroPython

micro:bit, Programmez la carte avec MakeCode et MicroPython

par Jean-Christophe Quetin

Éditions ENI (Collection La Fabrique)

2020

495 pages

J'ai eu le plaisir de recevoir le nouveau livre de Jean-Christophe Quetin, qui s'adresse aux adeptes de la carte micro:bit.

Une première particularité intéressante de ce livre, c'est qu'il couvre les deux principaux langages pouvant être utilisés pour programmer la carte: MakeCode et MicroPython. Il s'agit peut-être d'un inconvénient pour les lecteurs qui s'intéressent à un seul des deux langages (par exemple: quelqu'un qui a déjà des bonnes base en Python), mais c'est parfait pour le débutant qui ne sait pas encore quel langage il adoptera (je peux facilement imaginer que quelqu'un débute son initiation avec MakeCode et, réalisant les limites de l'outil, décide plus tard de s'attaquer à MicroPython).

L'approche pédagogique est similaire à celle que l'auteur avait appliquée dans son livre précédent (Arduino, Apprivoisez l'électronique et le codage): le lecteur est invité à apprendre les bases de la programmation...en programmant! La majeure partie du livre est donc consacrée à la présentation d'exemples concrets, expliqués soigneusement (mais sans blabla inutile). Les noms des variables sont en français, et les scripts en python comportent de nombreux commentaires.

Dans un premier temps (chapitres 2 et 3), le lecteur apprend à utiliser les nombreuses ressources intégrées à la carte: la matrice de LEDs, les boutons, l'accéléromètre, le magnétomètre, le capteur de température, le capteur de luminosité, les capteurs sensitifs, la communication radio, la communication série, le stockage de données sous forme de fichier... Je remarque qu'il n'y a rien concernant la communication en Bluetooth, qui permet pourtant des applications fort intéressantes (le bluetooth ne peut pas être utilisé en micropython, mais il peut l'être avec MakeCode).

Le chapitre 4 traite des entrées et des sorties, et on y apprend comment utiliser des composants externes communs: LED, LED RGB, module de LED adressables, bouton, potentiomètre, photorésistance, capteur d'humidité, buzzer, haut-parleur, capteur à ultrasons, détecteur de mouvement (PIR), relais, etc. Le moteur à courant continu et le servomoteur sont abordés un peu plus loin, dans un chapitre consacré aux robots.

Ensuite, ça semble un peu inévitable quand il s'agit du micro:bit, on en arrive aux cartes d'extensions spécialisées dans lesquelles il s'agit d'insérer la carte sans avoir à se poser de questions sur les connexions. Il est probablement impossible de couvrir tout ce qui est disponible sur le marché, mais la sélection est assez variée avec, pour chaque carte d'extension présentée, au moins un exemple en MakeCode et en Python.  J'ai particulièrement remarqué les cartes d'extension qui transforment le micro:bit en mini console de jeu (Joystick for micro:bit, Game ZIP 64) ou en robot (MOVE mini, Maqueen).

Je m'interroge un peu sur la pertinence des derniers chapitres, dans lesquels ont présente brièvement d'autres cartes utilisées dans le monde scolaire: Circuit Playground Express, Pyboard, Arduino, Makey Makey et Ozobot. C'est intéressant, mais un peu hors sujet.

L'absence de couleur donne au livre un aspect un peu austère, mais ça n'a pas eu de conséquence fâcheuse sur la clarté des schémas (seule exception: la figure de la page 282, dans laquelle un des fils du moteur est à toute fin pratique invisible). Un peu de couleur aurait aussi contribué à faciliter la compréhension des programmes présentés sous forme de blocs, puisque la couleur de chaque bloc donne une indication de la catégorie à laquelle il appartient. Malgré tout, les programmes en MakeCode sont très lisibles (sauf peut-être celui de la page 316, que les optométristes pourraient utiliser afin de diagnostiquer un début de presbytie).

En conclusion: si vous désirez vous initier au micro:bit, ce livre constitue un excellent choix.

À lire également:

• Mes commentaires sur le précédent livre de Jean-Christophe Quetin: Arduino, Apprivoisez l'électronique et le codage.

• Mes commentaires sur d'autres livres portant sur le micro:bit: 40 activités avec la carte micro:bit par Dominique Nibart, Python pour la carte micro:bit par Julien Launay, Petits robots à fabriquer par Daniel Knox.

• Arduiblog, le blog de Jean-Christophe Quetin

Le livre commenté dans cet article a été fourni gratuitement par les Éditions ENI.

Yves Pelletier (Twitter, Facebook)

Mesurer une distance avec un HC-SR04 et un micro:bit

Les modules à ultrason HC-SR04 constituent une façon simple et économique de déterminer à quelle distance se trouve un obstacle. Dans cet article, nous construisons un télémètre grâce à un HC-SR04 branché à une carte micro:bit.

Le module HC-SR04 est un sonar: lorsque sa broche "Trig" est brièvement soumise à un signal logique haut, une brève impulsion ultrasonore est émise.  La broche "Echo" prend ensuite l'état logique haut pendant une durée égale à la durée du trajet aller-retour de l'ultrason.  Puisqu'on connaît la vitesse du son (environ 340 m/s), on peut  utiliser cette durée pour calculer la distance qui sépare le module HC-SR04 de l'obstacle qui a réfléchi l'impulsion ultrasonore.

Connexions 

Commençons par une bien mauvaise nouvelle: la très grande majorité des modules HC-SR04 sont conçus pour être alimentés par une tension continue de 5 V, alors que la carte micro:bit ne dispose que d'une sortie de 3 V. Ça risque de nous compliquer un peu la vie...

Hypothèse 1: vous disposez d'un module HC-SR04 spécialement conçu pour être alimenté à 3 V

C'est loin d'être la norme pour le moment, mais il existe des modules HC-SR04 qui ont été conçus pour être alimentés aussi bien à 3 V qu'à 5 V. Si vous devez vous procurer un capteur à ultrasons spécialement pour le brancher à un micro:bit, ce serait une bonne idée de vous procurer un tel modèle, ça va simplifier les choses. Si votre module HC-SR04 est de ce type, référez-vous au circuit #1 ci-dessous.

Hypothèse 2: votre module HC-SR04, même s'il a été conçu pour être alimenté à 5 V, accepte malgré tout de fonctionner à 3 V!

C'est loin d'être certain, mais votre module HC-SR04, même s'il n'a pas été conçu pour fonctionner dans ces conditions, acceptera peut-être de fonctionner avec une alimentation de 3 V. J'ai fait le test avec 3 modules, et l'un d'entre eux a très bien fonctionné à 3 V, alors que c'était insuffisant pour les deux autres. Vous avez déjà en votre possession un module HC-SR04?  Faites confiances à la vie!  Essayez d'abord le circuit #1 ci-dessous. Si votre dispositif indique obstinément une distance nulle, vous devrez faire le circuit #2 (plus compliqué).

Circuit #1: alimentation 3 V

C'est le circuit à utiliser pour les modules qui fonctionnement à 3 V, et à essayer dans un premier temps, en croisant les doigts, pour les autres modules.

• Broche VCC du module HC-SR04: broche 3V du micro:bit
• Broche Trig du module HC-SR04: broche P0 du micro:bit
• Broche Echo du module HC-SR04: broche P1 du micro:bit
• Broche GND du mocule HC-SR04: broche GND du micro:bit

Hypothèse 3: votre module HC-SR04 connaît parfaitement ses droits, et il refuse obstinément de fonctionner à une tension de 3 V.

Nous allons tout de même nous en tirer, mais les choses vont se compliquer pour deux raisons. D'une part, il sera nécessaire d'alimenter le module HC-SR04 avec autre chose que les sorties du micro:bit. D'autre part, il faudra abaisser la tension émise par le HC-SR04 sur sa broche "Echo" pour qu'elle soit sans danger pour le micro:bit. Voir le circuit #2 ci-dessous.

Circuit #2: alimentation de 5 V et diviseur de tension

Nous aurons besoin d'une source de tension continue de 5 V.  Il peut s'agir d'une alimentation USB, d'une alimentation de labo, ou tout simplement de 3 piles AA en série (personnellement, j'ai préféré tricher un peu en utilisant la sortie 5 V secrète du micro:bit, dont je parle un tout petit peu plus loin dans cet article).

Il ne faut pas oublier de relier la borne négative de l'alimentation de 5 V avec l'entrée GND de la carte micro:bit, afin que le module HC-SR04 et le micro:bit utilise la même référence pour communiquer.

Mais maintenant que le module HC-SR04 est alimenté en 5 V, il émettra sur sa broche "Echo" un signal de 5 V, qui faut impérativement abaisser à 3 V avant de l'acheminer au micro:bit. Pour ce faire, nous pouvons utiliser un diviseur de tension constitué d'une résistance de 1 kΩ placée en série avec une résistance de 1,8 kΩ.

Nous n'avons pas à prendre cette précaution sur la broche "Trig", car ce signal est émis par le micro:bit (à 3 V), et il sera donc sans danger pour le module HC-SR04.

Voici donc le circuit complet:

• Broche VCC du module HC-SR04: borne positive de l'alimentation 5 V
• Broche Trig du module HC-SR04: broche P0 du micro:bit
• Broche Echo du module HC-SR04: branché à la résistance de 1 kΩ du diviseur de tension
• Broche GND du mocule HC-SR04: broche GND du micro:bit, borne négative de l'alimentation 5 V, et résistance de 1,8 kΩ du diviseur de tension
• Broche P1 du micro:bit: branché entre les deux résistances du diviseur de tension

En bonus: la sortie 5 V secrète de la carte micro:bit

Il y a quelque chose d'un peu intrigant concernant l'absence de sortie 5 V sur la carte micro:bit car, lorsque vous la branchez dans le port USB d'un ordinateur afin de la programmer, vous la soumettez bel et bien à une tension de 5 V. Un régulateur de tension abaisse cette tension à 3 V (3,3 V, en fait) avant de l'acheminer vers la sortie 3 V.

Ça signifie que, dans leur grande sagesse, les concepteurs du micro:bit ont jugé que je n'avais pas besoin d'avoir accès à la tension de 5 V. Mais moi, dans ma grande naïveté, j'ai bien l'impression que ça me serait utile!

Il existe une solution. Au verso de la carte, on trouve un certain nombre de petits points de test circulaires. L'un d'entre eux, celui qui est situé juste au-dessus du mot "ANTENNA", est à une tension de 5 V...

Grâce à une petite goutte de soudure, j'ai apporté une nouvelle amélioration à ma carte micro:bit...une sortie 5 V!

Programmation en microPython

Le principe de fonctionnement du HC-SR04 n'est pas aussi compliqué qu'il pourrait en avoir l'air: nous envoyons une brève impulsion à la broche "trig" pour lui demander de prendre une mesure, puis nous mesurons le temps pendant lequel la broche "echo" demeure au niveau logique "haut". Cette durée est égale au temps qui a été nécessaire pour que les ultrasons fassent le trajet aller-retour du capteur vers l'obstacle, puis de l'obstacle vers le capteur.

Sachant que:

vitesse = 2 * distance / temps

En supposant une vitesse de 343 m/s pour les ultrasons, on trouve que la distance en centimètres est égale au temps mesuré (en microsecondes) divisé par 58.

Nous demandons ensuite au micro:bit d'afficher la distance calculée sur sa matrice de LEDs.

-

-

Programmation en MakeCode

C'est le même principe dans MakeCode:

On peut aussi, si on préfère, installer l'extension "sonar" (disponible en cliquant sur la roue d'engrenage), et le programme est encore plus simple:

Les deux méthodes donnent exactement le même résultat...décevant!

Résultats...un bug dans MakeCode?

Le script en MicroPython fonctionne à merveille. Vous placez le capteur à 25 cm d'un mur et ça affiche 25. Vous le placez à 1 mètre du mur, ça affiche 100.

Mais le programme en MakeCode affiche de drôle de valeurs: vous placez le capteur à 25 cm d'un mur, le micro:bit affiche 16. Si le mur est à 1 mètre, le micro:bit affiche 70!!!

Sur la photographie ci-dessous, le micro:bit affiche 9 cm, alors que l'obstacle se trouve à environ 15 cm.

J'ai vérifié que le problème réside dans la brique "Pulse In" (traduite en français par "impulsion dans"): grâce à un analyseur logique branché à la broche Echo, j'ai mesuré une durée d'impulsion de 1455 µs lorsque l'obstacle se trouvait à 25 cm. Pourtant, le micro:bit mesurait une durée de 950 µs, qu'il utilisait pour calculer une distance erronée de 16 cm!

On pourrait croire que j'ai fait une erreur dans la conception du programme, mais il s'agit du même programme qui est cité en exemple d'application sur la page de référence de Pulse In! De plus, ça ne peut pas être une défectuosité de ma carte, puisque le script en micropython donne les bonnes mesures. 

J'obtiens de résultats assez bons, avec la version MakeCode du programme, si je divise par 38 plutôt que par 58 (ce qui n'a pas vraiment de sens...).

Étrange...

À lire également:

• Micro:Bit - Première exploration avec MakeCode
• Exploration de la carte micro:bit...deuxième volet
• Micro:bit et moteur pas à pas
• Mesurer la pression atmosphérique avec BMP180 et micro:bit

Vous trouverez aussi sur ce blog des conseils pour utiliser le télémètre HC-SR04 avec un Arduino Uno, avec un Raspberry Pi, avec un ATTiny85,  avec une carte STM32 Nucleo programmée avec mbed et avec un microcontrôleur PIC.

Yves Pelletier (Twitter, Facebook)

Micro:bit et moteur pas à pas

Voyons comment ont peut contrôler un moteur pas à pas au moyen d'une carte micro:bit.

Comme le montre la vidéo ci-dessous, les deux boutons du micro:bit seront utilisés pour modifier le mouvement du moteur (le bouton A inverse le sens de rotation, alors que le bouton B modifie la vitesse de rotation du moteur).  De plus, un symbole illustrant le dernier changement demandé (horaire, antihoraire, plus vite ou moins vite) est affiché sur la matrice de LEDs du mirco:bit.

Moteur pas à pas

J'ai utilisé un moteur pas à pas bipolaire qui avait été retiré d'une vieille imprimante (les lecteurs de CD, de CD-ROMs et de DVD sont également d'excellentes sources de petits moteurs pas à pas). Le moteur est constitué de deux bobinages et comporte donc 4 connecteurs.  Il effectue une suite de petites rotations à la condition qu'on inverse périodiquement le sens du courant dans les bobines. Pour que le moteur puisse tourner, il faut donc que la tension de chaque fil puisse être périodiquement interrompue, puis rétablie.

Pilote de moteur: le L9110S

Même si c'est le micro:bit qui contrôlera le moteur, il est hors de question de brancher directement le moteur aux sorties du micro:bit, car le courant nécessaire pour faire tourner le moteur est beaucoup plus intense que ce que peut supporter une sortie du micro:bit.

Nous avons donc besoin d'un circuit spécialement conçu pour servir d'intermédiaire entre le micro:bit et le moteur: les signaux de 3,3 V générés par les sorties du micro:bit seront transformés en une tension mieux adaptée à votre moteur (peut-être 5 V, 9 V ou 12 V, ça dépend du moteur), et le courant circulant dans les sorties du micro:bit demeurera minuscule même si un courant beaucoup plus intense circulera dans les bobinages du moteur.

Pour cette expérience, j'ai utilisé comme pilote de moteur un module L9110S. Si vous avez déjà un autre modèle (comme par exemple un L293D ou un L295N), ça fera très bien l'affaire aussi (les connexions sont très similaires).

Connexions

Puisque quatre sorties programmables sont nécessaires pour faire tourner le moteur, vous devez avoir accès à au moins une des minuscules sorties ultra-étroites. La méthode conventionnelle consiste à utiliser un module d'extension, et j'ai déjà présenté ma méthode personnelle , moins orthodoxe. J'ai choisi les broches P0, P1, P2 et P8, en prenant soin d'éviter les broches associées à la matrice de LEDs.

Vous devez utiliser une alimentation continue pour le moteur: ça ne doit pas être la sortie 3,3 V de votre carte micro:bit. Une tension d'environ 5 V fait souvent l'affaire, mais ça dépend de votre moteur.

• Broche B -IA du L9110S: broche P0 du micro:bit
• Broche B -IB du L9110S: broche P1 du micro:bit
• Broche GND du L9110S: broche GND du micro:bit et borne négative de l'alimentation du moteur
• Broche VCC du L9110S: borne positive de l'alimentation du moteur
• Broche A - IA du L9110S: broche P2 du micro:bit
• Broche A - IB du L9110S: broche P8 du micro:bit

Les 4 fils du moteur sont branchés aux borniers à vis du module L9110S. Au moyen d'un multimètre, il est facile de repérer les connecteurs qui partagent la même bobine. Si le moteur vibre au lieu de tourner, inversez deux fils.

Programmation

J'ai fait le même programme dans MakeCode et dans l'éditeur Python en ligne.

La rotation du moteur est constituée d'une succession de 4 phases; chaque nouvelle phase consiste à inverser le sens du courant dans un des deux bobinages du moteur.

• Phase 1: P0 à 1, P1 à 0, P2  à 1, P8 à 0
• Phase 2: P0 à 0, P1 à 1, P2  à 1, P8 à 0 
• Phase 3: P0 à 0, P1 à 1, P2  à 0, P8 à 1
• Phase 4: P0 à 1, P1 à 0, P2  à 0, P8 à 1

Le bouton A contrôle le sens de rotation du moteur: en marche avant, les phases s'exécutent dans l'ordre phase 1 - phase 2 - phase 3 - phase 4, alors qu'en marche arrière c'est le contraire: phase 4 - phase 3 - phase 2 - phase 1.

Le bouton B contrôle la vitesse de rotation: pause de 10 ms entre chaque phase pour une rotation rapide, pause de 200 ms entre chaque phase pour une rotation lente.

Programme dans MakeCode

Voici le programme que j'ai construit dans MakeCode.

Programme Micropython

Et voici celui qui j'ai écrit en microPython.

-

-

Lire aussi:

• Ma première exploration de la carte micro:bit, et la suite.
• Mesurer une distance avec un HC-SR04 et un micro:bit
• Mesurer la pression atmosphérique avec BMP180 et micro:bit

•  Utilisation d'un moteur pas à pas avec Arduino, Raspberry Pi, ESP32 / ESP8266.

Yves Pelletier (Twitter, Facebook)

Exploration de la carte micro:bit...deuxième volet

Voici  où j'en suis avec ma carte micro:bit. Pour mieux comprendre ce qui va suivre, c'est important de garder à l'esprit que, n'étant pas un écolier britannique s'initiant à la programmation, je ne fais pas exactement partie du public visé par le micro:bit.

Accès aux entrées/sorties

Lors de ma première exploration du micro:bit, je me plaignais de la difficulté de profiter de la totalité de ses entrées/sorties, à moins d'acheter du matériel spécialement conçu pour le micro:bit.

La façon sage et sensée de régler ce problème aurait été de me procurer un adaptateur permettant de transformer l'épouvantable "edge connector" du micro:bit en broches compatibles avec une breadboard (ces produits sont vendus sous le nom de "microbit extension board" ou "microbit breakout board").

Je dois malheureusement avouer que je n'ai pas eu l'autodiscipline nécessaire pour me conformer aux recommandations de la fondation micro:bit... j'ai plutôt choisi de souder chaque entrée/sortie de mon micro:bit à  une barrette de broches pour breadboard.

Mon micro:bit, tel qu'il était au départ...

...en cours de transformation...

Quelle formidable occasion de tester les limites de ma patience, de ma dextérité et de mes yeux presbytes!  

Les bouts de broches proviennent de résistances, de LEDs et de condensateurs ayant été utilisés dans d'autres circuits. Ils ont été nécessaires car l'espacement entre les connecteurs du micro:bit ne correspond pas à celui d'une breadboard.

...et finalement...

Le résultat est tout sauf esthétique et élégant, mais c'est efficace (en plus de donner à mon micro:franken:bit un petit cachet exclusif).

Programmation avec l'IDE Arduino

D'autre part, ma lune de miel avec Makecode semble en voie de prendre fin. Pour me retrouver en terrain connu, j'ai commencé à programmer mon micro:bit avec l'IDE Arduino.

Je résume la procédure: il faut d'abord ajouter cet URL dans le champ intitulé "URL de gestionnaires de cartes supplémentaires", au bas de la boîte de dialogue qui apparaît quand on choisit "Préférences" dans le menu "Fichier":

https://sandeepmistry.github.io/arduino-nRF5/package_nRF5_boards_index.json

On va ensuite dans le gestionnaire de cartes (Menu Outils - Types de cartes - Gestionnaire de cartes),  on recherche "Nordic Semiconductor nRF5 Boards by Sandeep Mistry", et on clique sur "Installer".

Comme type de carte, on choisit bien sûr "BBC micro:bit".

Pour "Softdevice", on choisit "S110"...

...et bien sûr, on sélectionne le port correspondant au micro:bit.

On peut ensuite vérifier que tout fonctionne en faisant clignoter une des LEDs de la matrice du micro:bit, avec un sketch comme celui-ci:

-

-

Dans mon cas, tout a fonctionné immédiatement, sans le moindre pépin. Un excellent tuto sur le site d'Adafruit énumère quelques problèmes possibles, ainsi que les solutions appropriées.

Certaines bibliothèques ne fonctionnent pas, mais j'ai fait quelques tests concluants avec des périphériques qui occupent beaucoup d'entrées/sorties, comme un clavier numérique 4 * 4...

...et un afficheur LCD classique.

En résumé: j'ai transformé mon micro:bit...en Arduino!

À lire aussi:

• Micro:Bit - Première exploration avec MakeCode
• Micro:bit et moteur pas à pas
• Mesurer une distance avec un HC-SR04 et un micro:bit
• Mesurer la pression atmosphérique avec BMP180 et micro:bit
• Mes commentaires sur les livres 40 activités avec la carte micro:bit par Dominique Nibart,  Python pour la carte micro:bit par Julien Launay et micro:bit Programmez la carte avec MakeCode et MicroPython par Jean-Christophe Quetin.

Yves Pelletier (Twitter, Facebook)

Fabrication d'un enregistreur GPS (GPS Logger)

J'ai fabriqué un enregistreur GPS: lorsque je l'apporte avec moi pour marcher, courir ou pédaler, il enregistre les coordonnées de mon itinéraire sur une carte SD en plus de les afficher sur un écran OLED. Lors de mon retour, je peux charger les données dans google maps pour visualiser mon parcours sur une carte géographique.

Comme vous pouvez le constater sur la photo ci-dessus, le dispositif est constitué de 5 éléments:

• Un module STM32 Blue Pill, qui a pour avantages de fonctionner à un niveau logique de 3,3 V, de prendre peu de place et de se programmer avec l'IDE Arduino. 

• Un  module GPS Neo 6MV2 (communication UART)

• Un lecteur de carte SD (communication SPI)

• Un écran OLED SH1106 (communication I2C). Il n'est pas obligatoire, mais il est utile pour s'assurer que le dispositif fonctionne correctement.

• Un chargeur USB portable ("power bank") qui fournit 3,3 V à tout le système par l'entremise du programmateur ST-Link que j'ai utilisé pour programmer la Blue Pill.

Connexions

Le module GPS est branché à la Blue Pill de cette façon:

• VCC du module GPS: 3,3 V *
• RX du module GPS: broche A2 du module STM32 Blue Pill
• TX du module GPS: broche A3 du module STM32 Blue Pill
• GND du module GPS: G du module STM32 Blue Pill

Le lecteur de carte SD est branché à la Blue Pill de cette façon:

• GND du module carte SD: G du module STM32 Blue Pill
• +3.3 du module carte SD: 3,3 V *
• +5 du module carte SD: pas branché
• CS du module carte SD: broche A4 du module STM32 Blue Pill
• MOSI du module carte SD: broche A7 du module STM32 Blue Pill
• SCK du module carte SD: broche A5 du module STM32 Blue Pill
• MISO du module carte SD: broche A6 du module STM32 Blue Pill

L'écran OLED est branché à la Blue Pill de cette façon:

• GND de l'écran OLED :  G du module STM32 Blue Pill
• VCC de l'écran OLED :3,3 V *
• SCL de l'écran OLED : B6  du module STM32 Blue Pill
• SDA de l'écran OLED : B7  du module STM32 Blue Pill

* Au début, j'avais branché tous les périphériques aux sorties 3,3 V de la Blue Pill, mais le comportement du GPS était erratique: ça fonctionne beaucoup mieux si vous les branchez directement à la source d'alimentation (sortie 3,3 V du ST-Link, dans mon cas).

Installation des bibliothèques dans l'IDE Arduino

J'ai utilisé les bibliothèque TinyGPS++ (pour le GPS) et u8g2 (pour l'écran OLED). Les bibliothèques nécessaire au bon fonctionnement du module de carte SD sont déjà incluses dans l'IDE Arduino. Les fichiers nécessaires à la programmation des cartes STM32 ("STM32 core") doivent avoir été installés dans l'IDE Arduino.

Sketch

Chaque fois que la Blue Pill reçoit des nouvelles données de la part du module GPS, elle met à jour les informations affichées sur l'écran OLED (latitude, longitude, date et heure). De plus, les données sont enregistrées dans un fichier CSV ("comma separated values"). Pour éviter d'accumuler une quantité de données inutilement grande, l'enregistrement sur carte SD s'accomplit une fois à toutes les 20 mises à jour en provenance du module GPS.

-

-

Chargement du fichier .CSV dans Google Maps

Après ma petite promenade, la carte SD contient un fichier intitulé "TRAJET.CSV". qui contient, sur chaque ligne, la latitude, la longitude et le temps.

Ces données brutes ne sont pas particulièrement agréables à contempler, mais il est facile de les visualiser dans Google Maps. On se dirige d'abord vers "My maps", et on créé une nouvelle carte.

Ensuite, on clique sur "Importer", et on sélectionne notre fichier "TRAJET.CSV".

On indique que la première colonne contient la latitude...

...alors que la deuxième est la longitude...

J'utilise la 3e colonne comme titre pour les repères...

...et mon trajet s'affiche à l'écran!

Lire aussi

• Programmation d'une carte STM32 avec l'IDE Arduino
• Module GPS Neo 6MV2
• Écran OLED I2C SH1106 et STM32
• Carte SD et Blue Pill

Yves Pelletier (Twitter, Facebook)

Dans un blog près de chez vous (11)

Quelques publications intéressantes trouvées ailleurs sur internet.

RitonDuino:

• MAX7219 : affichage matriciel

Arduiblog:

• Présentation du kit DaDa:bit
• ALFAWISE U30 PRO

Bidouille2Geek:

• Animer sa matrice de LEDs

Framboise 314:

• Carte PYBSTICK26 MicroPython de Garatronic
• Carte PyBStick26 : MicroPython avec le Raspberry Pi
• Boot du Raspberry Pi 4 sur un disque SSD en USB3
• Le Raspberry Pi 4 disponible en version 8Go RAM
• Installer la dernière version de Lazarus (mai 2020) sur Raspberry Pi

ProjetsDIY:

• Installer ESP Easy Mega sur une carte ESP8266
• Quel modèle de Raspberry Pi choisir en 2020 ?
• Mesure de distance par ultrason HC-SR04 à l’aide d’un Arduino
• Intégrer un module ESP32-CAM à Jeedom ou NextDom (firmware modifié)
• Intégrer un module ESP32-CAM à Domoticz (firmware modifié)
• Intégrer un module ESP32-CAM à Home Assistant (firmware officiel)
• Intégrer un module ESP32-CAM à un Dashboard Node-RED (firmware modifié)
• Dépanner Jeedom

MCHobby:

• PYBStick : projet Zumo
• MicroPython : Driver IS31FL3731 pour afficheur CharliePlexing
• PYBStick: officiellement supporté dans Arduino IDE
• MicroPython: Support du trackball I2C de Pimoroni (PIM447)
• Utiliser un TFT Rond avec MicroPython
• PYBStick: un automate programmable sous MicroPython
• UNIPI-MICROPYTHON-AUTOMATION: l'automate programmable propulsé par la PYBStick sous MicroPython
• MicroPython: Sortie de la PYBStick Standard

Papsdroid:

• Hello PYBStick!

L'air du bois:

• La valumineuse - la valise lumineuse

Yves Pelletier (Twitter, Facebook)

Matrice de LEDs RGB 16 X 16 WS2812B et Arduino

J'ai récemment reçu une matrice constituée de 256 LEDs RGB qui permet de créer des animations multicolores assez impressionnantes.  

Il  m'arrive souvent, lorsque je reçois un article que j'avais commandé en ligne, de m'apercevoir qu'il est beaucoup plus petit que ce que j'avais imaginé. Cette fois, c'est tout le contraire: la matrice de LEDs forme un carré de 16 cm par 16 cm, soit environ 6 fois la surface de la carte Arduino Uno que j'ai utilisé pour la contrôler.

Les connecteurs

À l'endos du panneau, la présence de 8 câbles conducteurs pourrait laisser croire que les connexions seront complexes, mais ce n'est pas le cas. 3 connexions suffisent pour faire fonctionner la matrice:

• Nous branchons n'importe lequel des 3 fils rouges à la borne positive d'une source de tension continue de 5 V.
• Nous branchons le fil noir (ou un des deux fils blancs) à la masse (GND de l'Arduino et borne négative de la source de tension).
• Un seul fil sert à la réception des instructions en provenance de l'Arduino: le fil vert identifié "DIN", que nous brancherons, par exemple, à la broche 3 de l'Arduino.

Les connexions non-utilisées servent à faciliter la combinaisons de plusieurs matrices afin de former un panneau plus grand (ce que je ne ferai pas dans cet article).

Prenez soin de bien choisir votre source de tension: 256 LEDs allumées en même temps peuvent consommer beaucoup de courant. Utiliser la sortie 5 V de l'Arduino Uno n'est pas une très bonne idée.

Installation de la bibliothèque FastLED

J'ai installé la bibliothèque FastLED par Daniel Garcia (on peut passer par le gestionnaire de bibliothèque de l'IDE Arduino).

Pour vérifier que tout fonctionne bien, je vous suggère d'essayer l'exemple "Blink" fourni avec la bibliothèque (menu Fichier - Exemples - FastLED - Blink).

Cet exemple ne fait rien de bien spectaculaire: il fait clignoter en rouge la LED numéro zéro de votre matrice. Mais il contient la liste des principales configurations possibles. Dans mon cas, j'ai décommenté la ligne dédiée au contrôleur WS2812B.

Une LED située dans un coin de la matrice s'est effectivement mise à clignoter, mais en vert, ce qui m'a permis de savoir que ma matrice est de type GRB plutôt que RGB.  En remplaçant, dans le sketch, la mention "RGB" par "GRB", la LED s'est mise à clignoter en rouge, tel que prévu.

Avec ces informations, j'ai pu essayer d'autres exemples fournis avec la bibliothèque FastLED, comme par exemple le spectaculaire "ColorPalette", à la condition de remplacer les paramètres appropriés:

• LED_PIN: 3
• NUM_LEDS: 256
• LED_TYPE : WS2812B
• COLOR_ORDER: GRB

Il nous reste toutefois à régler un petit irritant: le contrôleur WS2812B et la bibliothèque FastLED ne sont pas conçus de façon spécifique pour des matrices bi-dimensionnelles; on peut aussi les utiliser pour des rubans de LEDs. Pour cette raison, les LEDs sont simplement numérotées de 0 à 255, mais dans un ordre bien peu pratique.

Ainsi, sur ma matrice, la LED numéro 0 est celle qui est située dans le coin inférieur gauche. Sur cette ligne, les numéros augmentent à mesure qu'on se déplace vers la droite, jusqu'à la LED numéro 15. La LED numéro 16 est située juste au-dessus de la LED numéro 15, et sur cette ligne les numéros augmentent à mesure qu'on se déplace vers la gauche.

Voici un sketch qui allume chaque LED à tour de rôle, de 0 à 255. C'est une façon simple de vérifier dans quel ordre elles sont numérotées.

-

-

Installation de la bibliothèque LEDMatrix

Heureusement, il existe des bibliothèques spécialement conçues pour combler les lacunes de FastLED. J'ai choisi la bibliothèque LEDMatrix par Jorgen - VikingGod. 

Cette bibliothèque, qui doit être combinée à la bibliothèque FastLED, permet de contrôler les LEDs de la matrice à partir du numéro de ligne et du numéro de colonne. De plus, la bibliothèque met à notre disposition un certain nombre de méthodes pour faciliter le contrôle de notre matrice de LEDs:

• DrawPixel(x, y, couleur) : pour allumer une LED en particulier
• DrawLine(x0, y0, x1, y1, couleur): pour tracer une ligne
• DrawRectangle(x0, y0, x1,y1, couleur): pour tracer le contour d'un rectangle
• DrawCircle(xc,  yc,  r, couleur) pour tracer le contour d'un cercle
• DrawFilledRectangle(x0, y0, x1,y1, couleur): pour tracer un rectangle plein
• DrawFilledCircle(xc,  yc,  r, couleur) pour tracer un cercle plein

Le motif peut être déplacé d'un pixel dans n'importe quelle direction grâce à ShiftLeft(), ShiftRight(), ShiftDown(), ShiftUp(), et plusieurs effets de miroirs peuvent être utilisés afin de dupliquer une partie de l'écran: HorizontalMirror(), VerticalMirror(), QuadrantMirror(), QuadrantRotateMirror(), TriangleTopMirror(), TriangleBottomMirror(), QuadrantTopTriangleMirror(), QuadrantBottomTriangleMirror().

Voici un sketch qui illustre l'utilisation de certaines de ces méthodes.

-

-

À lire également:

• La même matrice de LEDs RGB, contrôlée à distance par un ESP32 ou un ESP8266

Yves Pelletier (Twitter, Facebook)

Mesurer une distance avec le télémètre laser VL53L1X

Le VL53L1X de ST Microelectronics est un capteur qui permet de mesurer la distance d'un obstacle situé à 4 m ou moins au moyen d'un laser (inoffensif pour les yeux) de type VCEL de 940 nm (infrarouge). Pour mes tests, j'ai utilisé un module fabriqué par la compagnie Waveshare, mais Sparksfun et Pololu ont également leur modèle. Plusieurs modules moins chers comportent plutôt le VL53L0X, dont la portée n'est que de 2 m.

Connexion du capteur

Le capteur comporte 6 connecteurs, mais seulement 4 d'entre eux sont nécessaires: 2 pour l'alimentation, et 2 pour la communication I²C.

VCC: à brancher à une tension de 3,3V ou 5 V. Puisque le capteur VL53L1X fonctionne à 2,8 V, tous les modèles de module (breakout) comportent un régulateur de tension permettant de l'utiliser à 3,3 V. Les modules fabriqués par Waveshare et Pololu acceptent les tensions de 5 V, mais pas celui de Sparkfun.

GND: à brancher à GND.

SDA: à brancher à la broche SDA de votre microcontrôleur  (par exemple: A4 pour l'Arduino Uno, PB6 pour la STM32 Blue Pill, GPIO 4 pour l'ESP8266, D21 pour l'ESP32).

SCL: à brancher à la broche SCL de votre microcontrôleur (par exemple: A5 pour l'Arduino Uno, PB7 par la STM32 Blue Pill, GPIO 5 pour l'ESP8266, D22 pour l'ESP32).

SHUT: entrée optionnelle "shutdown control". Je ne l'ai pas utilisée lors de mes tests.

INT: sortie optionnelle "interrupt output". Je ne l'ai pas utilisée lors de mes tests.

Choix et installation d'une bibliothèque Arduino

J'ai installé la bibliothèque VL53L1X conçue par Sparkfun. Il en existe également une conçue par Pololu, que je n'ai pas essayée. Les deux peuvent être installées par l'entremise du gestionnaire de bibliothèque de l'IDE Arduino.

Sketch

Voici un sketch de base qui affiche régulièrement la distance mesurée (en millimètres) dans le moniteur série de l'IDE Arduino. Tout le travail est fait en arrière-plan par les bibliothèques Wire et VL53L1X, le programme est donc très court.

-

-

Si vous constatez que la distance mesurée par le capteur n'est pas tout à fait exacte, vous pouvez la corriger au moyen de la méthode "setOffset" (ligne 23). Dans mon cas, la distance affichée était environ 20 mm plus courte que la distance réelle, et j'ai donc fait setOffset(20) pour ajouter 20 mm au résultat.

Par défaut, le capteur est réglé en mode "longue distance", ce qui permet de mesurer une distance maximale d'environ 4 mètres. La méthode "setDistanceModeShort" (ligne 33) permet de régler le capteur en mode "courte distance". La portée maximale est alors d'environ 2 m, mais les mesures sont moins perturbées par l'éclairage ambiant.

L'angle du champ de vision du capteur est, par défaut, de 27°. Pour certaines applications, ça peut faire en sorte que les mesures sont affectées par la présence d'obstacles indésirables en périphérie. Il est possible de diminuer ce champ de vision en contrôlant la région d'intérêt (ROI: region of interest). Le capteur est constitué d'une matrice de 16 X 16 éléments, et le contrôle de la ROI consiste à n'activer qu'une partie de ces éléments. Le faisceau le plus étroit (qui rendra le capteur sensible uniquement aux objets situés droit devant) est obtenu en utilisant la commande: setROI(4,4,199) (ligne 36) où le premier argument est la largeur de la matrice active (4 est le minimum), le deuxième est la hauteur de la matrice active (4 est, encore une fois, le minimum) et le troisième est le numéro de l'élément situé au centre de la matrice active (voir le fichier "SparkFun_VL53L1X.h" de la bibliothèque pour connaître l'ordre de numérotation (pas très intuitifs) des éléments de la matrice).

Quelques tests

J'ai fait quelques tests en branchant le VL53L1X à un module STM32 Blue Pill mais, comme je le disais plus haut, vous pouvez utiliser une carte Arduino conventionnelle (comme le Uno).

J'ai placé un grand panneau blanc rigide à différentes distances devant le capteur, et j'ai vérifié que la distance mesurée par le VL53L1X était conforme à ce que je mesurais avec un simple ruban à mesurer. Tel que mentionné un peu plus haut, j'ai constaté un écart d'environ 20 mm que j'ai pu compenser dans le sketch grâce à l'instruction setOffset.

J'ai également constaté que, en laissant l'obstacle parfaitement immobile à une distance d'environ 1 mètre, la distance affichée n'était pas toujours identique: elle pouvait facilement varier de presque 10 mm.  Par exemple, la capture d'écran ci-dessous montre que le même obstacle immobile à été mesuré à 1014 mm et à 1022 mm (donc 8 mm d'écart alors que rien de bougeait).

VL53L1X ou HC-SR04?

Puisqu'on peut se payer environ 12 modules à ultrasons HC-SR04 pour le prix d'un seul VL53L1X, on peut se demander en quoi le VL53L1X serait supérieur au HC-SR04. 

J'ai effectué un test consistant à mesurer la distance d'un même obstacle au moyen d'un VL53L1X et d'un HC-SR04.  Pour des distances inférieures à environ 3 mètres, l'écart entre les mesures était inférieur à 5 cm.

J'ai aussi vérifié la stabilité de la mesure de la distance d'un objet immobile à environ 1 mètres, pour constater que le HC-SR04 donnait des mesures étalées sur une plage de 14 mm: un tout petit peu moins stable que le VL53L1X, mais à peine.

Bref, portée similaire et résultats comparables: personnellement, je ne vois rien qui justifierait de payer 12 fois plus cher pour un VL53L1X. 

Yves Pelletier (Twitter, Facebook)