Vous aimeriez pouvoir contrôler votre Raspberry Pi Pico au moyen de votre smartphone?
Un module HC-06 permettra à votre Raspberry Pi Pico de communiquer par Bluetooth avec un téléphone ou une tablette situé à une distance maximale d'une dizaine de mètres.
Le module HC-06 ne comporte que 4 broches: deux pour l'alimentation, et deux pour la communication UART. Le verso de mon module indique que l'alimentation doit se situer entre 3,6 V et 6 V, mais que la communication s'effectue à un niveau logique de 3,3 V.
Voici comment j'ai branché le module HC-06 au Raspberry Pi Pico:
Broche VCC du HC-06 - Broche VBUS (5 V) du Raspberry Pi Pico
Broche GND du HC-06 - Broche GND du Raspberry Pi Pico
Broche TXD du HC-06 - Broche GP1 (RX) du Raspberry Pi Pico
Broche RXD du HC-06 - Broche GP0 (TX) du Raspberry Pi Pico
Couplage avec l'appareil hôte
Aussitôt que le module HC-06 est alimenté, sa LED rouge se met à clignoter, ce qui indique qu'il est prêt à être couplé avec un appareil hôte (smartphone, tablette, etc.). Cette procédure s'effectue de façon autonome par le module HC-06, elle ne dépend aucunement du Raspberry Pi Pico.
Les captures d'écran ci-dessous proviennent d'une tablette Android. Je suis allé dans "Paramètres", puis "Bluetooth". J'active Bluetooth si ce n'est pas déjà fait, et HC-06 apparaît dans la liste des appareils disponibles.
Par défaut, le mot de passe est "1234" (si vous le désirez, toutefois, le mot de passe peut être modifié au moyen d'une commande AT).
Si le mot de passe est bon, HC-06 apparaît désormais dans la liste "Périphériques couplés".
Une appli pour la communication Bluetooth
Il existe un grand nombre d'applis qui permettent de communiquer en Bluetooth avec votre téléphone ou votre tablette. Sur Android, j'aime bien Serial Bluetooth Terminal par Kai Morich.
À l'intérieur de Serial Bluetooth Termnal, cliquez sur ce bouton afin d'établir la connexion avec le HC-06.
À cette étape, le bouton change de forme et la LED du HC-06 cesse de clignoter (elle demeure allumée de façon continue).
Exemple 1: envoi d'un message du Raspberry Pi Pico vers le téléphone
Ce script en MicroPython envoie un message qui pourra être capté par votre téléphone. Puisque le HC-06 retransmet via Bluetooth tout ce qu'il reçoit sur sa broche RXD, le script ne comporte rien de spécifique au Bluetooth: il émet simplement un message UART (dans ce cas particulier: un nombre entier qui augmente d'une unité à chaque seconde).
-
-
Exemple 2: envoi d'un message du téléphone vers le Raspberry Pi Pico
Dans ce deuxième exemple, on envoie un message au Raspberry Pi Pico à partir du téléphone. Si on envoie le message "a", la LED verte du Raspberry Pi Pico s'allume, alors qu'elle s'éteint si on envoie le message "b".
Ici encore, le message Bluetooth reçu par le HC-06 sera transmis par UART au Raspberry Pi Pico.
Le module RFID-RC522 constitue une façon simple et économique de faire de la radio-identification au moyen d'un microcontrôleur. Dans cet article, nous lisons le numéro d'identification (uid) d'un tag RFID au moyen d'un module RC522 branché à un Raspberry Pi Pico programmé en MicroPython.
Connexions
Voici comment j'ai branché le module RC522 au Raspberry Pi Pico:
Broche 3.3 V du RC522 - Sortie 3,3 V du RP Pico
Broche RST du RC522 - Broche GP3 du RP Pico
Broche GND du RC522 - Broche GND du RP Pico
Broche IRQ du RC522 - Pas branchée
Broche MISO du RC522 - Broche GP4 du RP Pico
Broche MOSI du RC522 - Broche GP7 du RP Pico
Broche SCK du RC522 - Broche GP6 du RP Pico
Broche SDA du RC522 - Breoche GP5 du RP Pico
(Bizarrement, la broche identifiée SDA sur le module RC522 est en fait le "chip select" SPI)
Installation du pilote mfrc522
J'ai utilisé le pilote MicroPython mfrc522 que Daniel Perron a modifié pour utilisation avec le Rasbperry Pi Pico. Le fichier "mfrc522.py" doit être copié dans le Raspberry Pi Pico (pour ce faire, j'utilise le panneau "Fichiers" de Thonny).
Exemple: lecture du numéro d'identification d'un tag RFID
Le script ci-dessous lit le numéro d'identification d'un tag ou d'une carte RFID placée à proximité du module RC522.
-
-
Lorsque vous connaissez le numéro d'identification d'un tag RFID, vous pouvez ensuite l'utiliser dans un programme qui accomplira une action à la condition que ce tag en particulier soit présenté.
À lire également
D'autres articles impliquant le Raspberry Pi Pico programmé en MicroPython:
Dans ce tuto, nous branchons à un ESP32 un écran tactile SPI 240 X 320 comportant le contrôleur ILI9341. L'ESP32 sera programmé au moyen de l'IDE Arduino.
Connexions de l'écran à l'ESP32
Mon écran est muni d'un lecteur de carte SD que je n'utiliserai pas pour l'instant. Ça nous laisse tout de même 18 broches qui servent à l'alimentation, à l'affichage et au capteur tactile.
Voici comment j'ai branché l'écran à mon module ESP32:
Broche VCC de l'écran: sortie 3,3 V de l'ESP32
Broche GND de l'écran: broche GND de l'ESP32
Broche CS de l'écran: broche D15 de l'ESP32
Broche Reset de l'écran: broche D4 de l'ESP32
Broche DC de l'écran: broche D5 de l'ESP32
Broche SDI (MOSI) de l'écran: broche D23 de l'ESP32
Broche SCK de l'écran: broche D18 de l'ESP32
Broche LED de l'écran: sortie 3,3 V de l'ESP32
Broche CDCK (MISO) de l'écran: broche D19 de l'ESP32
Configuration de la bibliothèque TFT_eSPI(fichier User_Setup)
Puisque la bibliothèque TFT_eSPI est compatible avec un grand nombre d'écrans TFT et avec plusieurs microcontrôleurs, il est nécessaire de régler certaines informations dans un fichier de démarrage avant de pouvoir l'utiliser. Un grand nombre de fichiers prêts à l'emploi se trouvent dans le dossier "User_Setups", qui se trouve lui-même à l'intérieur du dossier de la bibliothèque TFT_eSPI (dans votre Sketchbook Arduino).
Malheureusement, le dossier ne comporte pas de fichier conçu pour l'utilisation d'un ILI9341 avec un ESP32, et j'en ai donc écrit un (voir ci-dessous). Ce fichier devrait être enregistré dans le dossier User_Setups sous le nom "Setup_ILI9341_ESP32.h"
-
-
Après avoir copié le fichier ci-dessous dans le dossier User_Setups sous le nom "Setup_ILI9341_ESP32.h" , il faut également ouvrir le fichier User_Setup_Select.h, commenter la ligne 22 (pour la désactiver), et ajouter cette directive:
#include <User_Setup/Setup_ILI9341_ESP32.h>
Si plus tard vous désirez utiliser la bibliothèque TFT_eSPI avec un autre écran ou avec un autre microcontrôleur, il s'agira d'utiliser un fichier de configuration différent.
Sketch #1: Deux boutons
Je vous présente ici les deux mêmes sketches que j'avais utilisés avec un ESP8266 et un STM32. Dans ce premier exemple, l'écran affiche deux boutons: un premier bouton fait apparaître un rectangle, alors que l'autre fait apparaître un cercle. En plus d'illustrer la gestion des boutons, cet exemple montre comment tracer à l'écran des formes géométriques simples.
-
-
Sketch #2: Bouton coulissant
Dans ce deuxième exemple, l'écran affiche un bouton coulissant qui contrôle une valeur numérique située entre 0 et 100. Ça pourrait être utilisé pour contrôler la vitesse d'un moteur, la luminosité d'une LED, etc.
-
-
Bien entendu, de nombreux autres exemples sont inclus avec la bibliothèque TFT_eSPI.
Dans cet article, nous programmons un Raspberry Pi Pico en MicroPython afin de mesurer la distance d'un obstacle au moyen d'un télémètre à ultrasons HC-SR04.
Le module HC-SR04 est un sonar: il émet des ultrasons pour ensuite capter leur écho. Plus l'obstacle qui réfléchit les ultrasons est éloigné, plus le temps nécessaire au retour de l'écho est long. C'est de cette façon qu'on peut déterminer la distance entre cet obstacle et le module HC-SR04.
Connexion du HC-SR04 au Raspberry Pi Pico
À moins que votre HC-SR04 n'accepte de fonctionner avec une alimentation de 3,3 V (ça arrive parfois), vous devrez l'alimenter avec une tension de 5 V et utiliser un diviseur de tension pour ramener à 3,3 V le signal de 5 V généré par la broche Echo.
Une option efficace consiste à utiliser une résistance de 1 kΩ jumelée à une résistance de 1,8 kΩ.
Quant à la broche Trig du HC-SR04, elle peut être branchée directement à une broche du Pico, puisque dans ce cas le signal de 3,3 V est généré par le Pico et capté par l'entrée Trig.
J'ai donc branché le HC-SR04 au Raspberry Pi de cette façon:
Broche VCC du HC-SR04 : Broche VBUS (5 V) du Raspberry Pi Pico
Broche Trig du HC-SR04: Broche GP14 du Raspbbery Pi Pico
Broche Echo du HC-SR04 Broche GP15 du Raspberry Pi Pico par l'entremise du diviseur de tension constitué des résistances de 1 kΩ et 1,8 kΩ .
Broche GND du HC-SR04: Broche GND du Raspberry Pi Pico
Installation du pilote MicroPython
Plutôt que calculer moi-même la distance au moyen de la vitesse du son et du temps de retour de l'écho, j'ai utilisé la bibliothèque réalisée par rsc1975. Il faut copier le fichier "hcsr04.py" dans le Raspberry Pi Pico.
Exemple de script
Voici, à tire d'exemple, un script qui mesure continuellement la distance de l'obstacle une fois par seconde. Si vous utilisez Thonny, le résultat s'affiche dans la console au bas de la fenêtre.
Même si je préfère désormais utiliser des afficheurs de type OLED ou TFT, qui permettent d'afficher à la fois du texte et des illustrations, il peut s'avérer utile d'afficher des informations sur le classique afficheur LCD comportant 2 lignes de 16 caractères (contrôleur Hitachi HD44780).
Dans cet article, nous affichons un texte sur un afficheur LCD grâce à un Raspberry Pi Pico programmé en MicroPython.
La plupart de ces afficheurs sont conçus pour fonctionner à un niveau logique de 5 V, mais certains d'entre eux acceptent malgré tout de fonctionner à un niveau logique de 3,3 V. Celui que j'ai utilisé était vendu avec la garantie qu'il pouvait fonctionner sous 3,3 V.
Connexions
L'afficheur est de type parallèle, ce qui implique un grand nombre de connecteurs (16 au total). Nous utiliserons le mode 4 bits, donc 6 broches seront utilisés pour la transmission des données.
Broche 1 de l'afficheur: Broche GND du Raspberry Pi Pico
Broche 2 de l'afficheur: Broche 3,3 V du Raspberry Pi Pico
Broche 3 de l'afficheur: Potentiomètre servant à contrôler le contraste (0 à 3,3 V)
Broche 4 de l'afficheur: Broche GP 16 du Raspberry Pi Pico
Broche 5 de l'afficheur: Broche GND du Raspberry Pi Pico
Broche 6 de l'afficheur: Broche GP 17 du Raspberry Pi Pico
Broche 7 de l'afficheur: Pas connectée
Broche 8 de l'afficheur: Pas connectée
Broche 9 de l'afficheur: Pas connectée
Broche 10 de l'afficheur: Pas connectée
Broche 11 de l'afficheur: Broche 18 du Raspberry Pi Pico
Broche 12 de l'afficheur: Broche 19 du Raspberry Pi Pico
Broche 13 de l'afficheur: Broche 20 du Raspbery Pi Pico
Broche 14 de l'afficheur: Broche 21 du Raspberry Pi Pico
Broche 15 de l'afficheur: Broche 3,3 V du Raspberry Pi Pico
Broche 16 de l'afficheur: Broche GND du Raspberry Pi Pico
Installation du pilote display1602
J'ai utilisé le pilote display1602 conçu par Olaf Dreyer. Il faut copier le fichier "display1602.py" dans le Raspberry Pi Pico (ci-dessous: le panneau "Fichiers" de Thonny).
Exemple de script
Pour afficher une chaîne de caractères sur la première ligne de l'afficheur, on peut utiliser la méthode write_line1() (ou encore write_line2(), pour écrire sur la deuxième ligne).
Par exemple, write_line1('Bonjour',1) affiche le mot "Bonjour" à l'extrême gauche de la première ligne. Vous remplacez le chiffre "1" par "2" pour que le texte soit centré, ou par "3" pour qu'il soit justifié à droite.
Il est également possible de faire apparaître le texte une lettre à la fois au moyen de la méthode type_string(). Par exemple, type_string("Bonjour",1,2") affiche progressivement le mot "Bonjour" avec une pause d'une seconde entre chaque lettre, au centre de l'écran.
La bibliothèque ne semble pas comporter de méthode permettant de faire défiler un texte comportant plus de 16 caractères, mais c'est assez facile à programmer soi-même (voir les lignes 30 à 34 de l'exemple ci-dessous).
Dans ce tuto, nous contrôlons un afficheur "LED & KEY" à base de TM1638 au moyen d'un Raspberry Pi Pico. Ces modules comportent 8 afficheurs à 7 segments, 8 LEDs et 8 boutons poussoirs.
Connexions
Un avantage intéressant de ce module est que, hormis l'alimentation, trois broches du microcontrôleur suffisent pour afficher des nombres, allumer des LEDs et connaître l'état des boutons.
Vous pouvez choisir d'autres broches si vous le désirez, mais je vous suggère ces connexions:
Broche VCC du module TM1638: Sortie 3,3 V du Raspberry Pi Pico
Broche GND du module TM1638: Broche GND du Raspberry Pi Pico
Broche STB du module TM1638: Broche GP13 du Raspberry Pi Pico
Broche CLK du module TM1638: Broche GP14 du Raspberry Pi Pico
Broche DIO du module TM1638: Broche GP15 du Raspberry Pi Pico
Installation du pilote TM1638
Mike Causer a mis au point un pilote MicroPython pour le TM1638. Le fichier tm1638.py doit être copié dans le système de fichier MicroPython du Raspberry Pi Pico (ça peut se faire, par exemple, au moyen de Thonny).
Exemple de script MicroPython
Le pilote de Mike Causer met à notre disposition un grand nombre de méthodes permettant d'interagir avec le module TM1638:
number() pour afficher un nombre
show() pour afficher une chaîne de caractères
led() pour allumer ou éteindre une LED
leds() pour régler en une seule étape l'état des 8 LEDs
keys() pour connaître l'état des boutons poussoirs
Plusieurs exemples très instructifs sont fournis avec la bibliothèque. Voici un script qui affiche des nombres, allume et éteint des LEDs, puis affiche le numéro du dernier bouton sur lequel vous avez appuyé.
Le A4988 est un circuit intégré spécialement conçu pour le contrôle d'un moteur à pas bipolaire. Deux broches suffisent pour contrôler le moteur: une entrée qui provoque la rotation d'un pas, et une autre qui détermine la direction de la rotation.
Le circuit intégré est étonnement petit pour un dispositif capable de tolérer une tension de 35 V et un courant de 2 A. Le module est accompagné d'un petit dissipateur thermique qu'il est conseillé de coller sur le circuit intégré.
Le module comporte 16 broches.
VDD et GND servent à l'alimentation du circuit intégré (3 V à 5,5 V)
Vmot et GND servent à l'alimentation du moteur (8 V à 35 V). Il faut placer un condensateur de 100 µF en parallèle avec l'alimentation pour atténuer les surtensions.
1A, 1B, 2A et 2B sont les sorties vers le bobinage 1 et le bobinage 2 du moteur pas à pas.
Chaque fois que l'entrée STEP passe du niveau logique bas au niveau logique haut, le moteur tourne d'un pas.
Le moteur tourne dans le sens horaire si l'entrée DIRECTION est au niveau logique haut, et dans l'autre sens si elle est au niveau logique bas.
On peut désactiver le module en plaçant l'entrée ENABLE au niveau logique bas. Si vous ne branchez rien à cette entrée, elle demeure par défaut au niveau logique haut.
On peut mettre le module en veille (pour qu'il consomme moins d'énergie) en plaçant son entrée SLEEP au niveau logique bas. Cette entrée est maintenue au niveau logique haut pendant l'utilisation du moteur.
La broche RESET peut être mise brièvement au niveau logique bas pour déclencher une réinitialisation du module (suite à un arrêt pour cause de surchauffe, par exemple). Cette entrée est maintenue au niveau logique haut pendant l'utilisation du moteur.
Les broches MS1, MS2 et MS3 permettent de sélectionner différents degrés de micropas (microstepping). Si vous ne les connectez pas, elles sont, par défaut, au niveau logique bas et le moteur fonctionnera en pas complets. Mais il est possible de régler ces broches de façon à obtenir des demi pas, des quarts de pas, des huitièmes de pas et des seizièmes de pas.
Pas complet: MS1 Bas - MS2 Bas - MS3 Bas
Demi pas: MS1 Haut - MS2 Bas - MS3 Bas
Quart de pas: MS1 Bas - MS2 Haut - MS3 Bas
Huitième de pas: MS1 Haut - MS2 Haut - MS3 Bas
Seizième de pas: MS1 Haut - MS2 Haut - MS3 Haut
Connexions du module A4988 à l'Arduino
Voici comment j'ai branché le module A4988 à une carte Arduino Uno pour effectuer quelques tests.
Réglage du courant maximal
Un petit potentiomètre sert à limiter le courant pour éviter qu'un courant trop intense n'endommage le moteur ou le circuit intégré. Vous pouvez mesurer le courant en plaçant le multimètre en série avec un des bobinages du moteur, ou encore mesurer la tension entre le potentiomètre et la masse. Le courant en ampères est approximativement égal à la tension mesurée (en volts) multipliée par 2,5. Cette mesure dépend de la tension à laquelle est soumise l'entrée Vmot, il faut donc refaire ce réglage si vous modifiez l'alimentation du moteur.
Un exemple de sketch
Voici un sketch qui fait tourner le moteur rapidement dans une direction, et lentement dans l'autre. Le programme est très simple: il n'a pas à alterner la direction du courant dans chaque bobinage comme il aurait à le faire pour un L293D, puisque c'est le A4988 qui fait tout le travail.
Le moteur tourne d'un pas chaque fois que le signal de son entrée STEP passe du niveau logique bas au niveau logique haut. Plus ces impulsions sont rapides, plus le moteur tourne rapidement (la vitesse de rotation est contrôlée par des delay() dans le sketch: un délai court correspond à une vitesse rapide).
Le sens de rotation du moteur dépend de l'état logique de la broche DIRECTION.
Je poursuis mon exploration du Raspberry Pi Pico en le combinant à un petit écran couleur SPI de 128 par 160 pixels (1.8") muni du contrôleur ST7735. Le Raspberry Pi Pico sera encore une fois programmé en MicroPython.
L'écran
L'écran que j'ai utilisé porte les mentions "1.8 SPI TFT 128*160" et "KMR-1.8 SPI".
Il comporte 16 connecteurs, mais nous en utiliserons 9, puisque 3 connecteurs ne servent à rien, et 4 autres servent au lecteur de carte SD, que nous n'utiliserons pas pour l'instant.
Connexions
J'ai branché l'écran au Raspberry Pi Pico de cette façon:
Broche LED- de l'écran - Broche GND du Pico
Broche LED+ de l'écran - Sortie 3,3 V du Pico
Broche SD_CS de l'écran - pas branchée (carte SD)
Broche MOSI de l'écran - pas branchée (carte SD)
Broche MISO de l'écran - pas branchée (carte SD)
Broche SCK de l'écran - pas branchée (carte SD)
Broche CS de l'écran - broche GP 15 du Pico
Broche SCL de l'écran - broche GP 6 du Pico
Broche SDA de l'écran - broche GP7 du Pico
Broche AO de l'écran - Broche GP 13 du Pico
Broche RESET de l'écran - Broche GP 14 du Pico
Broches NC de l'écran (il y en a trois): pas branchées
Broche VCC de l'écran: Broche VBUS du Pico *
Broche GND de l'écran: Broche GND du Pico
* Mon écran comporte un régulateur de tension et doit donc être alimenté avec une tension de 5 V. Ce n'est pas le cas pour tous les écrans, toutefois.
Pilote MicroPython pour le ST7735
J'ai utilisé le pilote pour ST7735 de Boochow et Carver. Le fichier "ST7735.py" doit être copié dans le système de fichiers MicroPython du Pico (si vous utilisez Thonny, ça peut se faire par le menu Fichier - Enregistrer une copie).
Deux exemples sont disponibles au même endroit: graphicstest.py, une démonstration mise au point par Adafruit et tftbmp.py qui affiche le contenu d'un fichier bmp enregistré dans la mémoire flash du Pico. Les deux exemples sont parfaitement fonctionnels à la condition de modifier la numérotation des broches utilisées.
Fichier de définition de police de caractère
Pour afficher du texte sur l'écran, il faut définir une police de caractère. Pour mon script ci-dessous, j'ai utilisé la police sysfont mis à notre disposition par Guy Carver. Ici encore, le fichier sysfont.py doit être enregistré dans la mémoire Flash du Pico.
Exemple de script
J'ai préparé un court script en MicroPython qui illustre l'utilisation des principales méthodes permettant de dessiner des formes géométriques de base à l'écran: affichage de texte, contrôle d'un pixel individuel, tracé d'une droite, d'un rectangle ou d'un cercle.
