Guide de l'ordinateur

Démonstration interactive

Mémoire vive

	A
LE
	D

Pour lire la mémoire :

mettre en binaire l'adresse à lire dans les bits de A ;
mettre 1 dans le bit LE ;
donner un coup d'horloge ;
observer le résultat dans les bits de D.

Pour écrire dans la mémoire :

mettre en binaire l'adresse à écrire dans les bits de A ;
mettre en binaire la donnée à écrire dans les bits de D ;
mettre 0 dans le bit LE ;
donner un coup d'horloge ;
observer le résultat dans l'adresse mémoire.

Notez que si les bits de A ne correspondent pas à une adresse dans la mémoire, il ne se passe rien.

Carte graphique et écran

Cette carte graphique est constituée d'une mémoire vive et d'un contrôleur lisant automatiquement cette mémoire pour envoyer les pixels à l'écran. Cette carte noir&blanc envoie un pixel noir (éteint) pour un bit 0 et un pixel blanc (allumé) pour un bit 1. Il suffit d'écrire dans la mémoire et observer le résultat sur l'écran.

Microprocesseur

Pour fonctionner, le microprocesseur a besoin de l'addresse de l'instruction à exécuter. En outre pour une opération mathématique comme une addition, il a besoin des deux opérandes simultanément. Or il n'est pas possible de lire deux adresses simultanément. Ces informations sont donc temporairement stockées dans des registres du microprocesseur. Un registre est une mémoire d'un octet qui a un nom particulier et généralement pas d'adresse.


A						D
LE						H

Le registre contenant l'adresse de l'instruction à lire est le compteur ordinal, appelé program counter ou pc en anglais. Lorsque le microprocesseur est mis en marche, ce registre est initialisé à 0, ainsi le microprocesseur commence automatiquement par lire l'instruction à l'adresse 0. Après lecture, le pc est automatiquement incrémenté pour contenir l'adresse de la prochaine instruction.

Ce microprocesseur est aussi doté de quatre registres r0, r1, r2 et r3. Ces registres sont utilisés comme source et destination de toutes les opérations mathématiques et logiques (addition, décalage de bits, ou binaire…) En outre, ils évitent de nombreux accès à la mémoire, accélérant l'exécution des programmes.

langage assembleur	langage machine	commentaire
`put n, rb`	`000000bb nnnnnnnn`	Met l'octet `nnnnnnnn` dans r`b`.
`b0 rb, n`	`000001bb nnnnnnnn`	Si r`b` égale 0, met l'octet `n` dans `pc` (saute à l'adresse `n`).
`bn rb, n`	`000010bb nnnnnnnn`	Si r`b` est négatif, met l'octet `n` dans `pc` (saute à l'adresse `n`).
`b n`	`00001100 nnnnnnnn`	Met l'octet `n` dans `pc` (saute à l'adresse `n`).
`ld ra, rb`	`0001aabb`	Met l'octet d'adresse r`a` dans r`b` (lecture de la mémoire).
`st ra, rb`	`0010aabb`	Met l'octet r`a` dans l'adresse r`b` (écriture dans la mémoire).
`add ra, rb`	`0100aabb`	Met dans r`b` le résultat de r`b` + r`a`.
`sub ra, rb`	`0101aabb`	Met dans r`b` le résultat de r`b` - r`a`.
`or ra, rb`	`0110aabb`	Met à 1 les bits de r`b` valant 1 dans r`b` ou r`a`, met à 0 les autres bits.
`and ra, rb`	`0111aabb`	Met à 1 les bits de r`b` valant 1 dans r`b` et r`a`, met à 0 les autres bits.
`sl ra, rb`	`1000aabb`	Décale de r`a` positions à gauche les bits de r`b`, met à 0 les bits de droite.
`sr ra, rb`	`1001aabb`	Décale de r`a` positions à droite les bits de r`b`, met à 0 les bits de gauche.

Exemples de programme

Ces petits programmes sont écrits dans un langage assembleur très simple. La première colonne contient l'adresse du premier octet de l'instruction, la seconde colonne le nom de l'instruction, suivi des données ou nom des registres contenant les données.

Écrire 22 dans r0 :

0	put	22, r0

Écrire 22 dans l'adresse 123 :

0	put	22, r0
2	put	123, r1
4	st	r0, r1

Mettre dans l'adresse 123 l'addition des octets aux adresses 121 et 122 :

0	put	121, r0
2	ld	r0, r1
3	put	122, r0
5	ld	r0, r2
6	add	r1, r2
7	put	123, r0
9	st	r2, r0

Si r0 = 3 alors multiplier r1 par 2, autrement soustraire 3 à r1 :

0	put	3, r2
2	sub	r2, r0
3	b0	r0, 8
5	sub	r2, r1
6	b	9
8	add	r1, r1
9	add	r2, r0

Ordinateur

Cet ordinateur est constitué d'un écran monochrome de 8×8 pixels, d'une carte graphique monochrome de 8×8 pixels, d'une mémoire vive de 16 octets, d'un microprocesseur 8 bits cadencé par une horloge réglable (1 Hz par défaut), d'un clavier de trois touches (gauche, centre, droite) et d'une mémoire morte de 128 octets.

Il n'y a pas de lecteur de disquette ou autre périphérique ; le seul moyen de charger un programme est de le mettre dans la mémoire morte avant le démarrage. Cet ordinateur ressemble donc beaucoup à un petit jeu vidéo portable. Le programme en mémoire morte déplace deux pixels blancs en bas de l'écran selon la touche du clavier qui a été tapée.

ordinateur

décimal
binaire

carte
graphique

décimal
binaire

RAM

décimal
binaire

bus

décimal
binaire

horloge
& CPU

décimal
binaire

clavier

décimal
binaire

ROM

décimal
binaire

Ce bouton traduit le programme ci-contre du langage assembleur au langage machine, et s'il n'y a pas d'erreur, met le résultat dans la mémoire morte.