0:19
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.
0:41
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.
1:07
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,
1:42
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.
2:00
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.
2:54
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.
3:38
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.
4:29
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
4:45
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.
5:51
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.
6:41
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
7:57
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
9:39
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.
9:58
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.
10:15
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.
10:41
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.
11:53
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.