[AUDIO_VIDE]

Bonjour.

Nous entrons véritablement dans le cœur de notre sujet.

Nous parlerons d'afficheurs matriciels à LED.

Nous introduirons d'abord la notion de pixels

et les caractéristiques des afficheurs matriciels.

Nous regarderons ensuite comment réaliser des matrices de LED et en particulier

comment utiliser des registres pour les piloter.

Nous parlerons ensuite de programmation

en mettant en évidence la génération et le rafraîchissement de l'image.

Le terme d'afficheur est utilisé pour désigner un dispositif électronique

permettant de présenter visuellement des données.

Lorsqu'il s'agit d'un afficheur matriciel, on a un ensemble de

pixels qui va permettre de composer des formes et des images.

La résolution c'est ce qu'on appelle la distance entre

un pixel et son plus proche voisin.

Le terme anglais souvent utilisé est le terme de pitch.

Si vous voyez par exemple pour décrire une matrice à LED le terme P6,

vous pouvez comprendre qu'il s'agit d'un pitch de 6 millimètres, et

cette distance de 6 millimètres correspond à la distance entre chaque pixel.

On parle aussi parfois de densité de pixels,

c'est-à-dire le nombre de pixels par unité de surface, par exemple en mètres carrés.

Voici un exemple d'afficheur matriciel à LED : on a des lignes de LED,

on a aussi des colonnes, on parle donc de la coordonnée X et de la coordonnée Y.

Les gens qui travaillent dans l'infographie ont l'habitude d'avoir une

origine qui se situe ici, en haut à gauche,

et non pas comme dans la physique, en bas à gauche.

Comment faire pour piloter un si grand nombre de LED?

Eh bien nous allons utiliser la technique des registres série/parallèle

que nous connaissons.

Ici nous avons un afficheur de 16 LED

par ligne, nous avons huit registres.

Chaque entrée est commandée par un port du microcontrôleur.

Les horloges, elles, sont communes entre chacun des huit registres

: l'horloge série et l'horloge parallèle.

Donc on a ici un ensemble de 128 LED,

qui sont pilotées par seulement dix broches du microcontrôleur.

Voilà un petit programme qui permet d'afficher un motif sur notre afficheur.

Tout d'abord, les initialisations,

en particulier mettre en sortie chacune des broches utilisées.

Et dans la boucle principale nous allons avoir une boucle for,

avec 16 itérations, qui correspondent chaque fois à une colonne.

Et dans cette colonne, nous allons allumer un seul pixel, un décalé de i

et pour que i ne dépasse pas huit, on va ici faire une limitation, un et logique

qui serait aussi un modulo, et donc on utilise P2OUT pour envoyer cette colonne.

Après avoir envoyé les données,

on envoie un coup d'horloge série puis un coup d'horloge parallèle.

Comment faire pour envoyer par exemple des caractères?

Eh bien nous aurons un générateur de caractères qui a été placé dans un

tableau Donc ce tableau ne changeant pas, on peut l'appeler constant.

On utilise des mots de huit bits, je les ai notés ici en binaire et si vous

regardez, si vouspenchez la tête, vous verrez que ici nous avons formé un A.

Ici, nous avons formé un B, ici nous avons formé un C, etc.

Pour afficher un texte,

nous allons mettre cette chaîne de caractères en mémoire et nous utiliserons

un pointeur pour aller chercher successivement chacun des caractères.

Voilà donc notre programme qui nous affiche ces quelques caractères.

Tant que le texte n'est pas terminé, donc que le

pointeur au texte ne pointe pas un caractère zéro qui est considéré comme

la fin de la chaîne de caractères, on va chercher le caractère : on va chercher

l'index du caractère dans la table, ici la table est multiplié par cinq

puisqu'il y a à chaque fois cinq colonnes pour faire un caractère,

et pour chacune de ces cinq colonnes eh bien il faut les envoyer sur la matrice

et donner les coups d'horloge comme tout à l'heure : on va attendre un certain temps.

À noter ici le tilde qui met en évidence le fait que

les caractères sont actifs à zéro, c'est bien un zéro à la sortie des

registres qui va allumer la diode lumineuse correspondante.

Ensuite on passe au caractère suivant.

On met à la fin de chaque caractère une colonne vide pour

bien les séparer visuellement et, de nouveau, on envoie les coups d'horloge.

Grâce à ces attentes,

on va pouvoir faire défiler notre petite texte sur notre afficheur.

Dans la pratique,

on rencontre rarement une géométrie aussi idéale que ce que nous avons présenté.

Dans la plupart des cas aussi,

nous utilisons des afficheurs multiplexés et le principe que nous avons utilisé

de faire directement décaler le texte sur notre affichage ne peut pas se réaliser,

nous devons passer à une autre technique qui consiste à générer l'image

puis la rafraîchir et ces deux étapes sont des étapes séparées.

Ce que nous allons faire, c'est créer une matrice qui correspond à notre afficheur.

Ici on a décidé de mettre des mots de 16 bits, qui correspondent donc à une ligne

et de mettre huit entrées dans cette table Nblignes qui est égal à huit.

Ce sont donc des mots de 16 bits qui sont utilisés,

on aurait pu faire d'autres choix, on le verra plus tard.

Lorsqu'il s'agit d'allumer un point à l'intérieur de cette matrice,

à partir des coordonnées X et des coordonnées Y,

c'est particulièrement simple, on va écrire ici Matrice, crochets, Y, ou,

égal c'est le set bit, un, [INAUDIBLE] X.

Si je reviens à la description précédente, on voit bien que je dois me déplacer

en y pour choisir un texte dans la matrice et que je dois allumer le

Xième bit en allant de zéro jusqu'à 15.

La même chose, naturellement, pour éteindre un point.

Cette fois on va faire la clear it, la mise a zéro du bit correspondant.

Et par exemple, pour créer une diagonale, on a défini ici le maximum en X

qui est 16, et le maximum en Y, qui a déjà été défini, qui est égal à huit.

Ici, on va, pour faire une diagonale sur notre afficheur,

aller de zéro jusqu'à huit, jusqu'à huit lignes.

et on va à chaque fois allumer un point qui aura comme coordonnées

pour Y la valeur i, et pour X une valeur qui sera le double

puisque MaxX/MaxY est effectivement égal à deux, de telle manière que la

diagonale se trace bien de cette manière là.

Nous avons donc ici généré une image, mais elle est purement virtuelle,

elle est à l'intérieur de la mémoire vive du microcontrôleur, elle n'est encore pas

du tout matérialisée : il va falloir maintenant afficher cette matrice.

Pour afficher la matrice, comme tout à l'heure, on va devoir réaliser une boucle

fois 16, donc pour chaque colonne, malheureusement, on n'a pas facilement

les valeurs, on doit aller rechercher les huit bits pour chaque colonne,

en allant de zéro à MaxY, c'est-à-dire de zéro à sept,

tester la valeur du bit correspondant et

allumer ou éteindre le bit correspondant.

Vous avez remarqué que j'ai dit allumer pour un clear et éteindre pour un set,

c'est toujours lié au fait que notre logique est inversée

et que un zéro va produire l'allumage d'une diode lumineuse.

Ensuite, le traditionnel coup d'horloge série et lorsqu'on

a tout éliminé, le coup d'horloge parallèle qui va faire que d'un seul coup,

l'ensemble de la matrice prendra une nouvelle valeur Après avoir

un peu peiné pour écrire cette procédure d'affichage, on se rend compte qu'il

aurait peut-être été plu intelligent d'envisager une matrice où cette fois

les colonnes se trouvent dans un mot de huit bits,

alors dans ce cas-là on a un nombre de colonnes qui est égal à 16,

donc on a une matrice qui a la même taille que tout à l'heure,

mais au lieu d'avoir huit fois deux octets, on a 16 fois un octet.

Et alors, dans ce cas-là, l'affichage de la matrice est beaucoup plus simple : il

suffit de prendre le contenu dans la matrice et de le mettre directement

sur le registre huit bits qui correspond aux bits d'une colonne.

Comment faire pour créer des animations sur notre afficheur?

Il faut préparer une image en mémoire, il faut envoyer son contenu sur l'afficheur,

attendre le temps nécessaire pour que l'œil puisse voir ce qui a été affiché

puis préparer une autre image, etc.

On voit bien qu'on a une alternance

génération de l'image puis rafraîchissement de l'affichage.

On va terminer par l'écriture d'un petit programme qui fait une animation de type

ping-pong : une balle va rebondir sur les bords de l'afficheur.

On va commencer à se trouver en position (X,Y)=0,

on terminera lorsqu'elle reviendra à cette position et, durant chaque cycle,

on va fondamentalement allumer le point concerné, la balle,

afficher la matrice et attendre un certain temps, puis éteindre le point,

et ensuite il va falloir calculer le prochain point : on va incrémenter X,

ou plus exactement lui ajouter la valeur sensX qui, au départ, est égal à un.

La même chose pour Y : on va lui ajouter sensY qui au début est égal à un.

Maintenant évidemment pour ne pas dépasser les bords, lorsqu'on va arriver à une

valeur plus grande que MaxX, eh bien on va

changer le sens en X et de la même manière on va changer le sens en Y.

Nous avons donc parlé de la notion de pixel, des caractéristiques des

afficheurs, en particulier le fameux pitch, nous avons vu comment faire des

matrices à LED, nous avons vu comment les programmer, et en particulier comment

utiliser le mécanisme de génération de l'image puis son rafraîchissement.

4.1 Les afficheurs matriciels

Enseignes et afficheurs à LED

Conheça os instrutores