La carte matricielle LED couleur Waveshare RGB pour le Raspberry Pi Pico dispose de 160 LED RGB disposées en 10 rangées de 16. Chacune des 160 LED peut être réglée sur l’une des 16 777 216 couleurs en spécifiant chacun des composants rouge, vert et bleu. avec un nombre compris entre 0 et 255.
Le tableau est lumineux, coloré et simple à connecter au Pico. Il est très facile à programmer et peut même être câblé manuellement à d’autres cartes !
Ce didacticiel en deux parties vous montre comment afficher différentes couleurs, valeurs, heures, chaînes de défilement et lectures de capteurs sur cet écran !
Ce dont vous aurez besoin
Pour la partie 1, vous aurez besoin de :
Dans ce tutoriel, nous allons vous montrer comment :
- Créez des affichages lumineux de couleurs en utilisant les coordonnées (x, y)
- Afficher les valeurs numériques en décimal, hexadécimal et binaire
- Afficher l’heure en heures et minutes
Connexion matérielle
La connexion matérielle est très simple. Branchez la carte directement sur un Pico ou via une carte d’extension. Prenez soin de le mettre dans le bon sens en alignant correctement l’extrémité USB :
Vous pouvez également utiliser des fils de connexion pour connecter les broches situées sous l’écran à votre Pico. 5V va à VBUS, GND à GND et DIN à GP6 ou autre broche appropriée de votre choix. Il y a des cavaliers sur le dessous de la carte pour connecter DIN (Data In) à GP6, GP7 ou GP22. Nous avons lié le nôtre au GP6.
Numérotation et coordonnées des LED
Si nous tournons la carte pour que la connexion USB soit à droite; puis les LED sont numérotées de 0 à 15 sur la rangée du haut en se déplaçant de gauche à droite, de 16 à 31 sur la deuxième rangée, et ce thème continue jusqu’à 44 à 159 sur la rangée du bas.
Si nous utilisons les coordonnées avec la LED en haut à gauche comme origine (0,0), la LED en bas à droite est à (15,9). À partir de là, il est facile de calculer l’index/la position de n’importe quelle LED sur la carte avec :
pos = x + y * 16
Ainsi, la dernière LED est numérotée 15 + 9 * 16 = 159
Nous avons écrit une fonction pour aider à définir des pixels spécifiques sur la couleur requise :
def xy_set(x, y, colour):
# Valid Neopixel check
if (x >= 0) and (x < 16) and (y >= 0) and (y < 11):
pos = x + y*16
pixels_set(pos, colour)
x et y sont les coordonnées du pixel et la couleur est un tuple avec les valeurs de rouge, vert et bleu comprises entre 0 et 255.
Qu’est-ce qu’un Tuple ?
Les tuples sont utilisés pour stocker plusieurs éléments dans une seule variable. Tuple est l’un des 4 types de données intégrés à Python utilisés pour stocker des collections de données, les 3 autres sont List, Set et Dictionary, tous avec des qualités et une utilisation différentes. Un tuple est une collection ordonnée et immuable. Les tuples sont écrits entre parenthèses (cité de w3schools.com).
Exemples de tuples
- Rouge = (255,0,0)
- Vert = (0,255,0)
- Bleu = (0,0,255)
- Jaune = (255,255,0)
- Cyan = (0,255,255)
- Magenta = (255,0,255)
Les crochets sont indispensables ! Vous pouvez obtenir de l’aide pour trouver les valeurs RVB pour les couleurs difficiles telles que le marron ou le rose pâle ici : https://htmlcolors.com/
Nous avons écrit plusieurs programmes de démonstration en MicroPython ci-dessous pour illustrer comment la carte peut être utilisée.
Exemple 1 : LED clignotantes colorées de base
Vous pouvez télécharger le programme ici : WS Neopixels 160 Basic.py
Nous vous suggérons de le télécharger et de le visualiser dans l’éditeur Thonny. Nous fournirons un commentaire (vous pouvez l’imprimer à partir de Thonny pour ajouter des notes ou des commentaires supplémentaires).
Lignes 1 à 49
Il s’agit du code de pilote de LED adressable standard fourni dans le Guide officiel du Raspberry Pi Pico à la page 134.
Nous définissons le nombre de LED, la broche DIN et la luminosité de l’affichage comme ceci :
# Configure the number of WS2812 LEDs. NUM_LEDS = 160 # 10 rows of 16 Neopixels PIN_NUM = 6 brightness = 0.1
Procédures fournies
pixels_set(i, colour)
Modifie le paramètre de couleur d’une LED. Rappelez-vous que la couleur est un tuple de 3 octets !
pixels_set(159, (0, 127 ,0))
Définit le pixel inférieur gauche sur vert moyen.
pixels_show()
Rend visibles les valeurs de couleur précédemment définies des pixels (oublier d’inclure cette instruction est une erreur courante et l’affichage reste inchangé).
Nous avons ajouté quelques procédures supplémentaires pour faciliter la programmation :
xy_set(x, y, colour)
Ceci ajuste le paramètre de couleur du pixel aux coordonnées (x, y). Il vérifie que la position est valide pour l’affichage.
pixels_fill(colour)
Cela définit tous les pixels sur la même couleur – tuple.
clear()
Cela définit tous les pixels en noir
rect(x, y, w, h ,r , g, b)
Dessine un contour rectangulaire de largeur, w, hauteur, h, commençant en haut à gauche à (x, y) avec les valeurs de couleur r, g et b.
vert(x, y, l, r, g, b)
Dessine une ligne verticale de longueur, l, dans la couleur spécifiée
horiz(x, y, l, r, g, b)
Dessine une ligne horizontale de longueur, l, dans la couleur spécifiée
La partie principale du programme, à partir des lignes 87, utilise ces routines pour produire des exemples de :
ordre des pixels, dégradés, lignes, rectangles et diagonales.
Les dégradés sont les plus compliqués avec les couleurs apparaissant en fonction de la position x.
# Gradients
clear()
for i in range(16):
xy_set(i,0,(i*8,0,0)) # Increasing red - left to right
xy_set(15-i,1,(0,i*8,0)) # Decreasing green
xy_set(i,2,(0,0,i*8)) # Increasing blue
xy_set(i,4,((15-i)*8,0,i*8)) # Red to blue
xy_set(i,6,((15-i)*8,i*8,0)) # Red to green
xy_set(i,8,(0,i*8,(15-i)*8)) # Blue to green
pixels_show()
utime.sleep(4)
Choses à essayer
- Dessinez des triangles pointant vers l’intérieur à chaque extrémité de l’écran
- Dessinez une grande flèche orange sur l’écran pointant vers la droite
- Affichez la flèche en boucle et redessinez-la à chaque fois dans une couleur aléatoire différente
- En utilisant la procédure du rectangle, créez un spectacle où un rectangle se dilate et se contracte à partir du centre de l’écran. Vous pouvez ajouter une autre procédure pour « agrandir » le plus petit rectangle de 4 pixels dans un carré à partir du centre de l’écran.
Exemple 2 : Affichage des valeurs numériques et de l’heure
Le deuxième programme montre comment afficher des valeurs numériques stationnaires (voir ci-dessus) sur l’affichage en bases 10, 16 et 2 (dénaire, hexadécimal et binaire – base 10, base 16 et base 2) et afficher l’heure – hh:mm – comme l’exemple ci-dessous :
Vous pouvez télécharger le programme ici : WSNeopixels 160 Numbers.py
Ce programme nécessite une très petite police de caractères. Chaque caractère est affiché dans un petit rectangle de 3 pixels de large et 5 pixels de haut – très petit mais étonnamment facile à lire. Nous avons besoin de caractères pour les chiffres 0 – 9 et les lettres A – F pour afficher les nombres hexadécimaux.
#one row per 5x3 digit - 0 to 15 - Hexadecimal symbols
nums =[0,1,0,1,0,1,1,0,1,1,0,1,0,1,0, # 0
0,1,0,0,1,0,0,1,0,0,1,0,0,1,0, # 1
1,1,1,0,0,1,0,1,0,1,0,0,1,1,1, # 2
1,1,1,0,0,1,1,1,1,0,0,1,1,1,1, # 3
1,0,0,1,0,1,1,1,1,0,0,1,0,0,1, # 4
1,1,1,1,0,0,1,1,1,0,0,1,1,1,1, # 5
1,1,1,1,0,0,1,1,1,1,0,1,1,1,1, # 6
1,1,1,0,0,1,0,1,0,1,0,0,1,0,0, # 7
1,1,1,1,0,1,1,1,1,1,0,1,1,1,1, # 8
1,1,1,1,0,1,1,1,1,0,0,1,0,0,1, # 9
0,1,0,1,0,1,1,1,1,1,0,1,1,0,1, # A
1,1,0,1,0,1,1,1,0,1,0,1,1,1,0, # B
0,1,1,1,0,0,1,0,0,1,0,0,0,1,1, # C
1,1,0,1,0,1,1,0,1,1,0,1,1,1,0, # D
1,1,1,1,0,0,1,1,1,1,0,0,1,1,1, # E
1,1,1,1,0,0,1,1,1,1,0,0,1,0,0] # F
powers = [1,2,4,8,16,32,64,128] # For Bin and Hex
Le schéma binaire de chaque caractère est contenu dans une liste appelée chiffres, à partir de la ligne 39. Chaque caractère a besoin de 15 uns ou zéros. L’ordre est de cinq lignes de trois valeurs avec la ligne du haut en premier. Un un représente un pixel allumé et un zéro un pixel éteint. Nous pouvons appliquer la couleur appropriée ultérieurement.
En regardant zéro, dans la première ligne, nous avons :
0,1,0,1,0,1,1,0,1,1,0,1,0,1,0, # 0 0 1 0 1 0 1 1 0 1 1 0 1 0 1 0
Nous avons maintenant besoin de certaines routines pour afficher ces motifs sous forme de pixels éclairés à l’écran.
def show_num(val,xd,yd,r,g,b): # Single digit
offset = val * 15
for p in range(offset,offset + 15):
if nums[p] == 1:
xt = p % 3
yt = (p-offset) // 3
xy_set(xt+xd,yt+yd,(r,g,b))
Cela affiche un seul caractère numérique de la police, val, avec le coin supérieur gauche à la position (xd, yd) dans la couleur spécifiée par r, g, b. val doit être compris entre 0 et 15.
Le décalage est la position calculée du premier 0 ou 1 dans le tableau pour val. La boucle parcourt les 15 bits de la table pour ce caractère. Si le bit est égal à 1, il calcule la position (xt+xd, yt+yd) et définit ce pixel sur la couleur requise. Cette routine est appelée, si nécessaire par la procédure suivante.
def show_number(val,r,g,b): #Base 10 - Hundreds, tens and units
abs_val = abs(val)
temp = abs_val
hund = abs_val // 100
temp = abs_val - hund *100
tens = temp // 10
units = temp % 10
clear()
if (abs_val > 99): show_num(hund,4,2,r,g,b)
if (abs_val > 9): show_num(tens,8,2,r,g,b)
show_num(units,12,2,r,g,b)
Cette routine dessine un entier, val, dans la plage 0 – 999 sur l’affichage dans la couleur spécifiée.
- La valeur absolue, toujours positive, est divisée en centaines, dizaines et unités.
- L’écran est effacé
- Les centaines, les dizaines et les unités sont affichées selon les besoins à l’aide de show_num().
def show_utime(hrs,mins,r,g,b):
clear()
tens = hrs // 10
units = hrs % 10
show_num(tens,0,2,r,g,b)
show_num(units,4,2,r,g,b)
show_colon(7,3)
tens = mins // 10
units = mins % 10
show_num(tens,8,2,r,g,b)
show_num(units,12,2,r,g,b)
Cette routine utilise des méthodes similaires pour afficher une heure en heures et minutes avec deux-points entre les valeurs, comme dans l’exemple ci-dessous :
powers = [1,2,4,8,16,32,64,128] # For Binary
def show_binary(val,r,g,b):
for index in range(0, 8):
if powers[index] & val:
xy_set(11-index,9,(r,g,b)) # Coloured
else:
xy_set(11-index,9,(0,0,0)) # Black
def show_hex(val,r,g,b):
nibble_hi = val // 16 # A nibble/nyble is half a byte
nibble_low = val % 16
show_num(nibble_hi,4,2,r,g,b)
show_num(nibble_low,8,2,r,g,b)
Ces routines affichent les valeurs en hexadécimal et en binaire.
La partie principale du programme fait appel à ces routines pour démontrer les différents formats. Pendant la section de comptage, la couleur des valeurs négatives et le signe moins sont appliqués.
Choses à essayer
Lire la température du Pico
Lisez la température du capteur intégré au Pico et affichez la partie entière sur les LED avec la lettre C.
import machine
import utime
sensor_temp = machine.ADC(4)
conversion_factor = 3.3 / (65535)
while True:
reading = sensor_temp.read_u16() * conversion_factor
temperature = 27 - (reading - 0.706)/0.001721
print(temperature)
utime.sleep(2)
Ce n’est pas très précis et on trouve toujours les valeurs trop élevées. Vous pouvez utiliser un capteur de température tel qu’un DHT11, DHT22, TMP36 ou DS18B20 pour améliorer la précision de votre sortie.
Construire une horloge numérique
Utilisez un « ticker-timer » d’une seconde ou utime.ticks_ms() pour construire une horloge numérique avec l’affichage pour le rendre facilement visible. En utilisant temps.sommeil(1) entre les mises à jour de l’affichage s’exécutera trop lentement car le réglage de l’écran et la mise à jour prennent peu de temps. Voir page 73 du Guide Pico pour utime.ticks_ms() aider.
Utiliser une horloge en temps réel
Pour plus de précision et de facilité de réglage, utilisez une RTC (Real Time Clock) telle que DS1302 ou DS3231.
Pixel rebondissant
#========== MAIN ===============
x = 4 # x position
xd = 1 # x direction
y = 5 # y position
yd = 1 # y direction
clear()
xy_set(x,y,(280,0,0))
pixels_show()
while True:
clear()
x = x + xd
if x > 14:
xd = -1
elif x < 1:
xd = 1
xy_set(x,y,(280,0,0))
pixels_show()
utime.sleep(0.1)
Vous pouvez télécharger le programme complet ici : WS Neopixels 160 Bounce.py
Exécutez le programme et vous verrez un seul pixel rouge se déplacer horizontalement sur l’écran. Quand il atteint le bord, il rebondit !
Modifications à essayer
- Ajoutez du code pour le faire se déplacer en diagonale en mettant à jour la valeur y dans la boucle et rebondir également sur les bords supérieur et inférieur
- Changer la couleur du pixel en fonction de la direction dans laquelle il se déplace
- Dessinez un cadre gris autour du bord de l’écran et faites-le rebondir sur ce
- Augmentez la taille de l’objet rebondissant à un carré de 4 pixels
À venir dans la partie 2
Dans la partie 2, nous vous montrerons comment faire défiler du texte coloré et des valeurs numériques sur l’écran à l’aide d’un jeu de caractères étendu. Nous verrons également comment afficher les lectures de capteur d’un BME680 !
N’oubliez pas de consulter notre section Raspberry Pi Pico pour d’autres super add-ons et accessoires !
Cet article a été écrit par Thomas. Thomas est un professeur d’informatique à la retraite qui a commencé à écrire du code en 1968 alors que cela s’appelait programmation – il a commencé avec FORTRAN IV sur un IBM 1130 ! Membre actif de la communauté Raspberry Pi, ses principaux centres d’intérêt sont désormais le codage en MicroPython, les voyages et la photographie.