Triceraprog
La programmation depuis le Crétacé

Articles de la catégorie Machines.

  • VG5000µ, simplification du tracé du cercle ()

    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 d'abord attirer votre attention sur un détail assez simple. Dans les deux cas de la condition, que m soit ou non supérieur à zéro, x est augmenté de 1. En effet, si vous vous souvenez, quoi qu'il arrive, on trace les pixels en prenant toujours le suivant sur la colonne à sa droite.

    On pourrait donc réécrire :

    • 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 \(y \leftarrow y - 1\)
      • \(x \leftarrow x + 1\)
    • fin


    Cela aura le même résultat, et un peu moins d'instructions.

    Une petite pause ici : avec des langages compilés et des outils de compilation récents, il est très probable que ce genre de simplification soit fait automatiquement par le compilateur. Ce qui n'empêche pas d'écrire un code plus simple, mais sans aller jusqu'à simplifier au point que le lecteur humain ne comprenne plus rien. Ici, dans le monde BASIC interprété des années 1980, c'est une simplification intéressante que l'on doit faire à la main.

    Cette simplification fait partie des optimisations. Avec moins d'instructions, le programme ira probablement plus vite. Dans notre cas ici, le routine d'affichage de pixel est tellement lente que l'effet est négligeable. Mais tout de même.


    Simplifions encore

    Un autre type d'optimisation peut venir d'une simplification des calculs à effectuer. Le BASIC du VG5000µ n'est pas très rapide en calculs et on demande ici dans la boucle de tracé sept opérations dont trois multiplications. Et les multiplications générique, c'est lent.

    Plutôt que de calculer m complètement à chaque fois, il est possible d'en calculer la valeur à partir de la valeur précédente. Attention, un peu de mathématiques.

    Disons que \(m_i\) est la valeur de m à l'itération i. Et \(m_{i+1}\) la valeur à l'itération suivante. Avec la même notation pour x et y à chaque itération (le rayon r ne bouge pas), on peut poser : \(m_i = (x_i+1)^2 + (y_i-0.5)^2 - r^2\).

    Et pour le calcul de m à l'itération suivante : \(m_{i+1} = (x_{i+1}+1)^2 + (y_{i+1}-0.5)^2 - r^2\)

    Il y a deux cas dans l'algorithme, d'abord celui où l'on sélectionne le pixel de droite. Dans ce cas là, x est augmenté de 1, et y ne change pas. Cela donne ces deux égalités : \(x_{i+1} = x_i + 1\) et \(y_{i+1} = y_i\).

    Avec l'objectif de calculer \(m_{i+1}\) à partir de \(m_i\), remplaçons dans l'équation :

    • \(m_{i+1} = (x_{i+1}+1)^2 + (y_{i+1}-0.5)^2 - r^2\)
    • \(m_{i+1} = (x_{i+1}+1+1)^2 + (y_{i}-0.5)^2 - r^2\), (par substitution des termes à l'itération précédente)
    • \(m_{i+1} = (x_i^2 + 4x_i + 4) + (y_{i}-0.5)^2 - r^2\), (par développement du premier carré)
    • \(m_{i+1} = ((x_i^2 + 2x_i + 1) + (y_{i}-0.5)^2 - r^2) + 2x_i + 3\), (par commutativité et associativité)
    • \(m_{i+1} = ((x_i + 1)^2 + (y_{i}-0.5)^2 - r^2) + 2x_i + 3\), (par factorisation)
    • \(m_{i+1} = m_i + 2x_i + 3\), (par substitution du premier groupe qui est la définition de \(m_i\))


    Ou bien, si l'on préfère calculer \(m_{i+1}\) par rapport aux coordonnées à la même itération :

    • \(m_{i+1} = m_i + 2(x_{i+1} - 1) + 3\), (par substitution)
    • \(m_{i+1} = m_i + 2x_{i+1} - 2 + 3\), (par développement)
    • \(m_{i+1} = m_i + 2x_{i+1} + 1\), (par simplification)


    Dans le deuxième cas où l'on prend le pixel en diagonal, on a x toujours augmenté de 1, mais aussi y qui est réduit de 1. Cela donne ces deux égalités : \(x_{i+1} = x_i + 1\) \(y_{i+1} = y_i - 1\).

    Remplaçons dans l'équation suivant le même principe :

    • \(m_{i+1} = (x_{i+1}+1)^2 + (y_{i+1}-0.5)^2 - r^2\)
    • \(m_{i+1} = (x_{i}+1+1)^2 + (y_{i}-1-0.5)^2 - r^2\), (par substitution des termes à l'itération précédente)
    • \(m_{i+1} = (x_{i}+2)^2 + (y_{i}-\frac{3}{2})^2 - r^2\), (par simplification)
    • \(m_{i+1} = (x_{i}^2+4x_{i}+4) + (y_{i}^2-3y_{i}+(\frac{3}{2})^2) - r^2\), (par développement des deux carrés)
    • \(m_{i+1} = ((x_{i}^2+2x_{i}+1) + (y_{i}^2-y_{i}+(\frac{1}{2})^2) - r^2) + 2x_{i} + 3 - 2y_{i} + \frac{8}{4}\), (par commutativité et associativité)
    • \(m_{i+1} = m_i + 2x_{i} + 3 - 2y_{i} + \frac{8}{4}\), (par substitution du premier groupe qui est la définition de \(m_i\))
    • \(m_{i+1} = m_i + 2x_{i} + 3 - 2y_{i} + 2\), (par simplification, mais pas trop, pour garder la forme du premier cas visible dans l'équation)


    Ou bien, si l'on préfère calculer \(m_{i+1}\) par rapport aux coordonnées à la même itération :

    • \(m_{i+1} = m_i + 2(x_{i+1}-1) + 3 - 2(y_{i+1}+1) + 2\), (par substitution)
    • \(m_{i+1} = m_i + 2x_{i+1} - 2 + 3 - 2y_{i+1} - 2 + 2\), (par développement)
    • \(m_{i+1} = m_i + 2x_{i+1} + 1 - 2y_{i+1}\), (par simplification, mais pas trop, pour garder la forme du premier cas visible dans l'équation)


    Dans les deux cas, il s'agit donc d'ajouter à l'ancienne valeur de m un calcul qui dépend des nouvelles coordonnées. La multiplication est une multiplication par 2, ce qui est beaucoup plus rapide pour un ordinateur qu'une multiplication générale. Bon, pas en BASIC VG5000µ, mais je vous assure que dans le future, nous serons heureux d'avoir cette simplification.

    Une autre étape intéressante peut-être de relier les deux équations, en cherchant à exprimer le résultat du choix du pixel en diagonal par le résultat lorsque le choix est celui du pixel à droite.

    Voilà la raison de ne pas trop simplifier les équations à la fin des calculs. Le calcul final est :

    • \(m_{i+1} = m_i + 2x_{i+1} + 1 - D\), (D pour diagonale)
    • \(D = 0\) si l'on choisi le point de droite,
    • \(D = 2y_{i_+1}\) si l'on choisi le point en diagonale.


    Point de départ

    Maintenant que l'on sait compter la valeur de m à une itération donnée par rapport à sa valeur précédente, il nous faut bien un point de départ. Le tout premier m, que l'on note \(m_0\) est la valeur pour le premier pixel tracé. Pour rappel, dans l'algorithme, le premier pixel est celui en haut du cercle, c'est-à-dire aux coordonnées x = 0 et y = r.

    Il suffit de remplacer ces valeurs dans l'équation qui nous donne la valeur de m :

    • \(m = (x+1)^2 + (y-0.5)^2 - r^2\)
    • \(m = (0+1)^2 + (r-0.5)^2 - r^2\), (par substitution)
    • \(m = 1^2 + r^2-r+(\frac{1}{4})^2 - r^2\), (par développement)
    • \(m = \frac{5}{4} - r\), (par simplification)


    Aïe, une fraction. Une fraction, c'est très bien tant qu'on est dans le calcul. Par contre, une fois que l'on doit passer à l'implémentation, cela se corse. Mieux vaut garder des calculs sur des entiers, surtout sur des machines de cette époque.

    Heureusement, tout ce qui nous intéresse dans m pour choisir le pixel suivant est son signe. Est-ce un nombre positif ou négatif ? Cette information restera valide même si la valeur de m est multipliée par un nombre positif.

    L'astuce ici sera donc, à l'implémentation, de ne pas calculer m, mais 4m, c'est-à-dire quatre fois la valeur de m. L'algorithme reste valide, et l'on se débarrasse de la fraction. En gardant des multiplications par multiples de 2, on garde la facilité à multiplier des entiers rapidement.

    • \(4m_0 = 5 - r\)


    Conclusion

    Cet article est un passage presque entièrement dédié à des mathématiques. Celles-ci nous ont aidé à réduire les calculs nécessaires à la résolution d'un algorithme.

    Transformer un problème en un équivalent plus simple est une des bases de l'optimisation. Cela fait parfois appel aux mathématiques, parfois à la connaissance de la machine utilisée, parfois au langage de programmation en lui-même.

    Au final, voici le nouvel algorithme, qui sera transformé en BASIC dans l'article suivant.

    • 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.
    • initialiser M à \(5 - r\)
    • 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 \(y \leftarrow y - 1\), \(M \leftarrow M - 8y_{i+1}\)
      • \(x \leftarrow x + 1\), \(M \leftarrow M + 8x_{i+1} + 4\)
    • fin

  • VG5000µ, tracer une ligne en BASIC ()

    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 et x' ainsi que de y et y'
      • Calculer la pente \(a = \frac{(x' - x)}{(y' - y)}\)
      • Calculer \(b = \frac{y'x - yx'}{y'-y}\)
      • Pour tous les y'' de y à y', calculer \(x'' = ay'' + b\)
      • Tracer un pixel en (x'', y'')

    Il s'agit à présent de transformer ces instructions en instructions BASIC. Je me base sur l'implémentation de tracé de point publié précédemment, implémenté entre les lignes 100 à 250.

    C'est quelque chose de classique en BASIC de l'époque, les routines, c'est-à-dire des sous-programmes dédiés à une tâche, sont implémentées à des lignes précises. Dans le cas de mon tracé de point, la routine est re-logeable, il est possible de changer les numéros de ligne sans problème.

    Cette routine utilise les variables X et Y en entrée. Elle utilise aussi en interne les variables ZX, ZY, RX, RY, CH, DI, AT et OL. Cela signifie que ces variables, si elles sont utilisées ailleurs dans le programme, verront leur contenu changer à l'appel de la routine.

    C'est, j'en ai déjà parlé, une limitation gigantesque des BASIC de cet époque. Même si, ALGOL, un langage antérieur, avait introduit la portée lexicale des variables, la compartimentation des différentes parties d'un programme n'est pas un acquis lors de la création du BASIC et les versions disponibles sur les ordinateurs familiaux, par soucis d'accessibilité très certainement, ont gardé cette limitation.

    Veillons donc juste à être prudent avec le nom des variables utilisées.


    Préambule

    Je vais implémenter la routine de segment de droite à partir de la ligne 300, soit après l'implémentation du point. Il y a une raison pour cela que j'expliquerai sûrement plus tard.

    La routine commence par une petite documentation du fonctionnement. Ces commentaires sont complètement optionnels mais bien utiles pour les utilisateurs futurs. Voire pour moi, me rappeler plus tard ce que j'avais décidé.

    300 REM AFFICHE UN SEGMENT DE DROITE DANS L'ESPACE SEMI-GRAPHIQUE
    310 REM X1 ET Y1 CONTIENNENT LES COORDONNEES DE DEPART
    320 REM X2 ET Y2 CONTIENNENT LES COORDONNEES D'ARRIVEE
    

    Puis vient l'échange des coordonnées. Comme le BASIC du VG5000µ n'a pas de commande pour inverser le contenu de deux variables (c'est une instruction plutôt rare), il me faut passer par une variable intermédiaire que je nomme TT. On reconnaîtra bien là les pâtés caractéristique des programmes BASIC de l'époque. Plein de lettres et de signes collés.

    330 IF X2<X1 THEN TT=X1:X1=X2:X2=TT:TT=Y1:Y1=Y2:Y2=TT
    

    Il faut ensuite, pour décider de l'octant et donc du balayage, savoir si on est plus de la verticale que de l'horizontale. Pour cela, on peut calculer la valeur absolue de la différence des X (abscisses) et des Y (ordonnées).

    340 AX=ABS(X2-X1):AY=ABS(Y2-Y1)
    

    Vient ensuite la sélection de la sous-routine à utiliser, en fonction de balayage utilisé. L'instruction conditionnelle IF du BASIC du VG5000µ n'a pas de clause ELSE comme sur beaucoup d'autres BASIC. Une solution (il y en a d'autres) est d'écrire les deux choix explicitement.

    Si la condition indiquée après le IF est vérifiée, alors le programme continuera à la ligne indiquée après l'instruction GOSUB. Lorsque l'interpréteur BASIC rencontrera l'instruction RETURN, le déroulement reprendra après le GOSUB.

    350 IF AX >= AY THEN GOSUB 400
    360 IF AX < AY THEN GOSUB 500
    370 RETURN
    


    Balayages

    Reste à écrire les deux balayages différents. Commençons par les X.

    400 A=(Y2-Y1)/(X2-X1)
    410 FOR X=X1 TO X2
    420 Y=INT(0.5+Y1+A*(X-X1))
    430 GOSUB 100
    440 NEXT X
    450 RETURN
    

    Il n'y a pas de fonction d'arrondi disponible. La fonction est émulée en prenant la partie entière, c'est-à-dire sans les chiffres après la virgule, du nombre augmenté de 0.5. La fonction pour obtenir la partie entière est INT.

    La ligne 420 est une simplification du calcul de b dans l'équation de la droite, valide pour les valeurs de x du segment de droite. Je vous laisse faire le calcul.

    Pour le balayage des Y, il faut commencer par échanger les coordonnées si nécessaire.

    500 IF Y2<Y1 THEN TT=X1:X1=X2:X2=TT:TT=Y1:Y1=Y2:Y2=TT
    

    Puis le balayage en lui-même est effectué.

    510 A=(X2-X1)/(Y2-Y1)
    520 FOR Y=Y1 TO Y2
    530 X=INT(0.5+X1+A*(Y-Y1))
    540 GOSUB 100
    550 NEXT Y
    560 RETURN
    

    La ligne 530 comme la 420 est une simplification des calculs.

    Et voilà. Une routine de tracé de segment de droite avec les moyens du bord, en BASIC VG5000µ.

    Petite modification avant le récapitulatif, les lignes 500 et 330 font toutes les deux l'échange des coordonnées. Se répéter en programmation est mauvais signe dans une grande partie des cas. Déplaçons cette partie dans une sous-routine.

    330 IF X2<X1 THEN GOSUB 270
    
    500 IF Y2<Y1 THEN GOSUB 270
    
    270 TT=X1:X1=X2:X2=TT:TT=Y1:Y1=Y2:Y2=TT
    280 RETURN
    


    Récapitulatif

    300 REM AFFICHE UN SEGMENT DE DROITE DANS L'ESPACE SEMI-GRAPHIQUE
    310 REM X1 ET Y1 CONTIENNENT LES COORDONNEES DE DEPART
    320 REM X2 ET Y2 CONTIENNENT LES COORDONNEES D'ARRIVEE
    
    330 IF X2<X1 THEN GOSUB 380
    
    340 AX=ABS(X2-X1):AY=ABS(Y2-Y1)
    350 IF AX >= AY THEN GOSUB 400
    360 IF AX < AY THEN GOSUB 500
    370 RETURN
    
    380 TT=X1:X1=X2:X2=TT:TT=Y1:Y1=Y2:Y2=TT
    390 RETURN
    
    400 A=(Y2-Y1)/(X2-X1)
    410 FOR X=X1 TO X2
    420 Y=INT(0.5+Y1+A*(X-X1))
    430 GOSUB 100
    440 NEXT X
    450 RETURN
    
    500 IF Y2<Y1 THEN GOSUB 380
    510 A=(X2-X1)/(Y2-Y1)
    520 FOR Y=Y1 TO Y2
    530 X=INT(0.5+X1+A*(Y-Y1))
    540 GOSUB 100
    550 NEXT Y
    560 RETURN
    


    Utilisation

    Voici par exemple une utilisation du programme pour tracé un dessin. Sur chacune des lignes, les coordonnées des lignes sont mentionnées puis la sous-routine est appelée. La commande DISPLAY exécutée ensuite sert à forcer le rafraîchissement de l'écran après chaque ligne.

    Comme indiqué précédemment, c'est long, très long. Il faut environ 17 secondes sur la machine pour contempler le résultat. Le VG5000µ nous laisse peu d'options en restant dans le BASIC pour améliorer cela. Nous essaierons cependant une prochaine fois.

    10 GOTO 1000
    
    1000 INIT
    1010 X1=10:Y1=15:X2=35:Y2=5:GOSUB 300:DISPLAY
    1020 X1=60:Y1=15:X2=35:Y2=5:GOSUB 300:DISPLAY
    1030 X1=10:Y1=15:X2=35:Y2=60:GOSUB 300:DISPLAY
    1040 X1=60:Y1=15:X2=35:Y2=60:GOSUB 300:DISPLAY
    1050 X1=60:Y1=15:X2=10:Y2=15:GOSUB 300:DISPLAY
    1060 END
    

    Résultat de tracé de segments


  • VG5000µ, SetPoint en BASIC, l'implémentation ()

    Ça y est, après avoir vu la structure des caractères semi-graphiques, l'arrangement en mémoire des valeurs d'affichage et fait un essai de manipulation de ces valeurs, nous voici prêts pour écrire un morceau de programme qui peut prendre en entrée des coordonnées et allumer ou éteindre un point à l'écran.

    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 désignent les mêmes variables. Cela limite fortement la possibilité d'utiliser des noms de variables intéressants.

    Deux caractères significatifs pour les variables

    Cette aparté terminée, revenons à la définition du problème.


    Modélisation du problème

    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.

    Dans un premier temps, 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
    • Récupérer les valeurs pour la paire d'adresse mémoire
    • Si le caractère présent n'était pas un caractère semi-graphique standard, considérer qu'il était complètement éteint (valeur 0 pour le caractère)
    • Modifier la valeur du caractère récupéré en fonction des coordonnées à l'intérieur du caractère semi-graphique
    • Modifier la mémoire écran avec les nouvelles valeurs


    Prenons un exemple avec les coordonnées (2, 7) que j'avais déjà utilisées dans l'article sur les changements de repère. Les coordonnées du caractères sont (0, 2) et les coordonnées dans le caractères sont (0, 1).

    À partir des coordonnées (0, 2), je trouve que l'adresse mémoire est &"4000"+160. Une paire de PEEK me donne les valeurs déjà présentes 128 et 230. Cela signifie qu'il y a un caractère graphique étendu à cet endroit. Je le considère donc comme un caractère éteint, de valeur 0.

    À partir des coordonnées (0, 1), j'obtiens pour valeur de caractère 64+4 = 68, qui sera donc la première valeur.

    La seconde valeur, en fonction des couleurs sera 224. Une paire de POKE avec ces valeurs allumera le bon point.

    Des peeks

    Maintenant, que se passe-t-il si un caractère graphique est déjà présent ? Pour vérifier cela, je vais allumer le point aux coordonnées (3, 7). Cela donne la paire de coordonnées (0, 2) et (1, 1). C'est-à-dire les mêmes emplacements mémoires mais avec un point différent dans le caractère semi-graphique.

    Les valeurs récupérées sont donc 68 et 224, celles que je viens de calculer et mettre en mémoire avec POKE. 224 reste identique, puisque les couleurs sont fixes. Le numéro de caractère, lui, doit être changé. Le nouveau gros pixel à allumer est celui de valeur 8. Je peux donc ajouter 8 à 68 pour donner 76. Et cela marcherait.

    Mais c'est faux dans le cas général.

    L'addition ne fonctionne pas. Si j'allume deux fois le même gros pixel, il ne faut pas ajouter le numéro de ce pixel, puisqu'il est déjà pris en compte.

    L'opération qu'il faut utiliser ici est une opération OU. Je ne m'étendrai pas dessus ici. Retenez juste que faire un OU entre le numéro du caractère actuel et le numéro associé au pixel revient à ajouter ce numéro associé uniquement s'il n'est déjà pas pris en compte par le caractère.

    En BASIC, le OU est écrit OR. 68 OR 8 donne 76. Parfait.

    Des pokes

    Voici le programme en BASIC, commenté, qui reprend ces opérations.

    100 REM AFFICHE UN POINT DANS L'ESPACE SEMI-GRAPHIQUE
    110 REM X CONTIENT L'ABSCISSE ENTRE 0 et 79
    120 REM Y CONTIENT L'ABSCISSE ENTRE 0 et 74
    130 ZX=INT(X/2):ZY=INT(Y/3)         : REM Calcul des coordonnées écran (ZX, ZY)
    140 RX=X-ZX*2:RY=Y-ZY*3             : REM Calcul des coordonnées dans le caractère (RX, RY)
    150 CH=2^(RY*2+RX)                  : REM Calcul du numéro de pixel associé
    160 DI=&"4000"+ZY*80+ZX*2           : REM Calcul de l'emplacement mémoire écran
    170 AT=PEEK(DI+1)                   : REM Récupération de la valeur d'attribut
    180 REM Si c'est un caractère graphique, la valeur du caractère est récupérée dans OL
    190 REM Sinon, OL reste à 64
    200 OL=64:IF (AT AND 128) = 128 THEN OL=PEEK(DI)
    210 REM Si le caractère était étendu, OL est remis à 64
    220 IF (OL AND 128) = 128 THEN OL=64
    230 POKE DI,OL OR CH                : REM Le caractère est augmenté de la nouvelle valeur
    240 POKE DI+1,224                   : REM Les couleurs sont fixes
    250 RETURN                          : REM Fin de la routine, retour à l'appelant
    

    Je ne m'étendrai pas non plus ici sur le AND en ligne 200. Retenez que cette opération vérifie si le bit de rang 7, qui décrit si le caractère est semi-graphique, est à 1. De même sur la ligne 200, où je vérifie si le bit de rang 7, qui décrit si le caractère est étendu, est à 1.

    Et voici comment peut-être utilisé ce programme. X et Y sont initialisés avec les coordonnées, puis la routine en ligne 100 est appelée avec GOSUB.

    10 INIT
    20 X=20:Y=10:GOSUB 100
    21 X=21:Y=10:GOSUB 100
    22 X=19:Y=11:GOSUB 100
    23 X=19:Y=12:GOSUB 100
    24 X=22:Y=11:GOSUB 100
    25 X=22:Y=12:GOSUB 100
    26 X=20:Y=13:GOSUB 100
    27 X=21:Y=13:GOSUB 100
    30 END
    

    Tracer des images, ou tout simplement des objets géométriques de cette façon serait très fastidieux. On pourra améliorer ça dans un futur article.

    Le résultat

    Le listing


  • VG5000µ, SetPoint en BASIC, manipulation de gros pixels ()

    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.

    Peek écran

    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 :

    Bit76543210
    ContenuN (0)/E (1)numéro du caractère

    Et que la seconde a celle-ci :

    Bit76543210
    ContenuTX (0)Inverse vidéoLargeur x2Hauteur x2ClignotementCouleur
    ContenuGR (1)Couleur de fondClignotementCouleur du caractère

    Compter jusqu'à deux

    Pour comprendre ce que ces tableaux signifient, il faut savoir et comprendre que les valeurs que j'ai obtenues et affichées le sont en base 10, c'est-à-dire sous la forme sous laquelle nous comptons usuellement dans la vie de tous les jours. En base 10, il y a 10 chiffres, et 0 à 9, et les nombres sont composés de ces chiffres. 79 est composé du chiffre 1 en position des dizaines et 6 en position des unités.

    C'est d'ailleurs au programme du primaire à l'école, où l'on apprends que 79, c'est 1 dizaine et 6 unités. Autrement dit, 1 × 10 + 6. De même, 0 est composé de 2 centaines, de 0 dizaines et de 5 unités, autrement dit 2 * 100 + 0 * 10 + 5.

    Ces 10 chiffres sont arbitraires. On aurait pu, et d'autres civilisations l'ont fait, avoir un système de comptage avec 20 chiffres. Pourquoi pas. En programmation, il est usuel de compter en base 10, bien entendu, mais aussi en base 8, donc en ne prenant que les chiffres de 0 à 7, en base 16, où nous avons besoins de chiffres supplémentaires au-delà du 9 (qui sont notés A, B, C, D, E et F) et... en base 2, où seuls les chiffres 0 et 1 sont utilisés.

    Le pourquoi de ces bases sort du cadre de cet article. J'y reviendrai probablement une autre fois. Je ne vais pas non plus expliquer ici les conversions d'écritures entre ces bases.

    Ces chiffres, 0 et 1 dont on va se servir se nomment chiffres binaires, en anglais Binary Digits, raccourcis en bit. C'est ce bit qui est mentionné dans les tableaux ci-dessus.

    Les valeurs que nous avons obtenues sont, de part l'organisation de l'ordinateur, des valeurs entre 0 et 255, et il se trouve que ces valeurs peuvent toutes s'écrire avec 8 chiffres binaires. Cette organisation en groupe de 8 bits s'appelle en octet.


    On reprend son souffle

    Cela fait beaucoup de vocabulaire d'un coup. Alors reprenons. Les valeurs que nous avons obtenues avec PEEK :

    • Sont toujours comprises entre 0 et 255,
    • Peuvent s'écrire en base 2 avec 8 bits (chiffres binaires) maximum,
    • Ces groupements de 8 bits, s'appellent des octets.

    À quoi ressemblent ces deux valeurs écrites en base 2 ? Les voici :

    • 79 (en base 10), s'écrit 01001111 (en base 2)
    • 0 (en base 10), s'écrit 00000000 (en base 2)


    Tout comme en base 10, le 0 en tête du 01001111 est optionnel, mais je les garde ici pour bien faire la différence entre les deux notations, et pour montrer que ces deux valeurs écrites en binaires s'associent parfaitement aux cases des tableaux ci-dessus.

    Dernier petit détail, dans les tableaux, le rang du chiffre binaire commence par le rang 0, à droite, puis va jusqu`au rang 7, à gauche. Cela donne bien 8 chiffres/colonnes.


    Décodage, enfin

    On a maintenant tous les éléments pour comprendre les deux valeurs récupérées au début de cet article. Le premier octet, de valeur 79, écrit en base 2 et remis en place dans le tableau de décodage, donne ceci :

    Bit76543210
    Contenu01001111

    Le second octet, de valeur 0, mis en base 2 et placé dans le tableau de décodage donne ceci :

    Bit76543210
    Contenu00000000

    Ce qui se lit :

    • Première valeur : il s'agit d'un caractère non étendu (bit 7 vaut 0) dont le numéro est 79
    • Seconde valeur : il s'agit d'un caractère textuel, de hauteur et largeur normale, sans clignotement, et de couleur 0 (noir)

    Un rapide coup d’œil sur la table de caractère nous renseigne que le caractère normal (non étendu) de rang 79 est le caractère O. Nous avons bien lu le O de Ok! en haut de l'écran.


    Et maintenant, l'encodage

    La commande pour modifier la valeur d'un emplacement mémoire, c'est-à-dire l'inverse de PEEK, est POKE. Cette commande prend un numéro d'emplacement mémoire et une valeur pour se charger de mettre cette valeur à cet emplacement mémoire.

    Exemple rapide en faisant POKE &"4000"+2,80 pour voir que le O de Ok! se transforme en P.

    Poke écran

    Ce que je voudrais maintenant, c'est utiliser des caractères semi-graphiques pour tracer une ligne horizontale au milieu de l'écran. En reprenant la méthode décrite dans l'article sur la constitution des caractères semi-graphiques, je calcule que les deux pixels du milieu allumés donnent le caractère numéro 76, ce que je peux vérifier sur le tableau des caractères semi-graphiques.

    D'après le calcul pour trouver l'emplacement mémoire du milieu de l'écran, ligne 12, colonne 0, j'obtiens 960, que je devrai ajouter à l'adresse de début de la mémoire vidéo &"4000".

    Dans les 20 paires de valeurs à partir de cet emplacement, je dois placer le caractère semi-graphique numéro 76 (1001100 en binaire sur 7 bits) non étendu, sans clignotement, avec comme couleur de fond la couleur 6 (110 en binaire sur 3 bits) et la couleur d'encre 0 (000 en binaire sur 3 bits), qui sont les couleurs par défaut à l'allumage du VG5000µ (INIT 6).

    Cela donne dans les tableaux d'encodage (qui sont toujours les mêmes) :

    Bit76543210
    Contenu01001100
    Bit76543210
    Contenu11100000

    Soit, une fois convertis en base 10, les valeurs 76 et 224.

    Et enfin, le programme

    10 INIT 6           : REM On efface l'écran
    20 P=&"4000"+960    : REM La variable P est positionnée en début de ligne 12
    30 FOR X=1 TO 40    : REM On effectue 40 fois les instructions suivantes
    40 POKE P,76        : REM La première valeur est 76
    50 POKE P+1,224     : REM La valeur suivante est 224
    60 P=P+2            : REM La variable P est avancée de 2, afin de traiter la paire suivante
    70 NEXT X           : REM Fin des instructions à répéter 40 fois
    

    Voici une belle ligne horizontale à base d'un caractère semi graphique choisi et positionné grâce à une série de calculs. Il n'y a plus long avant de pouvoir choisir directement quel point de l'écran afficher !

    Poke écran


  • VG5000µ, SetPoint en BASIC, changements de repères ()

    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.

    |-------------|-------------|-------------|-------------|-------------|
    | (0,0) (1,0) | (1,0) (2,0) | (3,0) (4,0) | (5,0) (6,0) | ......
    | (0,1) (1,1) | (1,1) (2,1) | (3,1) (4,1) | (5,1) (6,1) | ..... etc.
    | (0,2) (1,2) | (1,2) (2,2) | (3,2) (4,2) | (5,2) (6,2) | ....
    |    [0,0]    |    [1,0]    |    [2,0]    |    [3,0]    | ....
    |-------------|-------------|-------------|-------------|------
    | (0,3) (1,3) | (1,3) (2,3) | (3,3) (4,3) | (5,3) (6,3) |
    | (0,4) (1,4) | (1,4) (2,4) | (3,4) (4,4) | (5,4) (6,4) |
    | (0,5) (1,5) | (1,5) (2,5) | (3,5) (4,5) | (5,5) (6,5) |
    |    [0,1]    |    [1,1]    |    [2,1]    |    [3,1]    |
    |-------------|-------------|-------------|-------------|---
    | (0,6) (1,6) | (1,6) (2,6) | (3,6) (4,6) | (5,6) (6,6) |
    | (0,7) (1,7) | (1,7) (2,7) | (3,7) (4,7) | (5,7) (6,7) |
    | (0,8) (1,8) | (1,8) (2,8) | (3,8) (4,8) | (5,8) (6,8) |
    |    [0,2]    |    [1,2]    |    [2,2]    |    [3,2]    |
    |-------------|-------------|-------------|-------------|-
    |   .     .   |   .     .   |   .     .   |   .     .   | 
    |   .     .   |   .     .   |   .     .   |   .     
    |   .     .   |   .     .   |   .     .
    

    Entre parenthèse, j'ai placé tous les couples de coordonnées qui nous intéressent. Entre crochet, j'ai placé les coordonnées du caractère correspondant.

    Pour passer du premier système de coordonnées à l'autre, nous utilisons un outil mathématique très simple : la division. Prenez une coordonnée « gros pixel », divisez par 2 sa coordonnées X, divisez par 3 sa coordonnée Y (en arrondissant à l'entier inférieur), et vous obtenez les coordonnées du caractère semi-graphique à modifier.

    Par exemple : (2, 7) devient (2÷2, 7÷3) ce qui fait (0, 2). Sept divisé par trois de manière entière faisant 2.

    À présent que l'on sait trouver les coordonnées du caractère semi-graphique, il nous faut trouver lequel des six éléments est à modifier. Et pour cela, nous utilisons encore la division entière, mais cette fois en prenant son reste.

    En continuant sur le même exemple : (2, 7) devient (reste de 2÷2, reste de 7÷3), ce qui fait (0, 1). C'est-à-dire l'élément de la colonne de gauche (0), sur la ligne du centre (1).

    Pour transformer l’élément semi-graphique aux coordonnées (2, 7), il faudra donc allumer l'élément semi graphique de la colonne de gauche, ligne du centre, du caractère positionné aux coordonnées (0, 2).

    Ce que nous venons de faire est un changement de repère.

    Voici le même tableau avec l'élément exemple mis en évidence :

    |-------------|-------------|-------------|-------------|-------------|
    | (0,0) (1,0) | (1,0) (2,0) | (3,0) (4,0) | (5,0) (6,0) | ......
    | (0,1) (1,1) | (1,1) (2,1) | (3,1) (4,1) | (5,1) (6,1) | ..... etc.
    | (0,2) (1,2) | (1,2) (2,2) | (3,2) (4,2) | (5,2) (6,2) | ....
    |    [0,0]    |    [1,0]    |    [2,0]    |    [3,0]    | ....
    |-------------|-------------|-------------|-------------|------
    | (0,3) (1,3) | (1,3) (2,3) | (3,3) (4,3) | (5,3) (6,3) |
    | (0,4) (1,4) | (1,4) (2,4) | (3,4) (4,4) | (5,4) (6,4) |
    | (0,5) (1,5) | (1,5) (2,5) | (3,5) (4,5) | (5,5) (6,5) |
    |    [0,1]    |    [1,1]    |    [2,1]    |    [3,1]    |
    |=============|-------------|-------------|-------------|---
    I             I (1,6) (2,6) | (3,6) (4,6) | (5,6) (6,6) |
    I       (1,7) I (1,7) (2,7) | (3,7) (4,7) | (5,7) (6,7) |
    I             I (1,8) (2,8) | (3,8) (4,8) | (5,8) (6,8) |
    I    [0,2]    I    [1,2]    |    [2,2]    |    [3,2]    |
    |=============|-------------|-------------|-------------|-
    |   .     .   |   .     .   |   .     .   |   .     .   | 
    |   .     .   |   .     .   |   .     .   |   .     
    |   .     .   |   .     .   |   .     .
    

    Transformation du caractère

    À présent que l'on connaît les coordonnées du caractère à modifier, il faut trouver un moyen de savoir quelle est sa valeur actuelle. Et là-dessus, le BASIC du VG5000µ ne nous aide pas. Il y bien une commande d'affichage à l'écran, PRINT, mais pas de commande spécifique pour connaître le caractère actuellement affiché à l'écran pour une position donnée.

    Heureusement, cet article décrit l'arrangement en mémoire des informations d'affichage telles que gérées par le BASIC. Il est donc possible, moyennant un autre changement de coordonnées et de l'instruction PEEK du BASIC, d'obtenir cette information.

    L'instruction PEEK prend en paramètre une adresse mémoire et renvoie son contenu sous la forme d'un octet, c'est-à-dire, d'un entier allant de 0 à 255. C'est une instruction, avec son pendant POKE qui permet de modifier le contenu d'une adresse mémoire, qui permet au BASIC d'interagir avec la machine au delà des instructions toutes faites. Nous y reviendrons dans d'autres articles.

    En lisant l'article sur l'arrangement mémoire des informations écran, il est facile de convertir les coordonnées d'un caractère à l'écran en adresse mémoire. Chaque ligne prend 80 octets, il faut donc multiplier le numéro de la ligne par 80. Et chaque caractère prend deux octets sur une ligne, il faut donc multiplier le numéro de la colonne par 2.

    Dans notre exemple, (0, 2) donne (0×2)+(2×80) = 160. L'emplacement est donc le 160ième depuis le début de la mémoire vidéo. Plus exactement 160ième et 161ième puisque chaque caractère prend deux octets. Encore un changement de repère.

    Il reste donc à décoder cette information, la modifier et la replacer en mémoire. Ceci sera pour la prochaine fois.

    Repère cartésien


« Page 2 / 4 »