Les matrices de LEDs LTP305 permettent d’afficher 2 caractères sur une matrice de 5×7 très brillante. Je vous explique comment les utiliser sur la carte Pico Explorer de Pimoroni, avec le Raspberry Pi PICO. Les programmes sont en MicroPython.

Au sommaire :

Breakout LTP305 MED Matrix sur Pico Explorer

Dans la série des cartes Breakout de Pimoroni, je vous avais présenté les modules BME680 et RV3028 sur Pico Explorer. Aujourd’hui voici la carte LTP305.

[stextbox id=’info’ caption=’Objectifs’]L’objectif de cet article n’est pas de faire un tutoriel sur le bus I2C ou sur Python. Pas question de réinventer le fil à couper l’eau chaude ! Il s’agit de montrer qu’en utilisant des composants clé en main, des programmes existants auxquels on apporte quelques modifs on peut faire fonctionner tout ça ensemble sur un Raspberry Pi Pico. L’idée c’est d’essayer, d’expérimenter…[/stextbox]

La matrice de LEDs

Cette matrice de LED’s LTP305 ne date pas d’hier puisque les premiers développements datent de… 1970 ! C’est une matrice de LED’s tout ce qu’il y a de plus classique. Vous pouvez télécharger la datasheet LTP305 en cliquant sur ce lien.

LTP-305HR

Comme toutes les matrices, elle est organisée en lignes (7) et en colonnes (5). Pour allumer une LED il suffit d’envoyer un courant sur la colonne et de mettre à la masse la ligne correspondante.

Par exemple, si on envoie du courant dans la colonne 2 et qu’on met la rangée 3 à la masse, la seule LED qui s’allumera sera la LED située à l’intersection C2-R3 (cerclée en bleu).

Vue rapprochée des matrices de LEDs. En bas à gauche de chaque afficheur, le point décimal

On voit aussi que pour pouvoir allumer les LED de son choix, il faut « balayer » lignes et colonnes, tout en gérant le courant qu’on envoie. Cela peut se gérer depuis les broches GPIO d’un microcontrôleur (j’ai fait des trucs comme ça au siècle dernier pour gérer des afficheurs ou des claviers…) ou alors on confie la tâche à un circuit spécialisé qui se charge de gérer tout ça. c’est ce Pimoroni a choisi pour sa carte Breakout Garden.

Le circuit de commande (driver) IS31FL3730

Le circuit choisi par Pimoroni pour animer sa carte LTP305 est un driver de matrices de LEDs IS31FL3730.

C’est un circuit qui peut gérer 2 matrices. Pour diminuer le nombre de broches de sortie (plus il en a plus ça augmente le prix du circuit), le fabricant a choisi de gérer 2 matrices avec les mêmes fils, tout simplement en inversant le sens du courant dans les LEDs quand on passe d’une matrice à l’autre. Il suffit alors de 24 broches pour ce circuit. Vous voyez ci-dessus une des matrices en LEDS noires, l’autre en LEDs bleues.

Le circuit de commande 3730 sur la carte Pimoroni Breakout LTP305

Ce circuit est capable de gérer différents types de matrices :

8×8 (utilisé ici)
7×9
6×10
5×11

Le choix du type de matrice se programme via un registre interne. vous en saurez plus en téléchargeant la datasheet du IS31FL3730.
A noter que ce circuit possède aussi une entrée audio (non utilisée sur la carte) qui peut moduler la luminosité des LEDs en fonction de son intensité.

La carte Breakout Garden de Pimoroni

C’est sur la base de ces composants que Pimoroni a bâti sa carte Breakout Garden LED MATRICES + DRIVER. Alimentée entre 3 et 5 volts, elle se pilote via le bus I2C et est compatible avec les supports Breakout Garden. La carte existe avec des matrices de LEDs rouges ou vertes.

La carte LTP305 vue de dessus

Les pastilles de la carte vous permettent de l’enficher directement dans un support Breakout Garden, mais vous pouvez aussi y souder des picots droits ou à 90 degrés pour l’utiliser sur une breadboard (carte de prototypage) ou un circuit imprimé (PCB).

Le connecteur Breakout est un simple connecteur 5 contacts pour circuit imprimé. Il y en a 2 sur la carte Pico Explorer. De nombreuses cartes sont disponibles dans ce format chez Pimoroni ou en France chez Kubii.

La carte vue de dessous. On y voit le driver de matrices de LEDs 3730 en bas de la carte. L’adresse par défaut de la carte sur le bus I2C est 0x61. Vous pouvez la passer en 0x63 en coupant la piste en ADDR2. Il suffira de mettre une goutte de soudure entre les deux pastilles pour revenir à l’adresse d’origine. Si vous coupez la piste et reliez les deux pastilles en ADDR1 par une goutte de soudure, l’adresse passera en 0x62. Il est ainsi possible d’utiliser jusqu’à trois de ces cartes en même temps sur le même bus I2C. Pourquoi faire ? Me direz vous ? Pour une horloge avec 6 afficheurs par exemple, ou un affichage de fréquence ou de stations sur une radio…

Les programmes

Les programmes sont écrits en MicroPython pour le Raspberry Pi Pico. Cela implique que vous ayez déjà installé le MicroPython de Pimoroni sur votre PICO. (Si ce n’est pas fait regardez les précédents articles sur Pico du blog). Il existait une librairie pour la carte LTP305 en Python sur le github de Pimoroni. C’est cette librairie ainsi que le fichier de polices que j’ai utilisés en les intégrant à mes programmes. Il n’y a pas de librairie pour le moment – 05/2021 – (à ma connaissance) pour le LTP305 en MicroPython mais ça ne saurait tarder…

[stextbox id=’grey’ caption=’A propos des programmes’]Les programmes sont un peu bruts de fonderie, je vous les livre tels quels ! Il peut rester des print() destinés à voir comment il fonctionne quand il y a des doutes. C’est du MicroPython de maker, hein, pas du Python de développeur. L’important c’est que ça fonctionne et que vous puissiez vous en inspirer. Pas la peine de me pourrir parce que mes programmes ne sont pas propres 🙂 Après si vous êtes capable de programmer parfaitement, vous avez le droit de les réécrire et de les publier, ça sera profitable à la communauté. Mais râler pour râler… Ça ne sert à rien ni à personne.[/stextbox]

La bibliothèque LTP305

Cette bibliothèque est disponible sur le github de Pimoroni. Elle crée un classe LTP305 qui propose un certain nombre de fonctions :

clear() : effacer les matrices
set_brightness() : configurer la luminosité des LEDs (de 0 à 1) ça peut servir par exemple pour une horloge en baissant la luminosité la nuit.
set_decimal() : gère les points décimaux des afficheurs
set_pixel() : Allume/éteint un unique pixel
set_character() : envoie un caractère sur une des matrices
get_shape() : récupère la taille de la matrice (10×7)
set_image() : met une image PIL dans les matrices
show() : Envoie le contenu du buffer vers l’afficheur

En dehors de get_shape() et set-image(), j’utilise ces fonctions dans les programmes ci-dessous.

Le fichier Fonts

Ce fichier fonts.py contient les caractères qui vont être affichés sur les matrices de LED. On y trouve par exemple dans cet extrait :

font = {
32: [0x00, 0x00, 0x00, 0x00, 0x00], # (space)
33: [0x00, 0x00, 0x5f, 0x00, 0x00], # !
...
48: [0x3e, 0x51, 0x49, 0x45, 0x3e], # 0
49: [0x00, 0x42, 0x7f, 0x40, 0x00], # 1
50: [0x42, 0x61, 0x51, 0x49, 0x46], # 2
51: [0x21, 0x41, 0x45, 0x4b, 0x31], # 3
...
65: [0x7e, 0x11, 0x11, 0x11, 0x7e], # A
66: [0x7f, 0x49, 0x49, 0x49, 0x36], # B
67: [0x3e, 0x41, 0x41, 0x41, 0x22], # C

font = {

32: [0x00, 0x00, 0x00, 0x00, 0x00], # (space)

33: [0x00, 0x00, 0x5f, 0x00, 0x00], # !

...

48: [0x3e, 0x51, 0x49, 0x45, 0x3e], # 0

49: [0x00, 0x42, 0x7f, 0x40, 0x00], # 1

50: [0x42, 0x61, 0x51, 0x49, 0x46], # 2

51: [0x21, 0x41, 0x45, 0x4b, 0x31], # 3

...

65: [0x7e, 0x11, 0x11, 0x11, 0x7e], # A

66: [0x7f, 0x49, 0x49, 0x49, 0x36], # B

67: [0x3e, 0x41, 0x41, 0x41, 0x22], # C

Le chiffre à gauche représente le code ASCII du caractère (en décimal), on trouve ensuite les 5 octets représentant chaque colonne de la matrice, les 1 sont utilisés pour indiquer les LED allumées, et en bout de ligne la représentation alphanumérique du caractère.

Par exemple pour le A code ASCII 65 en décimal ou 0x41 en hexadécimal :

65: [0x7e, 0x11, 0x11, 0x11, 0x7e], # A

A gauche vous avez la transcription des octets du A et à droite ce que ça donne sur l’afficheur. Le caractère a sur l’afficheur de droite a pour code ASCII 97 en décimal ou 0x61 en hexadécimal. Si j’avais un peu de temps, je vous expliquerais le code ASCII plus en détail car c’est (à mon avis) une merveille d’invention. Les chiffres par exemple, pour lesquels il suffit de masquer les 4 bits de poids fort (très rapide en microcontrôleur) pour passer de leur code ASCII à leur valeur décimale.

Ou encore les majuscules et les minuscules. On voit ci-dessus qu’entre la minuscule et la majuscule, il n’y a qu’un bit d’écart en ASCII. C’est justement ce bit que vous faites passer à 0 quand vous appuyez sur la touche SHIFT de votre clavier 😉 Mais bon, on n’est pas là pour ça et je n’ai pas le temps 😛

Après, avec les informations sur ce fichier fonts.py, vous devez être capable de transformer tout dessin ou caractère de 5×7 en octets, puis de lui attribuer un code ASCII et de l’afficher sur la carte LTP305…

Compteur de 0 à 99

On va commencer par un compteur qui compte de 0 à 99. Vous pouvez le télécharger avec tous les autres programmes de cet article en cliquant sur ce lien. Il existe deux versions du programme, une avec les codes ASCII au complet, une autre avec juste les codes ASCII nécessaires pour le compteur compteur_ltp305_min.py.

# Initialiser variables
compteur = 0   # Compteur
point =1       # Etat du point décimal

# Eteindre les points décimaux
set_decimal(0,0)

# Boucle infinie
while True:
    # Transformer le compteur en chaine de caractères
    if compteur &lt; 10: 
        right = str(compteur) 
        left = "0" 
    else : display = str(compteur) 
        left, right = display 

    # Mettre les caractères correspondants dans les buffers 
    set_character(0, left) 
    set_character(5, right) 

    # Afficher les buffers 
    show() 

    #Incrémenter le compteur 
    compteur += 1 

    # Faire clignoter points décimaux 
    if point ==1: 
        point=0 
    else: 
        point = 1 
    if point == 1: 
        set_decimal(0,1) 
    else : 
        set_decimal(1, 0) 
    
    # Quand le compteur atteint 99 
    if (compteur &gt; 99) :
        compteur = 0
        # Eteindre les LED
        clear()
        show()
        # Attendre 2 secondes
        sleep (2)
    sleep(0.25)

# Initialiser variables

compteur = 0 # Compteur

point =1 # Etat du point décimal

# Eteindre les points décimaux

set_decimal(0,0)

# Boucle infinie

while True:

# Transformer le compteur en chaine de caractères

if compteur < 10:

right = str(compteur)

left = "0"

else : display = str(compteur)

left, right = display

# Mettre les caractères correspondants dans les buffers

set_character(0, left)

set_character(5, right)

# Afficher les buffers

show()

#Incrémenter le compteur

compteur += 1

# Faire clignoter points décimaux

if point ==1:

point=0

else:

point = 1

if point == 1:

set_decimal(0,1)

else :

set_decimal(1, 0)

# Quand le compteur atteint 99

if (compteur > 99) :

compteur = 0

# Eteindre les LED

clear()

show()

# Attendre 2 secondes

sleep (2)

sleep(0.25)

Avant ce programme vous retrouverez les fonctions de la bibliothèque Python que j’ai portées dans ce fichier. Quelques indications : Si le compteur est entre 0 et 9, il n’y a qu’un chiffre. on force le chiffre de gauche à 0 : left = « 0 » sinon entre 10 et 99 on sépare simplement les deux chiffres.

set_decimal (g, d) gère les points décimaux, un 1 allume le point, un 0 l’éteint. g pour le point gauche, d pour le point droit. clear() met à 0 toutes les LED dans le buffer. Il faut envoyer le buffer sur l’afficheur avec show() pour que l’extinction soit prise en compte.

Thermomètre

Cette vidéo vous montre le résultat du programme compteur ci-dessus et du thermomètre ci-dessous.

Ici l’idée c’est d’ajouter une carte breakout BME680 qui va mesurer la température, pour l’afficher sur les matrices de LEDs.

A droite la carte Breakout BME680 à gauche affichage de la température.

point =1
# Eteindre les points décimaux
set_decimal(0,0)

while True:
    temp = round(bme.temperature, 0)
    print ("Temperature ", temp )
    print ("Chaine ", str(temp))
    t = str(temp)
    resul = t[0:2]
    print ("Resultat ", resul)

    if temp &lt; 10:
        right = str(temp)
        left = "0"
    else :
        t = str(temp)
        display = t[0:2]
        left, right = display
    
    set_character(0, left)
    set_character(5, right)
    show()
    if point ==1:
        point=0
    else:
        point = 1
    if point == 1:
        set_decimal(0,0)
    else :
        set_decimal(1, 0)

    sleep(1)

point =1

# Eteindre les points décimaux

set_decimal(0,0)

while True:

temp = round(bme.temperature, 0)

print ("Temperature ", temp )

print ("Chaine ", str(temp))

t = str(temp)

resul = t[0:2]

print ("Resultat ", resul)

if temp < 10:

right = str(temp)

left = "0"

else :

t = str(temp)

display = t[0:2]

left, right = display

set_character(0, left)

set_character(5, right)

show()

if point ==1:

point=0

else:

point = 1

if point == 1:

set_decimal(0,0)

else :

set_decimal(1, 0)

sleep(1)

La lecture de la température sur le BME680 se fait de la même façon que dans l’article précédent.
On commence par éteindre les points décimaux. Le point gauche va clignoter au rythme des mesures. Ça permet de vérifier que le programme est encore « vivant ». Si la température est entre 0 et 9 on force le chiffre de gauche à 0 comme pour le programme du compteur. Je n’ai pas géré les températures négatives. En fin de programme on fait clignoter le point décimal à chaque mesure.

Pixels et PWM

Cette fois on va gérer chaque pixel comme une entité et faire varier la luminosité des matrices. On ne peut pas faire varier la luminosité d’un unique pixel.

# Eteindre points décimaux
set_decimal(0,0)

while True:
    # Affichage de l'alphabet Majuscules et minuscules
    for n in range (13): 
        set_character(0, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' [n],)
        set_character(5, 'abcdefghijklmnopqrstuvwxyz' [n])
        show()
        sleep(0.25)
    #Eteindre affichage
    clear()
    show()
    sleep(1)
    #Allumer les points
    for x in range (10):
        for y in range (7) :
            set_pixel(x, y, 1)
            show()
            sleep(0.070)
    sleep(1)
    # Faire pulser la luminosité
    print ("Pulse luminosité")
    for m in range (3) :
        for i in range (100) :
            set_brightness(i/100,1)
            sleep(0.025)
    # Eteindre les points
    print ("Extinction points")
    for y in range (7, -1, -1):
        print ("X ", x)
        for x in range (10, -1, -1) :
            print ("Y ", y)
            set_pixel(x, y, 0)
            show()
            sleep(0.070)
    sleep(1)

# Eteindre points décimaux

set_decimal(0,0)

while True:

# Affichage de l'alphabet Majuscules et minuscules

for n in range (13):

set_character(0, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' [n],)

set_character(5, 'abcdefghijklmnopqrstuvwxyz' [n])

show()

sleep(0.25)

#Eteindre affichage

clear()

show()

sleep(1)

#Allumer les points

for x in range (10):

for y in range (7) :

set_pixel(x, y, 1)

show()

sleep(0.070)

sleep(1)

# Faire pulser la luminosité

print ("Pulse luminosité")

for m in range (3) :

for i in range (100) :

set_brightness(i/100,1)

sleep(0.025)

# Eteindre les points

print ("Extinction points")

for y in range (7, -1, -1):

print ("X ", x)

for x in range (10, -1, -1) :

print ("Y ", y)

set_pixel(x, y, 0)

show()

sleep(0.070)

sleep(1)

Encore une fois on éteint les points décimaux. Pour le plaisir j’ai affiché les 13 premières lettres de l’alphabet en maj. et min. si vous voulez tout l’alphabet passez à 26 au lieu de 13.
Ensuite allumage des points en vertical avec 2 boucles.
Pour faire pulser la luminosité on envoie une valeur entre 0 et 1 et enfin on éteint les points en horizontal avec les deux dernières boucles.

Et voilà ce que ça donne en vidéo.

Conclusion

Vous avez maintenant de quoi vous amuser avec ces matrices sur la carte Pico Explorer et un Raspberry Pi Pico. N’hésitez pas à utiliser les commentaires pour dire ce que vous en avez fait ou pour proposer vos propres programmes que je rajouterai à l’article.
Vous pouvez télécharger les programmes de l’article en cliquant sur ce lien.

Framboise 314, le Raspberry Pi à la sauce française….

La référence du Raspberry Pi en France – Par l'auteur du livre "Raspberry Pi 4" paru aux Edts. ENI

Utilisation des matrices de LED LTP305 avec Raspberry Pi Pico

Breakout LTP305 MED Matrix sur Pico Explorer

La matrice de LEDs

Le circuit de commande (driver) IS31FL3730

La carte Breakout Garden de Pimoroni

Les programmes

La bibliothèque LTP305

Le fichier Fonts

Compteur de 0 à 99

Thermomètre

Pixels et PWM

Conclusion

Sources

À propos François MOCQ

Laisser un commentaire Annuler la réponse