Il y a quelques années, j'avais commencé une suite de tests pour le VG5000µ sous la forme d'un programme en mélange de C et assembleur.
L'idée était double : écrire une référence pour s'inspirer dans la programmation du VG5000µ (et particulièrement de l'EF9345), ainsi que
tester la fidélité des émulateurs.
Je me suis servi de cette base de code pour la première raison et mes besoins personnels. J'ai aussi pu corriger une paire de bugs dans
MAME grâce à la seconde utilisation.
Cependant, cette base de code traîne depuis un moment sur mon disque et je n'y passe pas beaucoup de temps. Alors autant que ça serve
à d'autres, et je mets donc aujourd'hui cette base à disposition.
Je ne sais plus trop dans quel état il est. Ça doit globalement fonctionner. J'imagine.
Cet article est la suite de deux précédents articles. Le premier, en plusieurs parties, était l'implémentation de l'affichage d'un « gros pixel » sur l'écran du VG5000µ. Le second était celui sur la possibilité (ou plutôt la difficulté) d'ajouter des commandes au BASIC du VG5000µ.
Il existe cependant une façon d'ajouter des commandes au BASIC... ou presque. Cette possibilité est évoquée brièvement dans le livre « Clefs pour VG5000 » page 98. À charge au lecteur de se débrouiller.
Cette méthode, indiquée dans le livre, est à vrai dire celle qui est utilisée par l'implémentation BASIC de la machine. Chaque routine d'instruction démarre avec HL qui pointe dans le buffer du texte BASIC sur l'octet suivant le token d'instruction, et donc sur ses éventuels paramètres.
C'est donc le cas, comme les autres, de l'instruction CALL. La routine de l'instruction se charge de lire l'adresse puis de l'appeler. Par lecture de ce paramètre, HL a …
Hier, en continuant le commentaire systématique de la ROM du VG5000µ, j'ai eu une impression de déjà-vu. Il me semblait bien avoir déjà commenté la partie « redéfinir un caractère étendu » (commandes SETE et SETG en BASIC).
L'impression persiste, voire s’accroît, au fur et à mesure et je me décide à aller voir dans ce que j'ai déjà commenté. J'ai commencé, lentement, ce commentaire en août 2017, avec moult pauses, mais aussi du « butinage ». Il y a donc des parties que je ne me rappelle plus avoir déjà traitées.
Et effectivement, un peu plus loin, je vois des commentaires similaires à ceux que je suis en train d'écrire. Les termes sont un peu différents, car au fil des commentaires, j'ai fait évoluer certains termes ou la manière de commenter, mais en regardant de plus près, oui, c'est évident, il y a deux fois la même routine dans la ROM.
Après cette implémentation en assembleur Z80 d'une fonction setpoint qui affiche, de manière assez basique, un point à l'écran, je me pose la question d'utiliser un langage de plus haut niveau... mais pas trop.
J'ai une assez longue expérience du C et la question que je me pose est : qu'est-ce que ça donne de programmer en C pour générer du code sur Z80.
Programmer en C a quelques avantages a priori : c'est nettement plus concis et lisible que de l'assembleur, j'y suis plus habitué et c'est portable sur de nombreuses plateformes. C'est le cas d'autres langages, mais le choix naturel pour moi puisque écrire du C m'est habituel. En tout cas bien plus habituel que d'écrire directement de l'assembleur Z80.
Premier essai
Voici le code C d'un premier essai :
#include<stdint.h> // Afin d'utiliser les types standardsvoidsetpoint(uint16_tx,uint8_ty)// Définition de la fonction// En entrée …
À présent que l'on sait diviser par 3, reprenons l'affichage d'un point à l'écran. Pour rappel.
En entrée, nous avons : des coordonnées X et Y, comprises entre 0 et 79 pour X et 0 et 74 pour Y.
En effet de bord, c'est-à-dire en modification de l'état de la machine, nous voulons : le point correspondant à l'écran qui prend la couleur d'encre définie.
Pour cette version, la procédure ne prendra pas d'information de couleur, je me contenterai d'utiliser la couleur d'encre 0 (noir) sur fond 6 (bleu), qui est la combinaison à l'initialisation de la machine.
Les étapes, d'après les articles précédents, sont donc :
À partir de X et Y, trouver les coordonnées du caractère à modifier à l'écran
À partir de X et Y, trouver les coordonnées à l’intérieur du caractère semi-graphique
À partir de coordonnées du caractère, calculer l'adresse mémoire écran correspondante
La méthode de cet article, qui sera le dernier avant de revenir à l'affichage d'un point, va diviser grâce à, globalement, une seule addition. Oui ! Une seule addition.
L'idée
Au tout début de la série d'articles sur la division, j'ai mis en place un système de tests pour m'assurer que mes bouts d'assembleurs faisaient ce qu'il étaient censés faire. Et pour cela, je comparais une série de divisions avec un tableau de résultats.
Mais alors, pourquoi ne pas utiliser un tableau de résultats directement ? On stock quelque part le résultat de toutes les divisions par 3 des nombres entiers de 0 à 255, et on …
Dans le dernier article, j'avais cherché une version plus rapide pour effectuer une division par 3, toujours dans l'optique d'afficher un point à l'écran en transcrivant la routine écrite en BASIC vers de l'assembleur Z80.
Le résultat était mitigé : une routine en moyenne plus rapide et plus stable, mais sur le domaine de définition considéré (le nombre de lignes graphiques du VG5000µ), pas entièrement gagnante.
Dans cet article, je vais donc étudier une autre manière de faire, un peu différente. Alors que les deux premières implémentations permettait de diviser par n'importe quel nombre de 1 à 255, cette nouvelle version est spécialisée dans la division par 3.
Est-ce que cette spécialisation permettra de gagner en performance et/ou en taille ?
L'idée
Le Z80 n'a pas d'instruction pour diviser de manière générale, cela a déjà été mentionné dans les articles précédents. Par contre, il est tout à fait possible de …
Dans le dernier article, j'avais écrit une première manière d'effectuer une division, en spécialisant la routine pour une division par 3 puisque c'est ce qui m'intéresse pour afficher un point à l'écran du VG5000µ.
Pour référence, cette routine nécessitait 15 octets en mémoire et son exécution pouvait prendre jusqu'à 695 cycles, ce qui est plutôt grand.
Micro optimisation
La première optimisation est une micro optimisation. On appelle micro optimisation une amélioration de la routine par un détail de fonctionnement, plutôt que par une réflexion sur l'ensemble de la méthode.
Ici, l'idée est de remplacer le couple push bc / pop bc en début et fin de la routine par un couple exx / exx. L'instruction exx du Z80 effectue un renommage des registresBC, DE et HL. Ces registres (ainsi que d'autres, mais qui ne sont pas touchés par cette instruction) existent en deux exemplaires dans le Z80. Un exemplaire de chaque …
Après avoir mis en place une vérification (légère) de l'intégrité de la pile, je passe à la vérification de la validité de l'appel d'une fonction.
Le fonctionnement du test est assez simple : je prends une suite de nombres, j'appelle une fonction avec en paramètre chacun de ces nombres, je vérifie que le résultat est conforme à ce que j'attendais.
Par exemple, si je veux tester une fonction diviser par 2 (division entière), je peux utiliser la suite de nombre 0, 10, 32, 255 et comparer les résultats respectifs avec 0, 5, 16, 127 (255 étant impair, le résultat de la division entière est 127, avec un reste égal à 1).
Encore plus simple qu'une division par 2, il y a la fonction identité : celle qui renvoie le paramètre sans le toucher. Tester cette fonction permet de se concentrer sur le développement du test.
Il y a maintenant pas mal de temps, j'avais implémenté, en BASIC, une routine pour afficher un point à l'écran. Puis de là, une routine pour tracer une ligne, puis un cercle. Le constat était que c'était très lent. Le BASIC interprété est déjà plutôt lent de manière générale, et celui du VG5000µ n'est pas particulièrement rapide.
Il y a plusieurs raisons à cela, et ce sera peut-être le contenu d'articles futurs.
Mais en attendant, et après tous les efforts pour se confectionner un environnement de travail pour développer en assembleur, je repars sur l'implémentation du tracé d'un point à l'écran, et cette fois-ci, en assembleur.
L'avantage d'un programme écrit dans un langage de « haut niveau », comme le BASIC, est de simplifier bien des choses. Faire une division d'une variable A par 3 par exemple, peut s'écrire B = A/3. C'est simple, concis, lisible.
Après la description de l'utilisation de l'affichage haute-définition du VG5000µ, voici le fichier au format K7 et format WAV qui vous permettra de lancer le programme sur votre propre VG5000µ ou un émulateur.
Au passage, le programme contient la version avec la maison sans l'inversion vidéo qui avait lieu dans l'article précédent.
Avec ce mode d'affichage, on obtient une résolution de 80 pixels horizontalement par 75 pixels verticalement. Ce qui donne un total de 6000 pixels. Cependant, le manuel d'utilisation de la machine indique une définition d'image de 80 000 points. Plus de 13 fois plus. Existe-t-il une façon d'afficher des pixels plus petits et d'atteindre une haute (toute proportion gardée) définition ?
Petit rappel : je ne m'occupe pour le moment que des capacités du VG5000µ offertes par le BASIC, et se mettant à la place d'une utilisation à l'époque, avec juste le manuel de base.
Plus fin
Pour atteindre une définition plus fine depuis le BASIC, il faut …
Maintenant que nous avons un algorithme pour tracer un cercle ainsi que le moyen d'afficher un gros pixel à l'écran, nous voilà prêts pour traduire tout cela en BASIC, comme cela a été fait auparavant avec le segment de droite.
Pour rappel, voici l'implémentation en BASIC d'affichage d'un point à l'écran.
100REM AFFICHE UN POINT DANS L'ESPACE SEMI-GRAPHIQUE110REM X CONTIENT L'ABSCISSE ENTRE 0 et 79120REM Y CONTIENT L'ABSCISSE ENTRE 0 et 74130ZX=INT(X/2):ZY=INT(Y/3)140RX=X-ZX*2:RY=Y-ZY*3150CH=2^(RY*2+RX)160DI=&"4000"+ZY*80+ZX*2170AT=PEEK(DI+1)200OL=64:IF(ATAND128)=128THENOL=PEEK(DI)220IF(OLAND128)=128THENOL=64230POKEDI,OLORCH240POKEDI+1,224250RETURN …
Avec de passer à l'implémentation en BASIC du cercle décrit dans un article précédent, passons un peu par une phase de simplification. Cet article va contenir quelques lignes de mathématiques.
L'outil mathématique le plus complexe utilisé est celui des factorisations et développements de carrés. Les identités remarquables seront d'un grand secours. Niveau de fin de collège je crois.
Pour rappel, voici l'algorithme de tracé de cercle de Bresenham :
initialiser cx et cy avec les coordonnées du centre du cercle, r avec son rayon
initialiser (x, y) à (0, r), c'est à dire le point au sommet du cercle.
tant que x ≤ y
tracer le pixel(x + cx, y + cy) et ses sept symétries.
calculer $m = (x+1)^2 + (y-0.5)^2 - r^2$
si m ≥ 0 alors $x \leftarrow x + 1$ et $y \leftarrow y - 1$
sinon $x \leftarrow x + 1$
fin
On pourrait l'implémenter tel quel. Mais je veux …
Si vous avez fait un peu de trigonométrie à l'école, vous devez savoir que, pour un angle α allant de 0 à 2π, tracer des points aux coordonnées (cos(α), sin(α)). Ces coordonnées sont multipliées par le rayon et déplacées au centre du cercle. Et c'est comme cela qu'il peut sembler de prime abord intéressant de tracer un cercle.
Cela ressemble à quelque chose comme ça.
initialiser cx et cy avec les coordonnées du centre du cercle, r avec son rayon
initialiser a à 0
tant que $a < 2\pi$
$x = cx + r.cos(a)$
$y = cy + r.sin(a)$
tracer un point en (x, y)
augmenter a
fin
Super simple.
Mais trop simple.
Dans l'algorithme ci-dessus, la ligne qui indique augmenter a n'indique pas de combien il faudrait augmenter a.
Après avoir décrit un algorithme de tracé de segment de droite de manière générique, voyons un peu comment traduire ça en BASIC sur le VG5000µ. Pour ce premier article, il s'agira d'une implémentation simpliste, qui servira de base.
Pour rappel, voici l'algorithme générique :
En entrée, on a deux points de coordonnées (x, y) et (x', y')
Si x' est plus petit que x, échanger les valeurs de x et x' ainsi que de y et y'
Choix de l'octant en fonction de |y' - y| et de |x' - x|
Si on fait un balayage des x, alors
Calculer la pente $a = \frac{(y' - y)}{(x' - x)}$
Calculer $b = \frac{x'y - xy'}{x'-x}$
Pour tous les x'' de x à x', calculer $y'' = ax'' + b$.
Tracer un pixel en (x'', y'').
Si on fait un balayage des y, alors
Si y' est plus petit que y, échanger les valeurs de x …
Après avoir vu le point, si nous passions à la ligne ? Ou plus exactement, au segment de droite.
Sur une feuille de papier, tracer un segment de droite entre deux points est une chose
simple : un crayon, un règle, on positionne la règle sur les deux points et l'on trace un
trait en tenant fermement cette dernière.
Le trait a alors une allure continue ; du moment que l'on n'utilise pas un microscope pour
en détailler la composition. Et c'est une représentation suffisante,
dans la plupart des cas, de l'objet mathématique sous-jacent.
Sur un écran d'ordinateur, c'est un tout autre problème. En effet, un écran traditionnel
est constitué d'une matrice de petits carreaux, les pixels. Les pixels des écrans récents
sont très petits et malgré cela, tracer un beau segment de droite n'est pas si simple.
Alors imaginez avec les gros carreaux formant les affichages d'anciens ordinateurs ?
Le BASIC est un langage, dans les versions de l'époque de cette machine, assez limité. Il n'y a entre autre pas de notion de portée lexicale des variables. La portée lexicale d'une variable, c'est l'ensemble des parties d'un code source depuis lesquelles une variable, ou plus généralement un symbole, est accessible. En BASIC sur VG5000µ, comme sur les BASIC d'autres machines de cette période, c'est simple, les variables simples sont accessibles de partout à partir du moment où elles ont été définies.
À cela s'ajoute le fait que seuls les deux premiers caractères d'une variable sont significatifs. ABC et ABD …
Dans l'épisode précédent, j'avais décrit l'arrangement en mémoire vidéo des caractères semi-graphiques et un moyen d'accéder directement en mémoire à celui qui nous intéresse.
Le but est toujours de pouvoir allumer un élément constitutif d'un caractère semi-graphique, que je nomme « gros pixel ». Et l'article précédent s'arrêtait au moment où je pouvais récupérer, via une paire d'appels à commande PEEK, les deux valeurs décrivant le caractère affiché à l'écran.
Premier test, après avoir effacé l'écran avec INIT, j'affiche les deux valeurs correspondantes à la colonne 1, ligne 0.
Les deux valeurs obtenues et visibles sur la capture d'écran sont 79 et 0. Pour comprendre ce qu'ils signifient, je reprends ici un morceau de l'article sur l'arrangement de la mémoire vidéo qui décrit la structure de ces deux valeurs.
On y lit que la première valeur a cette structure :
Après avoir fait un mini tour des commandes graphiques, puis étudié la structure des caractères semi-graphiques du VG5000µ, il est temps d'implémenter la possibilité d'allumer un point particulier de l'écran.
Comme je vais utiliser les caractères semi-graphiques, ce « point » sera sur la grille de résolution de 80 par 75. En effet, il y a 40 caractères par ligne qui ont chacun une largeur de deux éléments, et 25 caractères par colonne qui ont chacun trois éléments en hauteur.
L'idée pour allumer ou éteindre un point est donc d'abord de trouver quelle position de caractère semi-graphique est influencée, puis de modifier le caractère à cette position. Pour modifier le caractère, il faudra lire celui déjà présent, calculer le nouveau, puis écrire le nouveau.
Transformation de coordonnées
Pour visualiser la transformation de coordonnées, voici un tableau.
Cet article est la version française de cet autre que j'ai écrit suite à une demande d'aide dans le forum System.cfg forum. Je me suis dit que c'était le moment de mettre à plat mes notes, même si du coup cela cassait un peu la progression des articles en français sur l'affichage.
Cela donne un article un peu plus austère que d'habitude, et un peu plus dense.
Pour commencer, le processeur vidéo du VG5000µ est un EF9345. On peut y accéder de deux façons, soit en discutant directement, soit à travers la RAM lorsqu'on utilise le BASIC embarqué dans la machine. La manière directe est plus puissante, la seconde est plus simple.
Le signal de début d'affichage (Blank Start) du processeur vidéo est connecté à la broche d'interruption du Z80. Cela provoque une interruption IRQ qui, dans le mode dans lequel le BASIC initialise le Z80, fait un appel …
La dernière fois, j'avais présenté le début d'une idée pour accéder à des pixels « basse définition » sur le VG5000µ en se servant de caractères semi-graphiques.
Avant de continuer sur l'idée, je me demandais ce que donnerais, sans trop de traitement, une image de synthèse en niveau de gris avec une telle technique.
Afin de transformer cette image en niveaux de gris vers du noir et blanc, je fais appel à une technique appelée « Dithering » ou « tramage » en français. Il s'agit de transformer le niveau de lumière en série de points plus ou moins dense.
Plus la résolution est dense, plus le résultat est bon. Forcément, en basse résolution semi-graphique, il ne faut pas s'attendre à des merveilles.
Voici donc deux couples d'images. En premier le rendu en niveau de gris d'une image de synthèse assez simple. Puis un rendu avec du tramage. Il existe de nombreuses techniques de tramages, et …
Lorsque l'on regarde de près la structure des caractères semi-graphiques du VG5000µ, on voit qu'elle a été réfléchie pour être facile à manipuler. Voici quelques observations :
les caractères sont divisés en deux plages, l'une numérotée de 0 à 63, l'autre de 64 à 127.
si on prend un caractère de la première plage, contenant les caractères « quadrillés » et que l'on ajoute 64 à son numéro, on obtient le même caractère en format « plein »
de manière similaire, si on soustrait 64 au numéro d'un caractère plein, on obtient sa forme quadrillée.
Le caractère 127, par exemple, est le caractère complètement rempli. Le caractère 127 - 64, c'est-à-dire 63, est le caractère rempli, quadrillé.
Une observation supplémentaire est plus visible si l'on réarrange les blocs de chaque caractère semi-graphique sur une seule ligne. Pour cela, je prends les deux blocs du haut, puis j'y ajoute les deux blocs du milieu, et enfin les …
Une fois le VG5000µ démarré, on pourrait imaginer afficher des formes à l'écran en allumant des pixels avec des couleurs prises dans une palette donnée. Au même moment, c'est ce que font d'autres ordinateurs sur le marché. Avec de grandes limitations, certes, mais des commandes en BASIC sont fournies à l'utilisateur pour afficher des points, voires même tracer des lignes.
Il n'en est rien.
Les commandes en BASIC méritent d'être étudiées avant de se lancer. La manuel d'utilisation consacre quatre pages d'explications à l'affichage graphique et auront pu, je pense, décourager tous ceux qui ne cherchaient pas un minimum à conduire quelques expériences. Par chance, avoir un ordinateur à cette époque, c'est avoir un peu l'esprit curieux.
Deux commandes, CURSORX et CURSORY, suivies d'une nombre, permettent de placer la position courante d'affichage sur l'espace à l'écran, divisé en 25 lignes de 40 colonnes. Les caractères affichés avec PRINT qui suivent …
