Comment tester un Microprocesseur Z80 ? (schéma, explications, et carte PCB)

Si comme moi vous avez des vieux microprocesseurs Z80 de chez Zilog en stock dans vos tiroirs, vous voudrez peut-être savoir s’ils fonctionnent toujours, avant de les réutiliser ici ou là ! C’est pourquoi je vous partage ici un petit testeur de CPU Z80 (version CMOS, format DIP) que j’ai réalisé il y a peu, initialement pour mes propres besoins. Bien sûr, je comprendrais que vous ne soyez pas emballé par cet article, si vous n’êtes pas fan de composants électroniques « vintage » 😉

Sinon, vous pourrez découvrir (ou redécouvrir) ici un composant électronique de légende, datant des années 80, ayant notamment marqué l’histoire au travers de certaines calculatrices mythiques (telles que la Ti-81, Ti-82, et Ti-85 de Texas Instruments), et certaines consoles de jeu bien connues (Game Boy, Game Gear, …). Et pour info, même si ce microprocesseur peut sembler appartenir à un passé lointain, sachez qu’il n’en est rien, car il est toujours fabriqué à ce jour, sous une forme plus ou moins évoluée. Il s’intègre notamment dans certains appareils de bureautique ou autre (tels que les photocopieurs, etc).

Comme toujours, ces réalisations pratiques se veulent les plus simples et ludiques possibles, afin que vous puissiez apprendre d’elles, et pourquoi pas ici, vous initier au fonctionnement primaire des microprocesseurs (si vous n’avez aucune connaissance en la matière). Ainsi, ce projet permettra aux débutants d’entrevoir et comprendre comment fonctionne un microprocesseur, au ralenti, tout du moins, vu de l’extérieur ! Bien sûr, le but n’est pas ici de faire l’éloge du Z80, ni même de faire l’étalage de ses nombreuses fonctionnalités, mais simplement de pouvoir en tester son fonctionnement primaire, au travers d’un montage simplifié, et didactique. Alors, en route !

Intro : les raisons de ce projet + vidéo fonctionnement

Comme bien souvent, les montages publiés sur ce site ne sont ni plus ni moins que des réalisations personnelles, dont j’avais besoin à un moment où à un autre. Et ce testeur de microprocesseur Z80 (en version CMOS) n’échappe pas à la règle ! Bien sûr, si vous n’êtes pas intéressé par ce type de composant vintage, ce projet ne vous intéressera probablement pas. Toutefois, certaines parties de la carte développée ici pourrait peut-être vous servir dans d’autres projets, ou vous inspirer. Alors n’hésitez pas à faire un tour un peu plus bas, au niveau des plans et schémas !

Sinon, la raison d’être de ce projet est simple : tester le fonctionnement d’un Z80-CPU, à vitesse lente, de manière purement visuelle.

D’ailleurs, voici à quoi ressemble le montage final, une fois assemblé et mis sous tension (désolé pour la qualité de la vidéo, faute d’équipement adéquat) :

Le moins qu’on puisse dire, c’est que le résultat est simple à interpréter ici. Car soit toutes les LEDs se mettent à clignoter un peu partout (signifiant que le CPU est « en vie »), soit certaines restent inanimées (signifiant que le CPU est « mort »).

À présent, voyons ensemble comment fonctionne ce testeur de microprocesseurs Z80 !

Principe de fonctionnement de ce montage

Le principe de fonctionnement de ce testeur de microprocesseur Z80 est en fait assez simple. En fait :

• le câblage physique de certaines entrées du Z80 fait qu’il ne va faire qu’exécuter des instructions NOP indéfiniment. En sachant qu’une instruction NOP (de l’anglais « No Operation ») ne fait rien, comme son nom l’indique.
• et le câblage physique de certaines sorties du Z80 va nous permettre de visualiser l’état du compteur interne (« compteur de programme »), qui avance de 1 en 1 à chaque instruction exécutée (donc à chaque NOP exécuté, ici)

Au final, c’est ce passage d’une instruction « qui ne fait rien » à la suivante, et ainsi de suite, qui va nous permettre de voir s’il y a « de la vie » au sein du microprocesseur, une fois mis sous tension !

Vous n’avez rien compris ? Ne vous inquiétez pas ! Car je vais vous réexpliquer tout cela avec plus de détails, en faisant au passage un bref rappel du principe de fonctionnement de ce type de microprocesseur.

En fait, un microprocesseur (CPU, en anglais) ne sait globalement faire qu’une seule chose : exécuter des instructions qu’on lui donne à faire, les unes après les autres. Ainsi, dès sa mise sous tension, un µP (microprocesseur) exécute la 1ère instruction, puis passe à la 2ème, et ainsi de suite (sans jamais s’arrêter, sauf instruction en ce sens, ou mise hors tension).

Dans le cas du Z80, c’est exactement ce qui se passe. En pratique, on fournit au Z80 les instructions une par une, via ses broches D0 à D7 (codé sur 8 bits, donc), et il se chargera de les exécuter. Ici, dans notre montage, nous allons soumettre l’instruction « NOP » en permanence au Z80, qui lui dira simplement de ne rien faire de particulier, si ce n’est de passer à l’instruction suivante (qui sera aussi un « NOP », … donc tout ceci se répétera indéfiniment).

Cette instruction « NOP » est codée « 00000000 » selon le datasheet du fabricant du Z80. En clair, il faut que les broches D0 à D7 soient mises à la masse, pour que le microprocesseur comprenne qu’on lui demande d’exécuter cette fameuse instruction NOP. C’est d’ailleurs ce qui est fait dans ce montage, où les lignes D0 à D7 sont reliées à la masse, de manière permanente ; du coup, le CPU ne fera qu’exécuter des instructions NOP, sans arrêt.

Mais quel est l’intérêt de dire au Z80 de « ne rien faire », de manière perpétuelle ? Et en quoi cela va nous permettre de vérifier s’il y a de l’activité en son sein ou non ?

Eh bien… il y a 2 choses importantes à bien comprendre ici :

• premièrement, chaque exécution d’instruction, quelle qu’elle soit, va faire activer des lignes externes spécifiques du Z80. Je pense notamment aux broches /M1 (signalant un cycle processeur), /RD (signalant une requête de lecture), et /MREQ (signifiant un accès mémoire). Et c’est cette activité sur ces broches qui nous indiquera que le Z80 est bel et bien « vivant ».
• deuxièmement, tout microprocesseur dispose d’un compteur interne (le « compteur de programme »), qui compte à partir de 0, et avance de un en un (hors « saut » spécifique), au rythme de chaque instruction. Et ce qui nous intéresse grandement ici, c’est le fait que la valeur de ce compteur de programme est reportée sur les broches A0 à A15 par le Z80, avant chaque lecture de nouvelle instruction. Ainsi, en « affichant » l’état des lignes A15 à A0, nous verrons la valeur de ce compteur. Là encore, cela nous permettra de constater extérieurement « l’avancement interne » du Z80, en mettant des leds à cet endroit là.

En bref, ce testeur ne fera que montrer l’activité externe des sorties du Z80, pour prouver la vie (ou l’absence de vie), au sein du microprocesseur.

Remarques complémentaires :

• les lignes /M1, /RD, et /MREQ, parmi d’autres, sont actives à l’état bas ; nous raccorderons du coup leurs LEDs respectives « à l’envers », pour que ces dernières s’allument lorsque ces lignes passent à « 0 »
• les lignes A0 à A15, qui sont en quelque sorte « l’image » du compteur de programme, interne au Z80, sont « actives » à l’état haut ; en fait, vous verrez ni plus ni moins qu’un comptage binaire sur 16 bits, avec sur A15 le bit de poids le plus fort, et sur A0 le bit de poids le plus faible. Ainsi A0 s’allumera 2 fois plus souvent que A1, qui s’allumera deux fois plus souvent que A2, etc.

Nota : le compteur de programme du Z80 étant codé et stocké sur 16 bits, il ne pourra compter que de 0 à 65535 (c’est à dire 2^16 – 1). La valeur décimale « 0 » correspond à la valeur binaire « 0000 0000 0000 0000 », donc que des « 0 » logique sur les broches A15 à A0. La valeur décimale « 65535 » correspond à la valeur binaire « 1111 1111 1111 1111 », donc que des « 1 » logique sur les broches A15 à A0. Une fois que le compteur « arrive au bout », il continu en repartant de zéro.

Enfin, pour qu’on puisse se faire une idée claire du bon fonctionnement du MPU Z80, l’horloge qui cadencera son avancée sera fortement réduite, jusqu’à descendre à 1 coup d’horloge par seconde, environ. C’est d’ailleurs ce que je vous propose de découvrir ci-après, en étudiant le schéma électronique de ce testeur de Z80.

Schéma électronique de ce testeur de Z80-CPU

Comme évoqué précédemment, nous allons forcer les entrées D0 à D7 du Z80-CPU à « 0 », afin de lui faire exécuter l’instruction « NOP » indéfiniment. À noter que normalement, ce n’est pas comme ça qu’on se sert d’un microprocesseur. En effet, en « temps normal », on branche à minima une mémoire programme sur les lignes D0-D7, pour y faire défiler toutes les instructions à exécuter, au fur et à mesure. Mais ici, pour exécuter une seule et même instruction, encore et toujours, le choix a été de simplement relier toutes ces entrées à la masse. Ainsi, le Z80 lit « 00000000 » en permanence sur son bus de données, ce qui correspond une instruction « NOP », selon le datasheet.

Bon… trêve de blabla ! Voyons le schéma de ce testeur à présent :

Afin que tout soit bien compréhensible, j’ai divisé ce schéma électronique en 6 « grands blocs » (et 2 petits, moins importants !). C’est ainsi qu’on retrouve :

• un bloc « alimentation », qui permet d’alimenter l’ensemble de notre montage, depuis une simple embase micro-USB (à noter qu’une diode anti-retour et un fusible rapide assurent la protection du circuit)
• un bloc « microprocesseur Z80 », qui est en fait le coeur du montage ; et si vous regardez de près, vous verrez ici les fameuses entrées D0-D7 reliées à la masse, via des résistances de pull-down (ceci afin que le CPU exécute des instructions NOP en permanence)
• un bloc « affichage des bits d’adresse », qui vous permettra de visualiser les sorties A0 à A15 du microprocesseur  ; pour rappel, ces sorties « projetteront » l’image du compteur de programme, qui est en fait un compteur binaire à 16 bits. Et comme chaque instruction exécutée fera avancer de 1 ce compteur, nous verrons les LEDS s’allumer à ce rythme, en sortie
• un bloc « affichage de quelques lignes du CPU », qui permettra de visualiser l’activité de certaines lignes spécifiques, émanant du Z80 ;  je pense notamment à :
  • M1, qui nous renseigne sur les cycles machines
  • MREQ, qui nous dit quand le µP cherche à accéder à la mémoire
  • RD, qui nous dit quand le CPU cherche à « lire » des données
  • et RFSH, qui servait « autrefois » au rafraîchissement des mémoires RAM
• un bloc « oscillateur », qui va fournir les impulsions d’horloge au Z80, lui permettant ainsi d’avancer pas à pas (et donc, exécuter instruction après instruction). À noter que cet oscillateur fonctionnera de manière particulièrement lente (environ 1 à 120 Hz, réglable par potentiomètre), alors que d’ordinaire, un Z80 est « normalement » cadencé à plusieurs mégahertz
• et un « circuit de reset », qui nous permettra de redémarrer le microprocesseur au besoin (sachant qu’il faudra tenir le bouton appuyé au moins « 3 cycles d’horloge », soit 3 secondes si vraiment vous faites tourner ce montage au ralenti) ; ce même circuit s’occupe également de faire un RESET du Z80, à la mise sous tension

Du reste, j’ai mis les lignes WAIT, INT, NMI, et BUSREQ à l’état haut, afin qu’elles soient désactivées (pour qu’elles ne perturbent pas le fonctionnement du CPU, qui exécutera des NOP à la chaîne !). Une remarque, au passage : j’ai relié ces lignes à des résistances de pull-up, par habitude, mais ce n’était pas nécessaire ici (car elles ne sont reliées à rien d’autre, et donc, ne risque pas de créer de conflits).

Le circuit imprimé PCB

Au niveau du circuit imprimé (PCB), voici comment cette réalisation se présente :

En fait, tous les composants se trouvent « devant », exception faite d’un condensateur de découplage CMS (format 1206), qui se trouve au dos du Z80.

Si jamais vous reproduisez ce circuit, faites notamment bien attention au sens de montage de certains composants (je pense notamment aux réseaux de résistances, bargraphes LED, et condensateurs polarisés). Du reste, voici quelques photos prises de mon côté, au moment du soudage des composants :

Nota : comme toujours, soudez de préférence et en premier les composants les moins hauts (ou plus petits), jusqu’à finir par les plus hauts (ou plus imposants/encombrants).

Essais : test de « vieux » microprocesseurs Z80 de récup !

Avant toute mise sous tension, il faut placer son Z80-CPU dans le support amovible ZIF (support à force d’insertion nulle, venant de l’anglais « zero insertion force »).

Ensuite, vous pouvez brancher l’alimentation USB de ce montage. Ainsi, vous devriez voir, à minima :

• la LED verte « power » s’allumer, de manière fixe
• et la LED orange « horloge » clignoter (plus ou moins vite, selon le réglage du potentiomètre, présent sur la carte)

Ensuite, basiquement :

• si aucune des LEDS bleues ne s’allume (M1, MREQ, RD, ou RFSH), c’est que votre CPU Z80 est « mort »
• si les LEDS bleues clignotent dans tous les sens, c’est que votre Z80 a de bonnes chances d’être opérationnel !

Ah oui… Pour ceux que ça intéresse, la séquence d’allumage des LEDS suit le rythme suivant :

En fait, chaque instruction NOP prend 4 cycles d’horloge (4 clignotements de la LED orange, donc), pour être exécuté par le microprocesseur. Pendant ce laps de temps, vous verrez :

• M1 clignoter 1 fois (indique le « cycle machine » du Z80)
• MREQ clignoter 2 fois (dont la 1ère pour effectuer la lecture physique en mémoire)
• RD clignoter 1 fois (qui signale quand le microprocesseur lit l’instruction qui lui est présentée sur ses entrées D0 à D7)
• et RFSH clignoter 1 fois

Pour rappel, le Z80 est normalement prévu pour être connecté à une « mémoire programme », et non 8 entrées constamment reliées à la masse ! C’est pourquoi il possède une ligne MREQ (pour « Memory Request »), lui permettant de dire qu’il veut communiquer avec une mémoire, ainsi qu’une ligne RD (signifiant « Read »), pour dire à la mémoire visée qu’il souhaite lire une valeur, à une adresse donnée.

Du reste, gardez bien à l’esprit que ce testeur se limite juste à faire exécuter des fonctions NOP au microprocesseur Z80. Ainsi, il ne saurait garantir son parfait fonctionnement, en toute circonstance. Cependant, si votre µP Z80 est HS, vous le saurez assez vite, avec ce petit montage bien pratique !

Enfin, comme nous fonctionnons à vitesse particulièrement réduite, au niveau de l’horloge, il se peut qu’il y ait exceptionnellement quelques bugs au démarrage du Z80, sous certaines conditions. Si jamais c’est le cas, attendez simplement quelques secondes que le CPU « retrouve son chemin », ou faites lui simplement un bon reset (rappel : le bouton de RESET sera à maintenir au moins 3 cycles d’horloge, soit 3 bonnes secondes, si vous êtes à la vitesse la plus lente).

Remarques : codification des Z80 (références Zilog)

Je voulais ici faire quelques remarques au sujet des différentes références utilisées par Zilog (le fabricant), pour désigner ses Z80. Oui, je dis « ses », car il y a plusieurs modèles !

Pour commencer, il faut savoir qu’il existe 2 types de technologiques utilisées par le fabricant, pour concevoir ses Z80. En effet, il y a eu :

• les modèles NMOS, référencés « Z084… » (qui étaient rapides, peu chers à fabriquer, mais quelque peu énergivores)
• et les modèles CMOS, référencés « Z84C… » (qui étaient vraiment plus économiques, énergétiquement parlant)

Ici, nous ne nous intéressons qu’aux modèles CMOS, référencés « Z84C… », car c’est plus ou moins eux qui se sont le plus répandus (la technologie CMOS ayant supplanté la plupart ses technologies « rivales », du fait de sa plus faible consommation électrique, et de sa meilleure « résistance au bruit »).

À présent, il faut savoir que Zilog n’a conçu que des microprocesseurs, sous sa référence « Z80 ». En effet, on retrouve grosso modo :

• le Z80-CPU (le fameux microprocesseur, objet de cet article), référencé Z84C00xx
• le Z80-DMA (un contrôleur d’accès direct à la mémoire), référencé Z84C10xx
• le Z80-PIO (un double port parallèle, d’entrée/sortie), référencé Z84C20xx
• le Z80-CTC (4 compteurs/timers), référencé Z84C30xx
• le Z80-SIO (un contrôleur d’entrées/sorties séries), référencé Z84C40xx

Avec des « xx » représentant un nombre à 2 chiffres, indiquant la fréquence nominale d’horloge pour chaque circuit intégré :

• « 04 » pour 4 MHz
• « 06 » pour 6 MHz (et même jusqu’à 6,144, voire 6,170 MHz, selon les notes du fabricant)
• « 08 » pour 8 MHz
• « 10 » pour 10 MHz (plus récent)
• « 20 » pour 20 MHz (plus récent)

Remarque : ce sont des vitesses d’horloge max notées ici. Car avec ces modèles CMOS, on peut en fait fonctionner de 0 Hz (DC) à cette fréquence « max » (c’est pourquoi ce montage fonctionne de 1 à 120 MHz, même si votre microprocesseur est fait pour fonctionner à plusieurs mégahertz).

Du reste, une petite mise en garde : j’ai remarqué que certaines références gravées sur certains Z80 pouvaient différer des références exposées précédemment (selon la provenance ou l’année de fabrication, par exemple). Ne prenez donc pas pour argent comptant toute cette codification ici, sans un minimum de recul, et de méfiance (afin de ne pas griller le moindre composant ou risquer de vous blesser, par inadvertance).

Liens utiles et téléchargements

Tout d’abord, si vous vous intéressez au microprocesseur Z80, ou souhaitez simplement vous rafraîchir la mémoire, vous trouverez ci-après :

• la manuel utilisateur du Z80-CPU : http://www.zilog.com/docs/z80/um0080.pdf (PDF, en anglais)
• le datasheet du Z80-CPU : http://www.zilog.com/docs/z80/ps0178.pdf (PDF, en anglais)

Évidemment, ces documents sont plus ou moins à jour, du fait que le CPU Z80 n’est plus autant commercialisé qu’avant, sous la forme présentée ici (boitier DIP, 40 broches).

Aussi, vous trouverez les fichiers sources de ce montage ci-après, si vous souhaitez le reproduire à l’identique :

• schéma électronique du testeur de Z80 (format PDF)
• fichier Gerber pour faire fabriquer le PCB (format ZIP)

Ainsi que les composants électroniques utilisés ici :

• 1 x connecteur micro-USB femelle, power only (à 2 pins uniquement), pour circuit imprimé (modèle 90° edge)
• 1 x diode 1N5817 (schottky, traversant)
• 1 x porte-fusible 5x20mm à souder sur PCB
• 1 x fusible rapide de 500 mA (format 5×20)
• 1 x microprocesseur Z80-CPU, format DIP (si besoin ; en lien, un modèle CMOS fonctionnant à 8 MHz)
• 1 x support ZIF à 40 broches (marque 3M)
• 1 x NE555 au format DIP
• 1 x support pour circuit intégré 8 broches (format tulipe)
• 2 x afficheurs bargraphes à 8 leds rouges chacun
• 1 x led verte (signal d’alimentation)
• 4 x leds bleues (signaux du Z80)
• 1 x led orange (signal d’horloge)
• 1 x bouton poussoir 12×12 traversant, SPST, 4 broches
• 1 x réseau de 8 résistances de 10 kohms + commun (format SIL, 9 broches)
• 3 x réseau de 8 résistances de 2,2 kohms + commun (format SIL, 9 broches)
• 2 x résistance 100 ohms 1 %, traversant (1/4 de watt)
• 1 x résistance 1 kohms 1 %, traversant (1/4 de watt)
• 1 x résistance 2,2 kohms 1 %, traversant (1/4 de watt)
• 2 x résistance 10 kohms 1 %, traversant (1/4 de watt)
• 1 x potentiomètre 100 kohms, format WH148
• 2 x condensateurs 10µF 16V
• 1 x condensateur 100 nF CMS format 1206 (découplage, Z80)
• 3 x condensateurs 100 nF (plastique ou céramique), traversant

Testeur de Z80 : autres remarques, et conclusion !

Avant de conclure, je vous rappellerai que ce testeur n’effectue qu’un test sommaire du Z80 CPU, et que par conséquence, il se pourrait très bien qu’il passe à côté d’un dysfonctionnement autre (car ici, nous ne faisons qu’exécuter des instructions « NOP » au microprocesseur, et l’entièreté des fonctions du MPU ne sont donc pas testées). Toutefois, je pense que ce testeur de Z80 est un « bon » outil de base, pour savoir si le µP est en vie ou non !

Par ailleurs, comme nous fonctionnons à très basse fréquence, le bouton RESET doit être maintenu jusqu’à 3 secondes, pour réinitialiser correctement le microprocesseur (qui a besoin que le RESET dure au moins 3 coups d’horloge, pour être pris en compte). Qui plus est, pensez à éviter toute mise en place ou retrait « à chaud », du microprocesseur ; en gros : mettez toujours votre le montage hors tension, avant de faire la moindre manip (et laissez quelques secondes aux condensateurs pour se décharger, afin d’avoir un « bon » reset, et un démarrage correct).

Aussi, pensez à ne mettre que des Z80-CPU modèle CMOS (référencés Z84C00…) sur ce montage, car les versions NMOS (référencées Z08400…) ne supporteraient pas des fréquences de fonctionnement aussi basses (pouvant aller de 0 Hz à 120 Hz environ, ici).

Enfin, notez que les résistances alimentant les LEDS et les bargraphes ont des valeurs élevées (2200 ohms). Si j’ai fait ce choix, c’est pour ne pas dépasser un courant max entrant de -1,6 mA, au niveau des sorties du Z80. Car ces dernières ne sont pas prévues pour absorber « beaucoup de courant » (ni en délivrer d’ailleurs, car le courant max sortant possible est de 2 mA). À noter toutefois que les valeurs de courant entrant et sortant sur les sorties du Z80 ne sont pas clairement ou directement spécifiées par le fabricant, suivant les versions de datasheet. Mais bon, tant qu’on y voit bien au niveau des LEDS, pourquoi consommer plus de courant ?

Voilà ! Je pense avoir fait le tour de ce petit testeur de microprocesseur Z80 « fait maison » ! J’espère qu’il vous sera utile, si vous en avez besoin, ou qu’il saura vous inspirer, pour vos futurs montages !

À bientôt 😉
Jérôme.

À découvrir aussi : les autres réalisations faites, et publiées sur ce site !

(*) Mis à jour le 18/01/2024