- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.
--- L’équipe FantasPic ---
Modérateur : mazertoc
Voici les nouvelles du front
Merci Satinas, tu vois cela avance, bien sur a ma sauce avec plein de chemin détourné
voici un debut de commande , hey, une macro
Code : Tout sélectionner
couleur 0x00,0x0f,0xff,0xff
lfsr FSR0,Lettre_A
affiche .1,0x00,.10,0x00,.15,0x00,d'80',0x00,d'87'
et ca reception
Code : Tout sélectionner
affiche macro Let,columnSC1,columnSC2,columnEC1,columnEC2,pageSP1,pageSP2,pageEP1,pageEP2
movlw 0x2A ; set colonne adress
call Envoi_cmd
movlw columnSC1
call Envoi_data_8
movlw columnSC2 ; x
call Envoi_data_8
movlw columnEC1
call Envoi_data_8
movlw columnEC2 ; x
call Envoi_data_8
movlw 0x2B ; set page
call Envoi_cmd
movlw pageSP1
call Envoi_data_8
movlw pageSP2 ; y
call Envoi_data_8
movlw pageEP1
call Envoi_data_8
movlw pageEP2 ; y
call Envoi_data_8
movlw 0x2C ; memory write
call Envoi_cmd
movlw Let
movwf large_val
; lfsr FSR0,Lettre_A
call lettre
endm
Code : Tout sélectionner
;**********************************************************************
lettre
clrf trame_index
traitement_bits_suite
clrf bits
clrf passage
movf POSTINC0,w
movwf trame
movwf trame_sav
incf trame_index,f
t_bits
clrf large
btfss trame,5 ; lecture de la trame
bra vide_saut
plein_saut
rcall plein
incf large,f ; compteur largeur
movf large_val,w
subwf large,w
btfss STATUS,Z
bra plein_saut
bra t_bits_suite
vide_saut
rcall vide
incf large,f ; compteur largeur
movf large_val,w
subwf large,w
btfss STATUS,Z
bra vide_saut
t_bits_suite
rlncf trame,f ; decalage de la trame
incf bits,f ; compteur de decalage
movlw 0x06
subwf bits,w
btfss STATUS,Z
bra t_bits
incf passage,f
movf large_val,w
subwf passage,w
btfsc STATUS,Z ; si pas 0 alors sauter
bra saut_trame
movf trame_sav,w
movwf trame ; rechargement de la trame
clrf bits
bra t_bits
saut_trame
movlw 0x08
subwf trame_index,w
btfss STATUS,Z
bra traitement_bits_suite
return
plein
BITMAP
return
vide
BITFOND
return
T'es devenu addict à la macro :) va falloir te désintoxiquer, car c'est une solution de facilité. Vois avec Temps-x comment structurer l'appli en sous-programme, et utiliser les macros pas trop souvent. L'étape démarrage du lcd étant ok, il faut maintenant organiser calmement l'appli, car y a du boulot ...
Je pense qu'il faut les utiliser pour l'init, car on envoie des données déterminées. Ensuite, il s'agit de se construire des sous-programmes de tracés de point, rectangle, cercle, ... avec passage de paramètres. Ensuite affichage de caractères, tirés d'une police bitmap.
Les 2 contrôleurs fonctionnent de la même façon, envoi de commandes 8 bits et de données 8 ou 16 bits. Donc vous aurez peu de différence, juste l'init.
Je ne veux pas trop vous influencer, ne connaissant pas vos habitudes de programmation, chacun les siennes. Je ne sais plus raisonner en 8 bits, les ayant abandonnés depuis assez longtemps.
Tu as compris comment construire une macro avec arguments, c'est déjà super.
A part les macros facilitant la saisie, pour moi une macro doit être utilisée uniquement à la place d'un sous-programme appelé souvent, et donc la durée du call/return (4 cycles) n'est pas négligeable devant la durée d'exécution du sous-programme.
satinas a écrit :Bonjour JMarc,
Je ne veux pas trop vous influencer, ne connaissant pas vos habitudes de programmation, chacun les siennes. .
Niveau débutant donc aucune habitude
J'ai compris, pour l'init, seulement une macro comme cela c'est plus clair dans le source
puis j'ai pensé a faire une macro pour remplir les variables qui seront utilisé par la sous routine
Code : Tout sélectionner
affiche .1,0x00,.10,0x00,.15,0x00,d'80',0x00,d'87'
pour appeler
Code : Tout sélectionner
affiche macro m1,m2,m3,m4,m5,m6,m7,m8,m9
movlw m1
movwf large_val
movlw m2
movwf columnSC1
movlw m3
movwf columnSC2
movlw m4
movwf columnEC1
movlw m5
movwf columnEC2
movlw m6
movwf pageSP1
movlw m7
movwf pageSP2
movlw m8
movwf pageEP1
movlw m9
movwf pageEP2
call tableau
endm
qui appelle la sous routine
Code : Tout sélectionner
tableau
movlw 0x2A ; set colonne adress
call Envoi_cmd
movf columnSC1,w
call Envoi_data_8
movf columnSC2,w ; x
call Envoi_data_8
movf columnEC1,w
call Envoi_data_8
movf columnEC2,w ; x
call Envoi_data_8
movlw 0x2B ; set page
call Envoi_cmd
movf pageSP1,w
call Envoi_data_8
movf pageSP2,w ; y
call Envoi_data_8
movf pageEP1,w
call Envoi_data_8
movf pageEP2,w ; y
call Envoi_data_8
movlw 0x2C ; memory write
call Envoi_cmd
;**********************************************************************
lettre
clrf trame_index
traitement_bits_suite
clrf bits
clrf passage
movf POSTINC0,w
movwf trame
movwf trame_sav
incf trame_index,f
t_bits
clrf large
btfss trame,5 ; lecture de la trame
bra vide_saut
plein_saut
rcall plein
incf large,f ; compteur largeur
movf large_val,w
subwf large,w
btfss STATUS,Z
bra plein_saut
bra t_bits_suite
vide_saut
rcall vide
incf large,f ; compteur largeur
movf large_val,w
subwf large,w
btfss STATUS,Z
bra vide_saut
t_bits_suite
rlncf trame,f ; decalage de la trame
incf bits,f ; compteur de decalage
movlw 0x06
subwf bits,w
btfss STATUS,Z
bra t_bits
incf passage,f
movf large_val,w
subwf passage,w
btfsc STATUS,Z ; si pas 0 alors sauter
bra saut_trame
movf trame_sav,w
movwf trame ; rechargement de la trame
clrf bits
bra t_bits
saut_trame
movlw 0x08
subwf trame_index,w
btfss STATUS,Z
bra traitement_bits_suite
return
Là on est d'accord, la macro affiche se justifie, car c'est un raccourci de saisie, qui ne rallonge pas le code.
9 arguments pour la macro, ça fait beaucoup, ça complique son utilisation. Les arguments de macro sont gérés en mode traitement de texte, tu peux donc entrer des valeurs 16 bits et les couper en 2 octets dans la macro :
Code : Tout sélectionner
affiche macro m1, x1,y1, x2,y2
...
movlw (x1) / 0x100
movwf columnSC1
movlw (x1) % 0x100
movwf columnSC2
...
endm
Une nouvelle tentative avec ma pseudo-instruction, c'est à dire une macro courte qui ressemble à une instruction machine manquante. Les instructions machine et les macros étant affichées avec des couleurs différentes, pas de confusion possible. Donc ma pseudo-instruction toute simple, mais très utile, avec l'habitude tu ne devrais plus t'en passer, ou pas :)
Code : Tout sélectionner
movlf macro adr,val
movlw val
movwf adr
endm
Tu peux sans problème utiliser cette pseudo-instruction movlf dans la déclaration de la macro affiche.
Tu as entamé l'affichage de caractère, donc il faut te trouver une police bitmap.
Voila un exemple, celle d'Adafruit. Elle contient 256 caractères 5x7, qui occupent un pavé de 6x8 avec espacement et interligne. Je l'utilise avec possibilité de multiplier la taille par 2, 3, ...
https://github.com/adafruit/Adafruit-GF ... glcdfont.c
Faut pas lâcher, hein ...
Je n'avais pas compris les pseudos instructions, maintenant c'est bon
Ce soir j'essai tous cela
Oui, j'ai créé les deux lettres au pif pour les essais.
Hier j'ai trouvé sur le site MicroE un logiciel pour créer les fonts au format que l'on veut glcd font creator https://download.mikroe.com/setups/additional-software/glcd-font-creator/glcd-font-creator-v120.zip
J'ai essayé ton fichier adafruit mais je ne sais même pas ou se trouve la lettre A dans le fichier
Bon maintenant que j'ai compris le sens du format, je vais refaire ma routine. Je comptais utiliser la mémoire flash pour lire les lettres avec tablat, c'est correct ? Ou bien dois je mettre cela en ram et utiliser sfr?
Bien sur que je ne lâche rien
C'est pas compliqué, il y a 256 lignes, chaque ligne contient le graphisme d'une lettre, codes ascii 0 à 255.
Tu stockes ça en ram ou en flash. Le temps d'accès aux datas par FSR sera 2 fois plus rapide que par TBLRD, sauf erreur.
Pour afficher la lettre 'A' de code ascii 65, tu pointes sur l'adresse START_FONT + (5*65) et tu lis les 5 octets
cela donne 0x7C, 0x12, 0x11, 0x12, 0x7C
En affichant ces octets verticalement
Code : Tout sélectionner
b0 . . 1 . .
b1 . 1 . 1 .
b2 1 . . . 1
b3 1 . . . 1
b4 1 1 1 1 1
b5 1 . . . 1
b6 1 . . . 1
b7 . . . . .
Tu isoles chaque bit de chacun des 5 octets, et selon leur valeur, tu fais des SetPixel avec couleur caractère ou couleur de fond. C'est assez laborieux, mais ça passe avec mes cpus rapides.
On peut aller plus vite en remplissant un rectangle 6*8, toujours en testant les bits pour envoyer la bonne couleur. Ainsi on économise beaucoup de commandes 0x2A/0x2B/0x2C. Mais cela impose de changer d'octet à chaque test de bit, car on remplit horizontalement l'écran.
Ou alors trouver une police plus adaptée à la situation, définie avec des horizontales plutôt que des verticales. Mais difficile de trouver plus compact que la police Adafruit. Elle peut être convertie en mode "horizontal", il faudra alors 8 octets par caractère au lieu de 5.
L'affichage des caractères par des SetPixel n'est pas le plus rapide, par contre il offre l'avantage de simplifier l'affichage des caractères agrandis. Pour afficher des caractère de taille 3, c'est à dire 18x24, on remplit des rectangles 3x3 à la place du SetPixel.
L'affichage des caractères par des SetPixel n'est pas le plus rapide, par contre il offre l'avantage de simplifier l'affichage des caractères agrandis. Pour afficher des caractère de taille 3, c'est à dire 18x24, on remplit des rectangles 3x3 à la place du SetPixel.
Le SetPixel permet aussi de se créer un flag d'option "affichage fond", pour n'envoyer que les pixels du caractère, si l'on a effacé au préalable la zone d'écriture avec la couleur de fond.
Bonne journée
Merci pour toutes ces infos, j'ai de quoi m'occuper pour un bon moment
satinas a écrit :On peut aller plus vite en remplissant un rectangle 6*8, toujours en testant les bits pour envoyer la bonne couleur. Ainsi on économise beaucoup de commandes 0x2A/0x2B/0x2C. Mais cela impose de changer d'octet à chaque test de bit, car on remplit horizontalement l'écran.
.
C'est la méthode que j'avais choisi, mais la font que j'avais créé était horizontale, la tienne verticale comme le logiciel de microe donc j'ai changé mon sous programme, pour l'instant ça affiche mais c'est vraiment pas beau le code, je souhaite me débrouiller seul puis ensuite je posterai le résultat, cela fait travailler mon neurone
Jean-Marc, "je comprend vite mais il faut me l'expliquer longtemps "
Elle avance cette bibliothèque, félicitations JMarc
Juste un petit problème d'orientation :)
Les 4 valeurs du registre "Memory Acces Control" correspondant aux 4 orientations possibles sont :
0x88, 0x28, 0x48, 0xe8
Et pour écrire de droite à gauche
0x08, 0x68, 0xc8, 0xa8
On peut prévoir 2 variables Largeur et Hauteur, qui s'inversent selon l'orientation.
Retourner vers « Langage ASM »
Qui est en ligne
Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 137 invités