Comment utiliser le panneau matriciel LED couleur Waveshare RGB pour Raspberry Pi Pico – Partie 1

Comment Utiliser Le Panneau Matriciel Led Couleur Waveshare Rgb Pour Raspberry Pi Pico Partie 1

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 :

Matrice LED couleur RVB Waveshare pour connexion Pico

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.
Matrice LED RGB couleur Waveshare pour Raspberry Pi Pico Connexions manuelles

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

Couleurs de base de la matrice Waveshare Pico RGB 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

  1. Dessinez des triangles pointant vers l’intérieur à chaque extrémité de l’écran
  2. Dessinez une grande flèche orange sur l’écran pointant vers la droite
  3. Affichez la flèche en boucle et redessinez-la à chaque fois dans une couleur aléatoire différente
  4. 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

Matrice Waveshare Pico Affichage Valeurs numériques et temps 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 :

Temps d'affichage de la matrice LED RVB Waveshare

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.

  1. La valeur absolue, toujours positive, est divisée en centaines, dizaines et unités.
  2. L’écran est effacé
  3. 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 :
Matrice d'affichage Waveshare Pico RVB caractères

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.

  • Waveshare 1.3inch LCD Display Module for Raspberry Pi Pico 65K RGB Colors 240×240 Pixels SPI Interface Comes with Raspberry Pi Pico C/C++ and MicroPython Demo
    240×240 resolution, IPS screen, 65K RGB colors, clear and colorful displaying effect SPI interface, requires minimal IO pins 1x joystick and 4x user buttons for easy interacting Comes with development resources and manual (Raspberry Pi Pico C/C++ and MicroPython examples) Onboard Female Pin Header For Direct Attaching To Raspberry Pi Pico
  • Coolwell Waveshare 1.14inch LCD Display Module for Raspberry Pi Pico, Embedded ST7789 Driver, 65K RGB Colors, 240×135 Pixels, Using SPI Bus
    240×135 resolution, IPS screen, 65K RGB colors, clear and colorful displaying effect SPI interface, requires minimal IO pins 4x user buttons for easy interacting Comes with development resources and manual (Raspberry Pi Pico C/C++ and MicroPython examples): http://www.waveshare.com/wiki/Pico-LCD-1.14
  • Waveshare RGB Full-Color LED Matrix Panel 2.5mm Pitch 64x32 Pixels Adjustable Brightness Compatible with Raspberry Pi/Raspberry Pi Pico / ESP32 / Arduino
    Compatible with Raspberry Pi / Raspberry Pi Pico / ESP32 / Arduino. Chainable design,multi LED matrix panel can be chained together to build a larger panel via HUB75 input/output header. Usage Scenarios,DIY maker desktop or wall mount display, signboard, environment monitor.