29 déc. 2016

Texte défilant avec MikroBasic et MAX7219

Suite à une question sur un forum j'ai adapté le programme en C à un nouveau (pour moi) compilateur, en l'occurrence MikroBasic de MikroElektronika.
Mise à jour le 05/01/2017 
Mise à jour le 08/01/2017 (voir en fin d'article)
Mise à jour le 10/01/2017

Affichage défilant et Mikrobasic 

Cette adaptation n'est pas simplement une conversion du C vers le Basic mais aussi une adaptation à des modules en cms.

Une petite explication s'impose.

Dans l'article précédent l'afficheur (en DIP) était utilisé comme ceci :

matrice 8*8 dip


et maintenant cela revient à utiliser le module comme ceci

matrice 8x8 cms

Donc on peut dire : les lignes sont maintenant des colonnes et les colonnes deviennent des lignes et bien sûr cela à des conséquences sur la fonction qui permet l'affichage et le défilement.

Attention, j'utilise la version de démonstration limitée à 2k de programme ce qui limite la fonte de caractères.

Création d'un caractère :


Un petit schéma pour expliquer la création d'un caractère ( le "1" en 7x5) :

caractère

Chaque caractère est défini par 8 octets et chaque octet représente la valeur de chaque ligne.



Dans un premier temps l’explication porte sur un seul afficheur avec une table de caractères de 7*5.

Nous désirons obtenir cette séquence pour le chiffre « 1 » :


matrice 8x8




Pour obtenir cela nous utilisons une boucle principale (6 step) et une boucle secondaire (8 step) pour obtenir les valeurs des 8 lignes à transmettre à l’afficheur.

Il est inséré un espace entre chaque caractère, ce qui explique la boucle principale de 0 à 5.


Pour chaque étape il est nécessaire de déterminer la valeur de chaque ligne à transmettre à l’afficheur et ceci est réalisé par la boucle secondaire.

La boucle principale comporte la boucle secondaire et l’instruction « m = m >>1 » avec m qui est initialisée à $80 soit en binaire : 10000000

L’instruction « >>1 » décale vers la droite le contenu de « m » ce qui revient à diviser par 2 la variable, ce qui donne :

valeur initiale : 10000000 ou $80
après 1 décalage : 01000000 ou $40
après 2 décalages : 00100000 ou $20

Je vous laisse déterminer la valeur de « m » après x décalages.
Important « m » est utilisée dans la boucle secondaire.

La boucle secondaire :
  • détermine la valeur de chaque ligne, 
  • stocke cette valeur dans la variable « aff_buffer », 
  • transmet la variable ‘aff_buffer » à l’afficheur, 
  • fait un décalage vers la gauche de la variable « aff_buffer ». 

Pour déterminer la valeur de chaque ligne il est fait une comparaison entre la valeur, contenue dans la table, correspondant à la ligne choisie ( ex : ligne 3 : $60) et la valeur « m » et suivant le résultat le bit 0 de la variable « aff_buffer » est mis à 1 ou reste à 0.

En pratique :

« if table7_5[i+(data1 * 8)] and m > 0 »

ce qui pour notre ligne 3 du chiffre 1 donne :

if 01100000 and 10000000 > 0

       01100000 ($60)
and
       10000000 (m = $80)
      -------------
       00000000

le résultat étant = à 0 le bit 0 de la variable « aff_buffer [i]» reste à 0

Après affichage (étape 1) un petit décalage vers la gauche « aff_buffer_1[i] = aff_buffer_1[i] <<1 » et nous obtenons aff_buffer[i] = 00000000.

Le même traitement est effectué pour les 7 autres lignes.

Revenons à notre ligne 3 :

Après un décalage vers la droite de la variable « m » nous refaisons le test

if 01100000 and 01000000 > 0

      01100000 ($60)
and
      01000000 (m = $40)
     -------------
      01000000

le résultat étant > 0 donc aff_buffer[i] = 00000001

on affiche et on décale vers la gauche ce qui donne aff_buffer[i] = 00000010

On reboucle tant que cpt n’est pas supérieur à 5.

Nous obtenons pour aff_buffer[i] :

00000011 puis
00000110

Et finalement nous obtenons en dernier (étape 5) : aff_buffer[i] = 00001100 avant un dernier petit tour pour insérer un espace avec le caractère suivant.

L'organigramme :



organigramme programme

Photo (vue arrière) des 4 afficheurs achetés chez "gowin_electronic" sur Ebay.

matrice 8x8 et max7219




Le fichier de démonstration est ICI, il comprend le fichier basic, une petite vidéo et la photo des afficheurs.

Par rapport à la vidéo il a été rajouter une séquence d'affichage et l'erreur sur le chiffre "0" est corrigée.

Pour une utilisation dans un programme il sera nécessaire de créer des fonctions pour afficher une constante, une variable et autres.

Il peut également être intéressant d'utiliser les interruptions pour remplacer l'utilisation de la fonction "delay_ms" car cela laisse peu de temps au programme principal.

Le schéma de la platine de test :

max7219 mikrobasic


Mise à jour du 05/01/2017:


Suite à des modifications sur le projet en C (MPLABX et XC8) j'ai également mis à jour cette version utilisant le compilateur Mikrobasic.

Cette mis à jour permet maintenant de choisir le nombre d'afficheurs, la fonte utilisée (non testé à ce jour) et une modification de la routine principale qui permet le défilement de l'affichage ( sub procedure aff_defilant) et des autres routines (sub procedure ecr_max7219, sub procedure ecr_7219_cmde et sub procedure efface_aff ).

La vidéo et le fichier basic sont disponibles ICI.

Mise à jour du 08/01/2017:

Ajout de la possibilité d'un affichage inversé et l'utilisation de "select case ".

Pour inverser les caractères il suffit d'utiliser "not" et on ajoute la variable p pour sélectionner un affichage normal ( p = 0) ou un affichage inversé (p = 1) pour cela il est possible d'utiliser un "IF" mais il existe aussi le "select case x" qui peut être intéressant dans le cas de multiple choix.

Comme nous n'avons pas encore utilisé cette possibilité c'est l'occasion de le faire.

sub procedure ecr_max7219(dim adresse, i , p as byte)
dim compt as byte
    ChipSelect = 0
    for  compt = 0 to Nbaff-1
         ecr_7219_byte(adresse)
         select case p
                case 0
                     ecr_7219_byte(aff_buffer [compt][i])
                case 1
                     ecr_7219_byte(not(aff_buffer [compt][i]))
         end select
    next compt
    ChipSelect = 1
end sub


Le fichier basic


Mise à jour du 10/01/2017 :


Cette mise à jour est normalement la dernière sauf si Monsieur Mikroe peut me faire parvenir une licence pour ces programmes ( nous sommes en début d'année on peut rêver !!!).

Nous avons utilisé pour créer les caractères un tableau à une dimension, cela fonctionne bien, mais c'est l'occasion de voir les tableaux à plusieurs dimensions, ce qui permet de voir la déclaration , l'initialisation et l'utilisation de ces tableaux (à part pour la déclaration je n'ai rien trouvé dans la documentation un exemple).

Notre tableau prend donc la forme suivante :

const table5v2 as byte [17][9]= (

  (5,$00,$70,$88,$88,$88,$88,$88,$70),             ' 0

  (5,$00,$20,$60,$A0,$20,$20,$20,$F8),             ' 1

  (5,$00,$70,$88,$10,$20,$40,$80,$F8),             ' 2

  (5,$00,$70,$88,$08,$30,$08,$88,$70),             ' 3

  (5,$00,$10,$30,$50,$90,$F8,$10,$38),             ' 4

  (1,$00,$00,$80,$80,$00,$80,$80,$00),             ' :

  (4,$00,$00,$00,$10,$20,$40,$80,$00),             ' /

  (5,$00,$00,$20,$20,$F8,$20,$20,$00),             ' +

  (3,$40,$A0,$40,$00,$00,$00,$00,$00),             ' °

  (2,$00,$00,$00,$00,$00,$00,$C0,$C0),             ' .

  (5,$00,$00,$00,$00,$00,$00,$00,$00),             ' espace

  (0,$00,$00,$00,$00,$00,$00,$00,$00),             ' colonne vide

  (8,$7E,$81,$A5,$81,$BD,$81,$81,$7E),

  (8,$7E,$81,$A5,$81,$A5,$99,$81,$7E),

  (7,$7E,$60,$60,$78,$60,$60,$60,$00),             ' F

  (6,$30,$30,$30,$30,$30,$30,$30,$00),             ' I

  (8,$C6,$E6,$F6,$DE,$CE,$C6,$C6,$00)              ' N

  )

Perso je trouve cela plus simple mais il y a une autre modification qui permet d'ajuster l'affichage au nombre de colonnes de chaque caractère.

Par ex "1" utilise 5 colonnes alors que ":" utilise 1 colonne, dans les versions précédentes si un caractère faisait moins de 5 colonnes un espace important était affiché.

Pour cela une valeur (en décimal pour la différencier des octets représentant le caractère) est inséré en début de chaque ligne.

La procédure d'affichage utilise cette valeur pour déterminer le nombre d'itération à effectuer.


sub procedure aff_defilant(dim data1, vitesse as byte)

 dim cpt,i,cc  as byte

     for cpt = 0 to table5v2[data1][0] 'font

Il est donc possible de mieux gérer l'affichage et aussi d'afficher un nombre de caractères supérieur au nombre de matrice 8*8 ( voir vidéo dans le zip).

Le fichier zip est disponible ICI


(Dans la vidéo ci-dessous il faut voir un sourire, pas autre chose ce n'est pas l'ADN de ce blog)









Aucun commentaire:

Enregistrer un commentaire