Assembleur - Correction

1. Beaucoup de lignes pour rien...

copylr 15 20

copylr 27 21

copyra 20

addra 21

copyar 22

copyrr 22 dataLEDRegister

Ce programme fait donc ( simplement ! 😅) l'addition des deux valeurs placées aux adresses 20 et 21...

Vérification : Les LEDs affichent bien : 00101010(2) = 42(10).

2. Soustraction

On remplace simplement l'instruction d'addition par celle de soustraction; comme la machine ne gère pas les nombres en complément à 2, le résultat, lorsqu'il est théoriquement négatif, peut parfois surprendre...

copylr 15 20
copylr 27 21
copyra 20
subra 21
copyar 22
copyrr 22 dataLEDRegister
				

3. Multiplication

Faire le produit de deux valeurs stockées aux adresses 20 et 21 :

copylr 15 20			# copier la valeur 15 vers l'adresse 20
copylr 3 21				# copier la valeur 3 vers l'adresse 21
:loop					# début de la boucle
	addra 20			# additionner le contenu de l'accumulateur avec celui de l'adresse 20
	decjz 21			# décrémenter l'adresse 21; si égale à 0, on saute l'instruction suivante, sinon on continue normalement
	jmp loop			# retour en début de boucle
copyar dataLEDRegister	# copier le contenu de l'accumulateur ( qui contient le résultat du produit ) vers le registre d'affichage
				

Dans le cours sur la représentation binaire, vous avez vu que pour multiplier un nombre binaire par 2, il suffit de décaler tous ses bits d'une position vers la gauche; il existe une instruction qui réalise ceci, l'instruction shiftrl :

copylr 15 20				# copier la valeur 15 vers l'adresse 20
shiftrl 20					# décaler vers la gauche les bits du nombre à l'adresse 20
copyrr 20 dataLEDRegister	# copier le contenu de l'adresse 20 vers le registre d'affichage
				

Les LEDs affichent bien : 00011110(2) = 30(10).

4. Tant que l'on est dans les boucles...

4.1. Compteur binaire de 0 à 255

copylr 0 20
:loop
	copyrr 20 dataLEDRegister
	incrjz 20
	jump loop	
halt				
				

4.2. Compteur binaire de 255 à 0

copylr 255 20
:loop
	copyrr 20 dataLEDRegister
	decrjz 20
	jump loop	
halt				
				

5. Division

C'est plus délicat...

On a besoin, en plus de l'accumulateur, de 3 emplacements mémoires :

• deux pour stocker les nombres à diviser
• un troisième qui servira de "compteur de quotient" : à chaque soustraction, on incrémentera cet adresse de 1, ce qui fait qu'à la fin du programme, elle contiendra le nombre de fois où l'on a soustrait le deuxième nombre au premier, c'est à dire le quotient de ces deux nombres.

Et attention, le programme commence à être assez long : on choisira donc des adresses suffisamment "loin" du début de la mémoire pour ne pas venir "empiéter" sur les instructions ( architecture de von Neumann ! )

copylr 48 30				# premier nombre
copylr 12 31				# deuxième nombre
copylr 0 32					# compteur de quotient
copyra 30					# copie dans l'accumulateur du premier nombre
:loop						# début de boucle
	incr 32					# incrémentation du compteur de quotient
	subra 31				# soustraction, dans l'accumulateur, du deuxième nombre au premier
	bcrss 0 252				# est-on arrivé à un résultat nul ?
	jump loop				# si non, on revient en début de boucle,
copyrr 32 dataLEDRegister	# si oui, on affiche le quotient ( stocké à l'adresse 32 )