Unité de commande

Vue d'ensemble

• Objectif : l'unité de commande est le composant orchestrateur de l'architecture d'ordinateur 8 bits de DigiSim. Elle génère les signaux de contrôle nécessaires pour coordonner le compteur de programme, la mémoire (RAM), le registre d'instruction, l'ALU, le registre des indicateurs et d'autres composants afin d'exécuter un jeu d'instructions complet.
• Symbole : l'unité de commande est représentée par un bloc rectangulaire avec plusieurs broches d'entrée et de sortie pour s'interfacer avec les divers composants du CPU.
• Rôle dans DigiSim.io : l'unité de commande permet la création d'un ordinateur 8 bits complet et fonctionnel en séquençant et contrôlant correctement tous les composants du système à travers un cycle lecture-décodage-exécution-écriture.

Description fonctionnelle

Fonctionnement de la machine à états

L'unité de commande fonctionne comme une machine à états finis à 4 états qui parcourt :

1. FETCH : récupère l'instruction suivante depuis la mémoire
2. DECODE : décode l'instruction et incrémente le compteur de programme
3. EXECUTE : effectue l'opération spécifiée par l'instruction
4. STORE : stocke les résultats et met à jour les indicateurs si nécessaire

Entrées et sorties

Entrées (7 broches) :

Broche	Nom de broche	Type	Description
0	CLK	Entrée	Horloge système pour le fonctionnement synchrone
1	RST	Entrée	Signal de réinitialisation pour initialiser l'unité de commande
2	OP0	Entrée	Bit 0 du code opération depuis le registre d'instruction
3	OP1	Entrée	Bit 1 du code opération depuis le registre d'instruction
4	OP2	Entrée	Bit 2 du code opération depuis le registre d'instruction
5	OP3	Entrée	Bit 3 du code opération depuis le registre d'instruction
6	Z_FLAG	Entrée	Indicateur Zéro depuis le registre des indicateurs pour les sauts conditionnels

Sorties (18 broches) :

Broche	Nom de broche	Type	Description
0	PC_INC	Sortie	Incrémenter le compteur de programme
1	PC_LD	Sortie	Charger le compteur de programme (pour les sauts)
2	PC_OE	Sortie	Autorisation de sortie du compteur de programme (vers le bus d'adresses)
3	MEM_RD	Sortie	Autorisation de lecture mémoire
4	MEM_WR	Sortie	Autorisation d'écriture mémoire
5	RAM_OE	Sortie	Autorisation de sortie de la RAM (vers le bus de données)
6	IR_LD	Sortie	Chargement du registre d'instruction
7	IR_ADDR_OE	Sortie	Autorisation de sortie d'adresse de l'IR (vers le bus d'adresses)
8	ALU_OP0	Sortie	Bit 0 du code opération de l'ALU
9	ALU_OP1	Sortie	Bit 1 du code opération de l'ALU
10	ALU_OP2	Sortie	Bit 2 du code opération de l'ALU
11	ALU_OE	Sortie	Autorisation de sortie de l'ALU (vers le bus de données)
12	ACC_LD	Sortie	Chargement de l'accumulateur
13	ACC_OE	Sortie	Autorisation de sortie de l'accumulateur (vers le bus de données)
14	FLG_LD	Sortie	Chargement du registre des indicateurs
15	HALT	Sortie	Indicateur d'arrêt système
16	STATE0	Sortie	Bit 0 d'état (LSB de l'encodage d'état 2 bits)
17	STATE1	Sortie	Bit 1 d'état (MSB de l'encodage d'état 2 bits)

Encodage d'état (STATE1:STATE0) :

• 00 → FETCH
• 01 → DECODE
• 10 → EXECUTE
• 11 → STORE

Architecture du jeu d'instructions

L'unité de commande prend en charge un jeu de 16 instructions avec des opcodes de 4 bits :

Opcode	Hex	Mnémonique	Description	Opération
0000	0x0	NOP	Pas d'opération	PC ← PC + 1
0001	0x1	LDA addr	Charger l'accumulateur	ACC ← M[addr]
0010	0x2	STA addr	Stocker l'accumulateur	M[addr] ← ACC
0011	0x3	ADD addr	Ajouter à l'accumulateur	ACC ← ACC + M[addr]
0100	0x4	SUB addr	Soustraire de l'accumulateur	ACC ← ACC - M[addr]
0101	0x5	AND addr	ET logique	ACC ← ACC & M[addr]
0110	0x6	OR addr	OU logique	ACC ← ACC | M[addr]
0111	0x7	XOR addr	OU exclusif logique	ACC ← ACC ^ M[addr]
1000	0x8	NOT	NON logique	ACC ← ~ACC
1001	0x9	SHL	Décalage à gauche	ACC ← ACC << 1
1010	0xA	SHR	Décalage à droite	ACC ← ACC >> 1
1011	0xB	JMP addr	Saut inconditionnel	PC ← addr
1100	0xC	JZ addr	Saut si zéro	if (Z=1) PC ← addr
1101	0xD	JNZ addr	Saut si non zéro	if (Z=0) PC ← addr
1110	0xE	LDI	Chargement immédiat	Réservé pour usage futur
1111	0xF	HLT	Arrêt	Arrêter l'exécution

Format d'instruction

Position du bit	7	6	5	4	3	2	1	0
Champ	OPCODE (4 bits)				OPÉRANDE (4 bits)
Description	Opération à effectuer				Adresse mémoire/Valeur

Architecture du microcode

Génération des signaux de contrôle

L'unité de commande utilise une approche par ROM de microcode où chaque instruction est décomposée en micro-opérations à travers les quatre états. Chaque combinaison d'opcode et d'état produit un ensemble spécifique de signaux de contrôle.

Exemple : instruction LDA (Load Accumulator)

État FETCH :

• PC_OE = 1 (le PC pilote le bus d'adresses)
• MEM_RD = 1 (lecture de l'instruction depuis la mémoire)
• IR_LD = 1 (chargement de l'instruction dans l'IR)

État DECODE :

• PC_INC = 1 (incrémenter le PC vers l'instruction suivante)

État EXECUTE :

• IR_ADDR_OE = 1 (l'adresse de l'IR pilote le bus d'adresses)
• MEM_RD = 1 (lecture des données depuis l'adresse mémoire)

État STORE :

• RAM_OE = 1 (la RAM pilote le bus de données)
• ACC_LD = 1 (chargement des données dans l'accumulateur)
• FLG_LD = 1 (mise à jour des indicateurs)

Contrôle de bus et gestion des trois états

L'unité de commande gère soigneusement le conflit de bus en s'assurant qu'un seul composant pilote chaque bus à un moment donné :

• Bus d'adresses : contrôlé par PC_OE ou IR_ADDR_OE
• Bus de données : contrôlé par RAM_OE, ALU_OE ou ACC_OE

Intégration avec d'autres composants

Compatibilité des composants

L'unité de commande est conçue pour fonctionner de manière transparente avec les composants existants de DigiSim :

• ALU 8 bits : reçoit les codes d'opération (ALU_OP0-2) et fournit les résultats avec les indicateurs
• Compteur de programme : contrôlé via les signaux PC_INC, PC_LD et PC_OE
• RAM (256×8) : géré via les signaux MEM_RD, MEM_WR et RAM_OE
• Registre d'instruction : chargé via IR_LD et fournit la séparation opcode/adresse
• Registre des indicateurs : mis à jour via FLG_LD et lu pour les sauts conditionnels (Z_FLAG)
• Accumulateur : contrôlé via les signaux ACC_LD et ACC_OE

Calage des signaux

L'unité de commande assure des temps de mise en place et de maintien corrects pour tous les composants :

1. Mise en place de l'adresse : les signaux d'adresse sont stables avant les opérations mémoire
2. Données valides : les données sont valides lorsque les signaux de chargement sont actifs
3. Synchronisation d'horloge : tous les changements d'état se produisent sur les fronts montants d'horloge
4. Comportement de réinitialisation : réinitialisation asynchrone immédiate vers un état connu

Exemples d'utilisation

Programme simple : additionner deux nombres

; Add two numbers stored in memory
0x0: LDA 0x8    ; Load first number from address 0x8
0x1: ADD 0x9    ; Add second number from address 0x9
0x2: STA 0xA    ; Store result at address 0xA
0x3: HLT        ; Halt execution
...
0x8: 0x05       ; First number (5)
0x9: 0x03       ; Second number (3)
0xA: 0x00       ; Result location

Exemple de boucle : compter de 1 à 10

; Count from 0 to 10
0x0: LDA 0x8    ; Load counter
0x1: ADD 0x9    ; Add 1
0x2: STA 0x8    ; Store counter
0x3: SUB 0xA    ; Subtract 10
0x4: JNZ 0x0    ; Jump back if not zero
0x5: HLT        ; Halt when done
...
0x8: 0x00       ; Counter
0x9: 0x01       ; Constant 1
0xA: 0x0A       ; Constant 10

Notes techniques

Exigences d'horloge

• Fréquence minimale : 1 Hz pour l'observation pédagogique
• Fréquence maximale : limitée par les délais de propagation des composants
• Rapport cyclique : 50 % recommandé pour des marges de calage optimales

Comportement de réinitialisation

• Réinitialisation asynchrone : positionne immédiatement l'état à FETCH
• Effacement des signaux : tous les signaux de contrôle sont réinitialisés à l'état inactif
• Récupération après arrêt : nécessite une réinitialisation pour reprendre l'exécution

Performance

• Toutes les instructions : 4 cycles d'horloge (lecture-décodage-exécution-écriture)
• Instructions par seconde : fréquence d'horloge ÷ 4
• Bande passante mémoire : une lecture ou écriture par cycle d'instruction