lundi 20 décembre 2021

Étude du pendule avec un potentiomètre et Arduino

Récemment, mon attention a été attirée par un article de la revue The Physics Teacher* dans lequel on présente un montage expérimental qui permet d'étudier le mouvement d'un pendule au moyen d'un potentiomètre branché à une carte Arduino. Dans ce montage, le potentiomètre est utilisé pour mesurer en temps réel la position angulaire du pendule.

L'article du Physics Teacher propose l'analyse d'un "pendule pesant"  constitué d'une tige rigide de masse non-négligeable et d'une masse oscillante de taille non-négligeable. De mon côté, j'ai fait quelques essais avec un dispositif s'apparentant plutôt à un "pendule simple" (qui est, en principe, constitué d'une masse ponctuelle suspendue à une ficelle de masse négligeable).

Mon pendule était constitué d'une masse de 500 grammes suspendue à un fil de fer de 91 cm de longueur. L'autre extrémité du fil de fer était attachée à l'axe d'un potentiomètre.


Il faut prendre soin de fixer le fil de fer de façon à ce qu'il oblige la partie rotative du potentiomètre à tourner en suivant le mouvement du pendule.


Bien entendu, le potentiomètre était branché à une des entrées analogiques de l'Arduino. Puisque le signal n'excédait jamais 3,3 V pendant l'oscillation du pendule, j'ai choisi d'utiliser une tension de 3,3 V comme référence, afin d'améliorer un peu la résolution de la conversion analogique-numérique (j'ai relié la sortie 3V3 à l'entrée AREF, et j'ai ajouté la commande "analogReference(EXTERNAL)" au début du sketch). 

Dès les premiers essais, le moniteur série de l'IDE Arduino a montré des résultats encourageants. Je m'attendais à un amortissement plus important, à cause du couple nécessaire pour faire tourner le potentiomètre. Avec une masse de 500 grammes, on peut facilement le négliger si on se limite à quelques oscillations.


J'ai ensuite utilisé un sketch qui mesurait également le temps associé à chaque mesure de position angulaire afin de coller dans un tableur les mesures affichées dans le moniteur série.



Mis à part un aplatissement un peu suspect au sommet,  la courbe concorde assez bien avec ce que prévoient les équations théoriques. La période du pendule, mesurée au moyen des données obtenues, est de 1,92 seconde, ce qui correspond bien avec ce qu'on peut calculer théoriquement pour un pendule  simple de 91 cm de longueur.


* Inexpensive Physical Pendulum with Arduino, par Milentije Lukovic, Vanja Lukovic, Milos Bozic et Vojislav Vujicic, The Physics Teacher vol. 59, numéro 6, Septembre 2021, pages 432-435 (American Association of Physics Teachers).


À lire également


Yves Pelletier (TwitterFacebook)



dimanche 24 octobre 2021

Écriture et lecture de fichiers avec le Raspberry Pi Pico (micropython)

Puisque l'environnement MicroPython comporte un système de fichiers, il est très facile de créer et de lire des fichiers dans la mémoire flash interne du Raspberry Pi Pico. De cette façon, vous pouvez stocker des informations dont votre script a besoin pour bien fonctionner (des préférences de l'utilisateur, par exemple) , enregistrer des mesures prises périodiquement (data logging), etc.  

Évidemment, vos fichiers ne doivent pas être trop volumineux (nous disposons d'un espace total de 1,4 Mo) et leur mise à jour ne doit pas être trop fréquente (afin de ne pas provoquer une usure prématurée de votre Raspberry Pi Pico). Pour de nombreuses applications, l'utilisation d'une carte SD (ou d'un autre périphérique de stockage) s'avère préférable, voire nécessaire.


Exemple #1

Dans ce premier exemple, un nombre aléatoire est écrit à l'intérieur d'un fichier texte intitulé "hasard.txt". Le fichier sera automatiquement créé s'il n'existait pas déjà. Puisque j'ai utilisé l'argument "a" (append), le nouveau nombre est ajouté à la fin du fichier, dont le contenu initial demeure intact.

Dans un deuxième temps, le fichier est lu (notez l'utilisation de l'argument "r": read) et son contenu est affiché dans la console.

-

-

Exemple #2

Dans ce deuxième exemple, j'enregistre dans un fichier la date et l'heure de la dernière exécution du script. Dans un premier temps, on ouvre le fichier "date.txt" pour connaître la date et l'heure de l'exécution précédente du fichier.  Il est possible que ce fichier n'existe pas encore, d'où l'utilisation de try/except pour éviter que le script s'interrompe avec un message d'erreur.

Ensuite, le fichier est ouvert en écriture pour remplacer l'ancienne date par la nouvelle (cette fois, l'argument est "w", write, et le contenu précédent est donc remplacé par la nouvelle information).

-

-

Gestion des fichiers

Si vous programmez votre Pico avec Thonny, le volet "Fichiers" affiche la liste de tous les fichiers enregistrés dans la mémoire interne du Pico. Il est possible d'effacer un fichier grâce à un clic droit de la souris­.

e

(Si ce volet n'est pas visible, vous pouvez le faire apparaître en cochant "Fichiers" dans le menu "Affichage".)


Il est également possible de gérer les fichiers grâce à un script en micropython.  Le script ci-dessous, par exemple, affiche la liste des fichiers présents sur le Pico:

-

-

À lire également

Yves Pelletier (TwitterFacebook)


jeudi 12 août 2021

Horloge temps réel DS3231 et Raspberry Pi Pico (MicroPython)

Tel que mentionné dans un récent article, le Raspberry Pi Pico comporte une horloge temps réel (RTC) interne qui permet à nos programmes de connaître la date et l'heure à n'importe quel moment. Cependant, cette horloge interne retourne au 1er janvier 2021 chaque fois que l'alimentation du Raspberry Pi Pico est interrompue.

Pour éviter cet irritant, on peut utiliser un module RTC externe.  Grâce à sa pile, le module RTC continuera de se mettre à jour pendant que le Raspberry Pi Pico sera hors tension.

Module DS3231

Le module RTC DS3231 est économique et très facile à trouver. Les données sont communiquées par I2C, et une pile de 3 V (qui pourra typiquement fonctionner quelques années sans nécessiter de remplacement) assure le fonctionnement continu de l'horloge.

Mon module DS3231 ne comporte pas de support pour y insérer une pile, ce qui explique la présence de ruban gommé pour tenir la pile! Un avantage, c'est que je peux utiliser n'importe quel format de pile 3 V.

Connexions

J'ai branché le module DS3231 au Raspberry Pi Pico de la façon suivante:

  • Broche "+ " du module DS3231: sortie 3,3 V du Raspberry Pi Pico
  • Broche "D" du module DS3231: broche GP8 du Raspberry Pi Pico
  • Broche "C" du module DS3231:  broche GP 9 du Raspberry Pi Pico
  • Broche "-" du module DS3231: broche GND du Raspberry Pi Pico

Si votre module comporte une broche identifiée par la mention "NC", vous n'avez pas à connecter cette broche.

Bibliothèque MicroPython uRTC par Adafruit

La bibliothèque uRTC d'Adafruit permet de contrôler quelques modèles courants d'horloges temps réel (DS1307, DS3231 et PCF8523). Adafruit ne supporte plus cette bibliothèque depuis que la compagnie a choisi de prioriser CircuitPython plutôt que MicroPython. Malgré tout, uRTC demeure disponible et fonctionnelle.

Comme d'habitude, il faut copier le fichier urtc.py dans le Raspberry Pi Pico afin de pouvoir profiter des fonctionnalités de cette bibliothèque­.


Script #1: consulter la date et l'heure

Voici un script qui affiche la date et l'heure une fois par seconde.  La méthode datetime() (utilisée à la ligne 21) retourne la mesure du temps sous la forme d'un DateTimeTuple contenent l'année, le mois, le jour, le jour de la semaine, l'heure, la minute, la seconde et la milliseconde. Il est facile d'extraire de ce tuple les informations qui nous intéressent.


-

-

Script #2: régler la date et l'heure

Si la date et l'heure fournies par le module DS3231 sont incorrectes, il est facile de les modifier en utilisant encore une fois la méthode datetime, mais en fournissant comme argument le DateTimeTuple correspondant à la valeur désirée.

Par exemple, pour régler le module RTC à 11 heures, 29 minutes et 45 secondes le 12 aoùt 2021, on peut écrire:

urtc.datetime_tuple(year=2021, month=8, day=12, hour=11, minute=29, second=45)

Le script ci-dessous permet de régler la date et l'heure du module DS3231.

-

-

À lire également


Yves Pelletier (TwitterFacebook)


mercredi 11 août 2021

Connaître la date et l'heure avec un Raspberry Pi Pico (machine.RTC)

Grâce à la classe machine.RTC de MicroPython, il est possible d'utiliser l'horloge temps réel interne du Raspberry Pi Pico, ce qui permet de connaître la date et l'heure à n'importe quel moment.


MicroPython: version 1.16 ou plus récente

Pour le Rasbperry Pi Pico, la classe machine.RTC n'est disponible que depuis la version 1.16 de MicroPython (sortie en juin 2021). Si vous utilisez la version 1.14 ou 1.15, il faudra faire une mise à jour avant d'aller plus loin.  (Rappel: on presse le bouton BOOTSEL au moment où on branche le Pico à un porte USB, et on y copie le fichier uf2 approprié).

Si vous utilisez Thonny, le numéro de version de MicroPython s'affiche dans la console.


Script #1: Affichage de la date et de l'heure

Le script ci-dessous affiche la date et l'heure à chaque seconde. La méthode datetime() (utilisée à la ligne 17) retourne la date et l'heure en format "datetimetuple".  Il s'agit d'un tuple comportant 8 éléments: l'année, le mois (1 à 12), le jour (1 à 31), le jour de la semaine (0 à 6), l'heure (0 à 24), la minute (0 à 59), la seconde (0 à 59) et les "subsecondes".

Lors de la première exécution de ce script, vous obtiendrez probablement un tuple qui indique le 1er janvier 2021: l'horloge interne du Raspberry Pi Pico redémarre à cette valeur chaque fois que son alimentation a été interrompue.

-

-


Script #2: Réglage de la date et de l'heure

Puisque nous ne sommes plus le 1er janvier 2021, il va sans dire que nous avons besoin d'une méthode pour régler l'horloge interne du Raspberry Pi Pico à la bonne date Pour ce faire, il s'agit d'utiliser encore une fois la méthode datetime, mais en lui fournissant en argument le tuple correspondant à la date et l'heure actuelle.

Par exemple, je peux régler l'horloge du Pico à 9 heures, 12 minutes et 17 secondes le lundi 16 août 2021 en utilisant:

rtc.datetime((2021, 8, 16, 0, 9, 12, 17, 0))

Une fois la date et l'heure correctement réglée au moyen de la méthode datetime(), le Raspberry Pi Pico va afficher la date et l'heure correctes aussi longtemps qu'il est alimenté, peu importe que vous exécutiez un script ou non. Mais si vous interrompez son alimentation, il retournera inévitablement au 1er janvier 2021 (dans le prochain article, nous aborderons l'utilisation d'un module RTC externe pour éviter cet irriant).

Le script ci-dessous permet de régler la date et l'heure.

-

-

Après avoir réglé la date et l'heure grâce au script #2, vous pouvez exécuter à nouveau le script #1 pour constater que le Raspberry Pico affiche maintenant l'heure correcte.


À lire également


Yves Pelletier (TwitterFacebook)


dimanche 8 août 2021

Module GPS NEO 6MV2 et Raspberry Pi Pico

Dans cet article, nous déterminons notre position (latitude et longitude) au moyen d'un module GPS NEO 6MV2 branché à un Raspberry Pi Pico programmé en MicroPython.


Tel que mentionné lors de notre première exploration du module GPS NEO 6MV2, le module GPS est presque autonome: il s'agit de l'alimenter au moyen d'une tension de 3,3 V pour qu'il se mette à capter des signaux en provenances des satellites GPS et communique les résultats par UART. Une LED bleue intégrée au module GPS clignote pour indiquer que le GPS dispose de données fiables (suite au démarrage du module, plusieurs dizaines de secondes sont parfois nécessaires avant que la LED ne se mette à clignoter).


Le circuit

Puisque le rôle du Raspberry Pi Pico se limite à recevoir les données qui lui seront communiquées par le module GPS, j'ai branché le module GPS au Raspberry Pi Pico de la façon suivante:

  • Broche VCC du module GPS: sortie 3,3 V du Raspberry Pi Pico.
  • Broche RX du module GPS: broche GP4 du Raspberry Pi Pico*
  • Broche TX du module GPS: broche GP5 du Raspberry Pi Pico
  • Broche GND du module GPS: broche GND du Raspberry Pi Pico

* Notez qu'il n'est pas nécessaire de brancher la broche RX du module GPS (car le Raspberry Pi Pico n'enverra aucune information vers le GPS).

Premier script: affichage des données brutes

Dans un premier temps, nous nous contenterons d'afficher dans la console les données brutes émis par le module GPS. Sans surprise, le script est très court, puisqu'il se résume à démarrer le bus UART 1 (associé aux broches GP 4 et GP 5) avec une vitesse de transmission de 9600 bauds, et d'afficher tout ce qui est reçu.

-

-

Si votre module GPS capte des signaux en provenance des satellites (donc si sa LED clignote), vous devriez voir s'afficher des messages débutant par $GPRMC, $GPVTG, etc.

Voici ce que j'ai obtenu dans la console de Thonny:


Installation de la bibliothèque microGPS

Si le coeur vous en dit,  vous pouvez vous documenter sur la norme NMEA 0183 afin d'extraire vous-même les informations qui vous intéressent (latitude, longitude, etc).

Je vous propose plutôt d'installer la bibliothèque micropyGPS de Calvin McCoy.

Prenez soin d'enregistrer le fichier micropyGPS.py dans le Raspberry Pi Pico afin de pouvoir utiliser le deuxième script que je vous propose ci-dessous.


Deuxième script: affichage des données pertinentes

La bibliothèque microGPS met à notre disposition plusieurs méthodes permettant d'extraire la latitude, la longitude, l'altitude, etc. à partir des données brutes fournies par le module GPS:

  • latitude retourne la latitude sous la forme d'un tuple:  [degrés, minutes, Nord ou Sud]
  • longitude retourne la longitude sous la forme d'un tuple:   [degrés, minutes, Est ou Ouest]
Ces tuples sont particulièrement pratiques pour le stockage de données ou pour effectuer des calculs. Pour afficher la latitude et la latitude (sur un écran, par exemple), vous préférerez peut-être utiliser latitude_string() et longitude_string(), qui offrent la même information sous la forme d'une chaîne de caractères.

Ce court script affiche la latitude, la longitude, l'altitude, la vitesse et la date.

-
-

Voici ce que j'ai obtenu dans la console de Thonny:

Il ne vous reste plus qu'à modifier le script pour qu'il réponde à vos besoins (affichage sur un écran, etc.).

À lire également


Yves Pelletier (TwitterFacebook)

mercredi 14 juillet 2021

Jouer une mélodie avec le Raspberry Pi Pico (MicroPython)

Une façon simple de jouer une mélodie au moyen d'un microcontrôleur consiste à modifier la fréquence d'un signal modulé en largeur d'impulsion (PWM). Il en résulte un son très synthétique qui rappelle les jeux vidéo des années 1980.

Pour transformer le signal électrique de la broche GP2 en vibration sonore, vous pouvez utiliser un haut-parleur ou un buzzer piézoélectrique.

Connexion d'un haut-parleur

Un haut-parleur offre une excellente qualité sonore,  mais il est hors de question de le brancher directement à une broche du Raspberry Pi Pico (ou de tout autre microcontrôleur): le courant traversant la broche serait beaucoup trop intense à cause de la faible résistance du haut-parleur. 

Le signal PWM généré par la broche GP2 du Raspberry Pi Pico est plutôt reliée à la base d'un transistor par l'entremise d'une forte résistance (1 kΩ, par exemple). Le haut-parleur est branché au collecteur du transistor, en série avec une résistance d'au moins 100 Ω (pour plus d'infos, voir cet article)


Un buzzer piézoélectrique est beaucoup plus facile à brancher, mais la qualité sonore risque d'en souffrir. Ça peut être une bonne idée d'ajouter une résistance de 100 Ω ou 220 Ω en série avec le piézo.


Script en MicroPython

Chaque fois qu'on désire jouer une note, il faut s'assurer de jouer la bonne fréquence (hauteur de la note) et la bonne durée. La fréquence est réglée au moyen de la méthode freq().

Pour que les notes soient bien distinctes les unes des autres, on ajoute un court silence (d'une durée de 50 millisecondes) entre deux notes successives. Le rapport cyclique est alors réglé à 0% (alors qu'il est de 50% lorsqu'on désire générer un son).

-

-

À lire également


Yves Pelletier (TwitterFacebook)


jeudi 8 juillet 2021

Mesure d'une température avec un thermocouple MAX6675 et un Raspberry Pi Pico (MicroPython)

Lorsqu'on désire mesurer une haute température, comme par exemple celle qui règne à l'intérieur d'un four, l'utilisation d'un thermocouple s'avère particulièrement pertinente.


Un thermocouple exploite l'effet Seebeck: une faible différence de potentiel est générée lorsqu'on joint deux fils conducteurs de matériaux différents et qu'on les soumet à une différence de température. Le circuit intégré MAX6675 transforme cette différence de potentiel en un signal numérique de 12 bits qui indique directement la température, avec une résolution de 0,25°C.


Dans cet article, nous utilisons un thermocouple de type K branché à un module MAX6675. Le module sera branché à un Raspberry Pi Pico programmé en MicroPython.

Connexions

Le module MAX6675 que j'ai utilisé comporte, d'un côté, un bornier à vis servant à brancher le thermocouple et, de l'autre côté, 5 broches pour les connexions avec le microcontrôleur (GND, VCC, SCK, CS et SO).




Côté thermocouple, le rouge est positif et le bleu est négatif. Si vous le branchez à l'envers, vous constaterez que la température mesurée diminue lorsque vous chauffez le thermocouple...


J'ai branché le module MAX6675 au Raspberry Pi Pico de cette façon:

  • Broche GND du MAX6675 : Broche GND du Raspberry Pi Pico
  • Broche VCC du MAX6675: Sortie 3,3 V du Raspberry Pi Pico
  • Broche SCK du MAX6675: Broche GP13 du Raspberry Pi Pico
  • Broche CS du MAX6675: Broche GP14 du Raspberry Pi Pico
  • Broche SO du MAX6675: Broche GP15 du Raspberry Pi Pico


Installation du pilote

J'ai choisi le pilote MicroPython max6675 par BetaRavener. Le fichier max6675.py doit être copié dans le Raspberry Pi Pico.


Script

La méthode "read" de la bibliothèque retourne la température mesurée en degrés Celsius. Le script se résume donc à peu de choses: définir les 3 broches du Raspberry Pi Pico qui ont été utilisées pour la connexion du MAX6675, lire la température une fois par seconde et afficher le résultat. J'ai aussi ajouté une conversion en Kelvin.

-

-

À lire également


Yves Pelletier (TwitterFacebook)

jeudi 17 juin 2021

Robot quadrupède à base de Raspberry Pi Pico (MicroPython)

Au début du mois, je vous ai présenté un robot quadrupède très facile à fabriquer qui comportait deux servomoteurs branchés à un Arduino Uno. Je vous présente aujourd'hui le même robot, dans lequel j'ai remplacé l'Arduino par un Raspberry Pi Pico programmé en MicroPython.


Dans un premier temps, voici une courte vidéo qui montre le robot en mouvement.

Fabrication du robot

J'ai fabriqué le robot en utilisant du carton et quelques bâtonnets de bois, assemblés avec de la colle et du ruban gommé.



Pour que le robot puisse avancer, il est important que les deux servomoteurs soient inclinés par rapport à l'horizontale, d'où la forme triangulaire du châssis du robot.



Connexions des servomoteurs au Rasbperry Pi Pico

Chaque servomoteur est alimenté par une tension continue de 5 V (broche Vbus du Raspberry Pi Pico).

Servomoteur avant: 

  • fil jaune: broche GP15 du Raspberry Pi Pico
  • fil rouge: broche Vbus du Raspberry Pi Pico
  • fil brun: broche GND du Raspberry Pi Pico

Servomoteur arrière: 

  • fil jaune: broche GP13 du Raspberry Pi Pico
  • fil rouge: broche Vbus du Raspberry Pi Pico
  • fil brun: broche GND du Raspberry Pi Pico


Script en MicroPython

Ce script fait avancer le robot de quelques pas vers l'avant, puis de quelques pas vers l'arrière. Vous devrez probablement ajuster les variables "pwm_avant" et "pwm_arriere": il s'agit de la durée de l'impulsion pour laquelle chaque servomoteur se trouve à sa positon moyenne  (la patte droite n'est alors ni en avant, ni en arrière par rapport à la patte gauche).

Il sera peut-être pertinent de modifier également le contenu de la variable "pas": si vous l'augmentez, le robot fera de plus grandes enjambées (ainsi, il marchera peut-être un peu plus vite, à moins qu'il ne perde l'équilibre...). 

-
-

À lire également

Yves Pelletier (TwitterFacebook)

lundi 14 juin 2021

Utilisation d'un écran tactile TFT SPI 240 X 320 (ILI9341) avec le Raspberry Pi Pico

Nous allons maintenant brancher un Raspberry Pi Pico à un écran tactile SPI 240 X 320 muni d'un contrôleur ILI9341 (pour l'affichage) et d'un contrôleur XPT2046 (capteur tactile). Le Raspberry Pi Pico sera programmé en MicroPython.


Connexions de l'écran au Raspberry Pi Pico

Le module comporte un total de 18 broches:

  • 2 broches pour l'alimentation (VCC et GND)
  • 7 broches pour l'affichage
  • 5 broches pour le capteur tactile (celles dont le nom débute par "T_")
  • De l'autre côté de la carte, 4 broches pour le lecteur de carte SD (que je n'ai pas utilisé)

Il serait tout à fait acceptable de brancher l'afficheur et le capteur tactile (XPT2046) sur le même bus SPI. Toutefois, l'auteur de la bibliothèque que nous allons utiliser fait remarquer que l'affichage supporte une vitesse de communication beaucoup plus rapide que le capteur tactile. Pour cette raison, il suggère de brancher l'afficheur et le capteur tactile sur deux bus SPI différents, et c'est ce que j'ai fait (affichage sur le bus SPI0 et détection du touché sur le bus SPI1).

Ça représente beaucoup de fils à connecter... De gauche à droite sur l'écran du schéma ci-dessous:

  • Broche T_IRQ de l'écran : Broche GP2 du RP Pico
  • Broche T_DO de l'écran: Broche GP8 du RP Pico
  • Broche T_DIN de l'écran: Broche GP11 du RP Pico
  • Broche T_CS de l'écran: Broche GP12 du RP Pico
  • Broche T_CLK de l'écran: Broche GP10 du RP Pico
  • Broche SDO (MISO) de l'écran: Broche GP4 du RP Pico (probablement pas nécessaire)
  • Broche LED de l'écran: Sortie 3,3 V du RP Pico
  • Broche SCK de l'écran: Broche GP6 du RP Pico
  • Broche SDI (MOSI) de l'écran: Broche GP7 du RP Pico
  • Broche DC de l'écran: Broche GP13 du RP Pico
  • Broche RESET de l'écran: Broche GP14 du RP Pico
  • Broche CS de l'écran: Broche GP15 du RP Pico
  • Broche GND de l'écran: Broche GND du RP Pico
  • Broche VCC de l'écran: Sortie 3,3 V du RP Pico

Installation des bibliothèques

J'ai utilisé les bibliothèques MicroPython offertes par rdagger.

Pour que les scripts que je présente plus loin dans cet article fonctionnent correctement, tous les fichiers suivants doivent être copiés dans le Raspberry Pi Pico:

  • ili9341.py (gestion de l'affichage)
  • xpt2046.py (gestion du capteur tactile)
  • xglcd_font.py (pour affichage de texte)
  • Unispace12x24.c, à l'intérieur du répertoire "fonts"


Le dépôt github présente une bonne quantité de scripts en MicroPython qui montrent comment afficher du texte, des formes géométriques, des images et des animations sur l'écran (il s'agit des 11 fichiers dont le titre débute par "demo").  Mais puisqu'il n'y a aucun exemple simple montrant comment utiliser la bibliothèque xpt2046.py, c'est sur cet aspect que je vais insister.

Routine de calibration

Lorsqu'on touche l'écran, le capteur tactile envoie au Raspberry Pi Pico deux valeurs qui sont proportionnelles à la position (horizontale et verticale) qui a été touchée.  Ces valeurs brutes doivent toutefois être transformées si on désire qu'elles correspondent aux coordonnées des pixels sur l'écran.

Pour compliquer les choses, les valeurs générées ne sont pas identiques d'un écran à l'autre. Pour cette raison, il est utile d'exécuter une routine comme celle qui est présentée ci-dessous, afin de connaître les valeurs propres à l'écran que nous utilisons.

Le script ci-dessous invite l'utilisateur à toucher tour à tour chacun des 4 coins de l'écran.


Lorsque c'est terminé, les valeurs extrêmes sont affichées:
  • x_min (coordonnée x lorsqu'on touche le bord gauche de l'écran)
  • x_max (coordonnée x lorsqu'on touche le bord droit de l'écran)
  • y_min (coordonnée y lorsqu'on touche le haut de l'écran)
  • y_max (coordonnée y lorsqu'on touche le bas de l'écran)



Ces informations peuvent être entrées dans nos scripts afin que les coordonnées de la position touchée correspondent aux coordonnées du pixel correspondant sur l'écran.

-
-

Vérification de la calibration

Voici maintenant un script minimaliste qui permet de vérifier rapidement la qualité de la calibration: avant de l'utiliser, c'est important de modifier le contenu de la ligne 29 pour qu'il corresponde aux valeurs trouvées au moyen du script de calibration.

Lorsque vous exécutez ce script, un point blanc est tracé chaque fois que vous touchez l'écran. Si la calibration est correcte, le point devrait se tracer à la position touchée.


-

-

Script: un exemple avec des boutons

Voici finalement un exemple dans lequel deux boutons apparaissent à l'écran. Lorsqu'on touche le bouton de gauche, un cercle vert est affichée, alors que c'est un rectangle rouge qui s'affiche lorsqu'on clique sur le bouton de droite. Encore une fois, pour que ça fonctionne bien, c'est important d'écrire vos paramètres de calibration à la ligne 68 du script.


-
-

À lire également

Le même écran tactile peut être utilisé avec un ESP32, un ESP8266 ou une STM32 Blue Pill (toutes ces cartes ont été programmées avec l'IDE Arduino).

D'autre part, nous avons déjà exploré l'utilisation d'autres afficheurs avec le Raspberry Pi Pico programmé en MicroPython: 


Yves Pelletier (TwitterFacebook)