Cedric Hammiche

En 1995 pendant ma 2eme année d’I.U.T. Électronique et informatique industrielle à Evry Courcouronne, on avait des TP d’électronique et aussi des TP d’informatique …
Je faisais de l’assembleur 680×0 sur Atari ST depuis quelques années déjà, donc forcement je m’embêtais pendant les TP de 4 heures vu qu’il me fallait 45 minutes pour le terminer sans faire aucune préparation.
J’ai eu de la chance d’avoir un prof sympa et intéressant, il aurait pu me déchirer, mais lui ça ne le dérangeais pas au contraire, il me donnait du travail en plus !!
Comme j’adorais l’électronique, je finissais les TP en 2 – 3 heures et du coup il ma proposer de faire un coprocesseur vidéo pour les ordinateurs que l’on avais et qui ne possédaient pas de mode graphique.
Je devais me servir de l’oscilloscope comme écran pour afficher des images de 128 * 64 pixels et de l’ordinateur.

Si je résume donc il fallait, créer une carte d’interface entre l’ordinateur et l’oscilloscope et Pouvoir afficher une image de 128 sur 64 pixels en 255 niveau de luminance.
On avait :
- un ordinateur (qui affichait que des caractères et pas d’images) avec un espèce de port parallèle bidirectionnelle
- un oscilloscope avec 3 entrées :
* Channel X
* Channel Y
* Channel Z

L’OSCILLOSCOPE :
La channel X et Y permettais de voir des signaux sur l’oscilloscope, sur les oscilloscope il y a un bouton qui permet de commander le faisceau d’électron avec les 2 channels.
La channel Z c’était une entrée situé derrière l’oscilloscope qui permettait de régler la luminance du faisceau d’électron qui balaie l’écran.
Du coup il est possible de balayer l’écran de gauche a droite avec la channel X et de haut en bas avec la channel Y puis pour chaque coordonnée (X,Y) de modifier la luminance
du point grâce à la channel Z et donc d’afficher une matrice de points avec des nuances de vert pour afficher une image sur l’écran.

L’ORDINATEUR :
Une plage mémoire sur l’ordinateur était donc alloué pour la carte graphique.
Il fallait une plage de 128*64 octets, soit 1 pixel par octet ce qui nous donne 255 niveaux de luminance par points de quoi faire de belles images :p
Il suffisait donc d’écrire sur cette plage mémoire avec un petit programme pour pouvoir voir l’image sur l’oscilloscope.

LA CARTE GRAPHIQUE :
J’énumère les différents module de la carte graphique et je vous explique le pourquoi du comment :p
il fallait donc :
- 1 Horloge
- 1 Compteur 13 bits
- 1 RAM -> Mémoire avec un bus d’adresse de 13 bits et bus de données de 8 bits (capacité de 2^13 = 8 K octets)
- 3 convertisseurs CNA ( Numérique vers Analogique) de 8 bits.

Le principe c’est d’afficher une matrice de points de 128 * 64 pixels 50 fois par seconde à l’écran pour que cela soit fluide si par la suite on fait des animations :p
L’horloge est relié au compteur qui permet à chaque coup de l’horloge de compter de 0 à 8191 en boucle. les 13 bits du compteur vont servir a plusieurs choses :
- les 7 premiers bits ( 7bits = 128 ) seront relié au convertisseur CNA de la channel X pour avoir une valeur analogique de 0 à 5v représentatif de la position X du pixel.
- les 3 prochains bits ( 6bits = 64 ) seront relié au convertisseur CNA de la channel Y pour avoir une valeur analogique de 0 à 5v représentatif de la position Y du pixel.
Ainsi un cycle de comptage va permettre de balayer le faisceau d’électron de l’oscilloscope sur la matrice de points 128 par 64 pixel !
- les 13 bits seront relié au bus d’adresse de la RAM.
A chaque cycle d’horloge on pourra donc lire le bus de données 8bits de la RAM représentant la couleur du pixel de coordonnée (X,Y) !
Le 3eme convertisseur CNA sera relié au bus de données de la mémoire pour avoir une valeur analogique de 0 à 5v représentatif du niveau de luminescence via la channel Z.

L’horloge doit être cadencé au minimum à 409 KHz ( 128 pixels * 64 pixels * 50 fois par seconde) pour avoir un balayage de toute la matrice 50 fois par seconde.
On a donc un système autonome et indépendant de la machine, car la carte envoie constamment sur l’oscilloscope la luminance du point au coordonnées (X,Y) en balayant tout l’écran de gauche a droite et de haut en bas.
Une dernière étape reste a faire, c’est de pouvoir écrire dans la RAM les pixels.
Pour cela :
- un petit programme en assembleur sera nécessaire pour envoyer a la carte les pixels dans la RAM.
- un démultiplexeur sera nécessaire sur le bus d’adresse et le bus de données de la RAM pour pouvoir soit écrire en mémoire, soit rafraichir l’image sur l’oscilloscope.
En gros, le port de l’ordinateur va a son tour adresser la RAM et présenter sur le bus de données la couleur du pixel et sauvegarder en RAM.
Une fois fini, la carte reprends son autonomie et va donc rebasculer le bus d’adresse de la RAM sur le compteur pour de nouveau afficher les pixels sur l’oscilloscope.

Voila, au final ce que j’ai fait à marché, et je me suis même permis en fin d’années pendant une eval de TP (que je n’ai pas faite :p) de finir mon petit programme qui était un TETRIS en assembleur 680×0 jouable sur un oscilloscope