Voilà un an que j'écris sur ce blog sur l'assembleur arm pour le Rapsberry et c'est le 50ième post publié : ça s'arrose non !!
Dans ce post, nous allons voir comment utiliser le
framebuffer à partir de la mailbox pour tracer des lignes et écrire du texte
sur un écran relié au Raspberry par le câble HDMI.
Attention pour ces tests, j’utilise un écran dont la définition est de 800 sur 480 et donc
il vous faudra adapter certains paramètres à votre propre écran. Mon écran
nécessite aussi un certain paramétrage qui doit être ajouter dans le fichier
config.txt stocké sur la carte SD et qui est traité lors de l’initialisation du
Raspberry par le GPU (voir la documentation sur le Raspberry).
Et comme nous savons lire maintenant des fichiers de la
carte SD, j’ai ajouté dans les modules de ce projet, le module configuration.s
qui permet la lecture de mon propre fichier de configuration et la récupération
d’un paramètre (ici c’est debug). Ce fichier et ces paramètres bien que simples
peuvent être complétés avec d’autres paramètres pour configurer vos propres modules.
Revenons à l’affichage sur l’écran. Pour cela j’ai ajouté le
module framebuffer.s qui contiendra les routines nécessaires. Tout d’abord nous
trouvons une routine d’initialisation qui configure le framebuffer pour les
dimensions de l’écran et qui récupère les différentes informations nécessaires
et en particulier l’adresse de la zone mémoire dans laquelle il faudra écrire
les descriptions de chaque pixel de l’écran. Pour cela nous envoyons un message
au firmware par l’intermédiaire de la mailbox. Vous remarquerez que par rapport
à notre première approche de la mailbox au chapitre … Nous envoyons la totalité des messages en une
seule fois. Les codifications des messages sont stockées dans une table de 35
postes et miraculeusement cela fonctionne.
Ensuite, nous trouvons les routines de dessin d’un pixel,
d’une droite horizontale et d’une verticale. Je vous laisse le soin de réécrire
les routines vues au chapitre pour les dessins de rectangles vides et pleins,
les cercles et les polygones.
Mais ici nous trouvons en plus une routine pour écrire du
texte sur l’écran en utilisant un fichier binaire de l’exemple du tutoriel (en
C) trouvé sur :
Merci à ce développeur pour cet apport. L’utilisation de
cette police nécessite la récupération des informations stockées en début du
fichier (fichier qui sera inclus dans notre code avec la pseudo instruction .incbin)
à l’aide d’une structure (police décrite dans structures.inc). Si j’ai bien
compris, cette police est une police utilisée par linux et il doit donc être
possible de récupérer d’autres polices. Je laisse le soin aux courageux d’explorer
cette possibilité.
Cette police donne pour chaque caractère (code < 80h) la
description de chaque pixel suivant une image de 8 * 16 pixels. La routine
décrite ici va récupérer pour chaque caractère cette description puis l’analyser
et positionner dans la zone mémoire du framebuffer le code du pixel (soit noir pour
le fond soit un code couleur pour le texte). Compte tenu des 3 boucles incluses
l’une dans l’autre, j’ai essayé d’optimiser cette séquence mais il a fallu
utiliser tous les registres en 2 routines pour cela.
Mais cela reste imparfait puisqu’il faut sauvegarder et
restaurer 11 registres sur la pile à chaque caractère traité ce qui est couteux
(une trentaine de cycles pour chaque instruction push et pop !! )
Vous remarquerez que comme je l’avais déjà indiqué lors de
nos premières utilisations du Framebuffer, il faut trouver toutes les
descriptions de polices pour des tailles et types différentes !! bon courage à ceux qui veulent persister
dans cette voie !!
Et voilà le projet ici.
Aucun commentaire:
Enregistrer un commentaire