Lecture d’EPROM avec un Arduino

Tout a commencé en voulant équiper un TS-711E et son compagnon, un TS-811E, d’une interface pour les piloter par ordinateur. La documentation mentionne bien cette possibilité, ainsi que la description du langage de commande, mais il y a loin de l’envie à la réalisation.

En effet, ces matériels sont sortis au milieu des années 80 et par conséquent, il est difficile de trouver les différentes options de l’époque. Si les accessoires standards se trouvent encore sur eBay ou sur des sites d’annonces radioamateur (microphone, HP externe, pièces détachées, …), certains sont plus difficiles à trouver, voir impossible.

C’est le cas des interfaces IF-10A (TS-711/811) et IF-10B (TS-940) qui permettent la connexion d’un ordinateur. Malgré de nombreuses recherches sur le web, les annonces, les mailing lists, aucune possibilité d’obtenir une interface originale. Le seul moyen est de passer par le site de la société PIEXX Computers & Electronics pour se procurer cette interface. Elle n’est pas très bon marché et l’idée vient vite de se construire sa propre carte interface. D’autant que toutes les documentations et schémas sont disponibles sur le web et que les composants, bien qu’anciens, se trouvent facilement.

Seul soucis, mais de taille : l’interface seule ne sert à rien ! Il lui faut une EPROM à insérer sur un support à l’intérieur de l’appareil. Comme on ne trouve pas l’interface, on ne trouve pas plus l’EPROM pour ces matériels. Au mieux, on arrive à trouver des interfaces IF-10B pour TS-940 mais malgré le même type d’EPROM (2732A), le code n’est pas le même et est donc inutilisable sur des 711/811.

En y réfléchissant, même si l’on trouve une EPROM, encore faut-il le moyen de la copier. Et un programmeur d’EPROM qui prend en charge des 2732 est encore assez cher. Certes, on trouve des produits en provenance de l’empire du milieu, mais tous ne prennent pas en compte ces modèles de circuits et quand c’est le cas, les documentations et autres logiciels ne sont pas toujours fournis et les informations pas très précises.

C’est en posant des questions sur Twitter qu’un camarade radioamateur m’a soufflé l’idée de regarder ce que l’on trouve comme réalisations à base d’Arduino. Et on en trouve ! Et plusieurs pour différentes utilisations. En effet, on trouve des EPROM sur de nombreux équipements électroniques, et notamment sur des instruments de musiques comme les synthétiseurs des années 80 ainsi que chez les adeptes du Retrogaming où l’on trouve ces circuits dans les cartouches de jeux.

Je suis donc parti avec un montage décrit sur le site NYCRESISTOR, un collectif de hackers/makers de New York, notamment à partir de cet article.

Le montage est réalisé à partir d’un Chipkit Uno 32 de la société Digilent (carte remplacée depuis par la uC32). Cette carte a l’avantage d’être du même format qu’un Arduino Uno tout en proposant beaucoup plus de ports d’entrées/sorties. Elle est basée sur la plateforme open source de l’Arduino mais utilise un PIC32. La puissance de ce processeur ne nous est pas utile pour l’application proposée mais à l’époque de l’étude, je voulais tester ce qui se faisait dans ce type de carte et j’ai profité de cette occasion. Si vous voulez rester dans le cadre de cartes Arduino, la Mega fera l’affaire.

La programmation se fait avec le même environnement que l’IDE Arduino et Digilent propose son propre logiciel MPide.

L’article indiqué propose un code pour pouvoir lire des EPROM (on peut lire aussi des ROM, des EEPROM, etc, le principe reste le même) 27256, c’est à dire des circuit de 256 kbits, soit 32 Ko (256 Kbits / 8 = 32 Koctets). En ce qui me concerne, je suis intéressé par lire des EPROM 2732A, des mémoires de 4 Ko (32 Kbits / 8 = 4 Koctets).

Le sketch est mis à disposition par son auteur sur Github. Comme il est prévu pour une EPROM 27256, vous devez modifier la taille de l’espace mémoire à couvrir pour la lecture. Le code donne l’exemple de calcul pour une EPROM 27C256. Il suffit de l’adapter pour une 2732A. Le calcul est le suivant : (32 x 1024)/8 = 4096.

Dans le cas qui nous occupe, la ligne devient : #define MAX_ADDR 4096

Il y a aussi deux variables à modifier concernant les pins utilisées. La première pin des connexions pour les lignes d’adresses et la première pin pour les connections des lignes de données. Il suffit de suivre le commentaire de l’auteur pour adapter à votre situation. Dans mon cas, j’ai utilisé les mêmes pins de départ, le code est donc :

#define AD0 26
#define Q0 2

Vous remarquerez qu’il y a une différence entre la ligne A0 utilisée dans le code original et celle ci-dessus. C’est un commentaire à la suite du billet de Nycresistor qui indique le pourquoi et le comment de l’erreur de l’IDE, et comment la corriger.

Il reste une ligne à modifier concernant le nombre de pins nécessaires qui vont constituer l’adresse que l’on va lire sur l’EPROM. L’original va jusqu’à 16 (2 puissance 16 = 65536) mais dans notre cas, nous n’irons que jusqu’à 12 (2 puissance 12 = 4096). La ligne devient donc :

for (int i = AD0; i < AD0+12; i++)

Cela sera aussi à modifier dans la fonction loop ainsi :

for (int i = 0; i < 12; i++)

Malgré tout, cela n’a pas fonctionné du premier coup. Un problème de timing semblait à l’origine du soucis car à chaque appui du bouton reset pour redémarrer le programme, la lecture n’était jamais la même. En baissant la vitesse du port série il y avait du mieux, et même si des caractères revenaient souvent, impossible d’avoir une lecture fiable des données. Il semblait ne pas manquer grand chose…

Après avoir envisagé différentes solutions comme la modification du programme pour ne lire qu’une ligne ; l’utilisation d’un analyseur logique, et d’autres modifications, la lumière est venue à la suite d’un repas avec un ami radioamateur et la lecture d’un site web qui parlait justement de ce sujet.

Il a suffit d’ajouter une ligne au programme pour que tout fonctionne correctement. Les dernières lignes de code deviennent donc :

Serial.println(‘ ‘);
Serial.flush();
}
while (1) {}
}

Il y encore quelques caractères parasites au démarrage du programme. Mais une fois la première itération effectuée, un nouvel appui sur le bouton reset vous donne un code propre à l’utilisation.

Il n’y a pas grand chose de plus à ajouter pour en faire un programmateur d’EPROM. Ces circuits nécessitent une certaine tension appliquée à une broche pour indiquer que le prochain octet sur le bus sera destiné à l’écriture à l’adresse indiquée.

Mais depuis le démarrage de ce projet, des petits programmateurs d’EPROM d’origine extrême orientale à des prix défiant toute concurrence ont fait leur apparition et descendent jusqu’à la 2732, voir la 2716.

Si vous ne disposez que d’une carte Arduino Uno par exemple, ou une carte ne disposant pas suffisamment de pins d’entrées/sorties, il y aussi moyen de faire la même chose avec des registres à décalage en envoyant les bits en plusieurs fois au lieu d’une seule. Vous trouverez aisément tout ça sur le web.

Aujourd’hui où nous sommes nombreux à utiliser des cartes micro-contrôleurs, ce bout de code et son principe de fonctionnement permettent de lire n’importe quelle circuit de mémoire morte, ROM, EPROM, EEPROM.

Je vous mets à disposition en téléchargement le fichier texte du code modifié pour la lecture d’une EPROM 2732 qu’il suffira de copier/coller dans votre IDE compatible Arduino.

La prochaine étape sera la réalisation de la carte interface compatible IF-10A pour TS-711/811.