Le 6502 est installé sur une breadboard et le câblage est en place pour l’EEPROM. Le système est désormais en mesure de lire des programmes arbitrairement longs, j’ai donc besoin de pouvoir programmer la ROM plus de 16 octets à la fois. Jusque là je n’utilisais que 4 lignes d’adresses car l’Arduino n’a pas assez de broches pour utiliser les 15 lignes en même temps, mais il est possible de produire plus de sortie grâce à un composant qu’on appelle registre à décalage.

Un registre à décalage est capable de produire plusieurs sorties à partir d’un seul bit d’entrée. On envoie les valeurs une par une et elles sont distribuées sur les lignes de sorties, dans l’ordre. Chaque nouvelle donnée “pouse” les données déjà présente d’un cran. Il est possible de connecter plusieurs registres les uns à la suite des autres pour produire un nombre arbitraire de sorties. On peut également figer la sortie le temps qu’on pousse toutes les données pour éviter que les appareils connectés ne voient les données se déplacer d’une ligne à l’autre, ce qui pourrait avoir des conséquences indésirables.

J’utilise le circuit 74HC595 que j’avais en stock. C’est un registre à décalage qui possède 8 lignes de sortie. Pour contrôler 15 lignes d’adresse il en faut donc deux. Comme d’habitude je commence par les bases, avec un montage minimal pour me familiariser avec le fonctionnement. Je place un registre à décalage et 8 LEDs avec leur résistances.

Le 74HC595 possède en tout 5 signaux de contrôle :

Signal Signification Fonction
/OE Output Enabled Active la sortie des données
SER Serial input Reçoit la donnée d’entrée
SRCLK Shift register clock Pousse la donnée d’entrée dans le registre et décale les données existantes
RCLK Storage register clock Libère la sortie pour refléter les données internes
/SRCLR Overriding clear Efface tout

Je connecte l’alimentation et la masse, et je mets /SRCLR à 1 car je ne prévois pas de l’utiliser. Je mets /OE à 0 pour activer la sortie, et le reste sera piloté manuellement. Je passe SER à 1, puis passe SRCLK à 1 puis à nouveau à 0. J’essaie plusieurs fois avec différentes valeurs mais les tests ne sont pas très concluants. J’ai soit toutes les LEDs allumées, soit toutes éteintes. Je soupçonne des mauvais contacts, mais à un moment j’ai les 4 premières éteintes et les autres allumées. Je me dit que mes manipulations manuelles provoquent peut-être plusieurs pulse sur SRCLK ce qui a pour effet de pousser plusieurs données d’un coup. Je décide donc de passer au pilotage par Arduino.

Premier montage du registre à décalage avec Arduino

Je connecte les signaux de contrôle sur l’Arduino et code un programme de test. Je commence par essayer de pousser un bit à la fois. Ça a l’air de bien fonctionner. J’écris une fonction de test qui pousse alternativement un 1 et un 0 avec un délai entre chaque. Ça fonctionne comme attendu. Je teste ensuite une fonction capable de pousser un octet. Tout fonctionne bien. Au début j’avais mis des temporisations mais en fait elles ne sont pas nécessaire. J’ai connecté une LED supplémentaire pour afficher la valeur du dernier bit de donnée dans le registre. Contrairement aux autres cette donnée est toujours à jour avec l’état interne même si on fige la sortie, car elle est destinée à être connectée au registre suivant quand on chaine plusieurs.

Injection de 1, 0, 1, 0, etc

Injection de 0xEA

Code pour pousser les données dans le registre à décalage

Arduino fournit une fonction shiftOut() qui permet de pousser 8 bits de données. Je teste en lui passant les pins que j’ai configurées pour la donnée d’entrée et pour la clock et vérifie que ça fonctionne bien. La fonction pousse les données mais ne met pas à jour la sortie, donc il faut toujours faire ça manuellement.

La fonction shiftOut() permet de pousser 8 bits

Je teste maintenant d’ajouter un registre. Je le place sur la breadboard à côté du premier, je connecte l’alimentation, /OE et /SRCLR. Je ne peux pas ajouter d’autres LEDs donc je laisse les 4 premières connectées au 4 premières sorties du premier registre, et je connecte les 4 dernières au 4 dernières sorties du second registre. Et au début, rien ne fonctionne. C’est parce que j’avais oublié de connecter les signaux SER, RCLK et SRCLK du premier registre sur le second. Une fois fait ça fonctionne bien. Je teste en poussant un 1 puis que des 0 pour voir avancer le 1. Comme attendu il traverse les 4 premières LEDs, puis après un temps réapparait sur les 4 suivantes.

Montage avec deux registres

Déplacement d'un bit au travers de deux registres

Le code Arduino est disponible sur GitHub.

La suite

Les registres à décalage vont permettre de créer un circuit de programmation complète de la ROM avec Arduino malgré la limitation du nombre de broches. Une fois capable d’écrire des programmes arbitrairement longs, je pourrai commencer à installer une puce d’entrées-sorties qui permettra de connecter des périphériques au 6502 et d’avoir enfin des résultats observables sans instruments.