Chargeur de programme assembleur

Vue d'ensemble

• Objectif : le chargeur de programme assembleur est un composant spécialisé qui convertit des programmes en langage assembleur en code machine binaire et les charge dans des composants mémoire. Il fait le pont entre le code assembleur lisible par l'humain et les instructions binaires que les circuits numériques peuvent traiter.
• Symbole : le chargeur de programme assembleur est représenté par un bloc rectangulaire avec des entrées pour l'horloge, l'autorisation, l'autorisation de sortie d'adresse et l'autorisation de sortie de données, et des sorties pour le bus d'adresses, le bus de données, l'autorisation d'écriture, la sélection de puce et l'achèvement du chargement.
• Rôle dans DigiSim.io : permet de tester et exécuter des programmes assembleur dans des conceptions de CPU sans convertir manuellement le code en binaire, en faisant un outil pédagogique essentiel pour explorer les concepts d'architecture des ordinateurs.

Description fonctionnelle

Comportement logique

Le chargeur de programme assembleur lit le code assembleur saisi par l'utilisateur, le convertit en code machine et l'écrit séquentiellement dans des adresses mémoire. Il fonctionne sous forme de machine à états avec des phases distinctes : repos, chargement et achèvement.

Flux opérationnel :

1. Lorsque le chargeur est déclenché (via sa boîte de dialogue de propriétés), il commence le processus de conversion
2. À chaque front montant CLK pendant que EN est HIGH, le chargeur avance vers l'instruction suivante
3. Pendant le chargement, les sorties WE et CS sont HIGH
4. Lorsque le chargement est terminé, la sortie LC (Load Complete) passe à HIGH
5. Les sorties d'adresse sont pilotées lorsque A_OE est HIGH ; les sorties de données sont pilotées lorsque D_OE est HIGH

Entrées et sorties

• Entrées (4 au total) :

  • CLK : broche 0. Entrée d'horloge — le chargeur avance à chaque front montant.
  • EN (Enable) : broche 1. Autorisation globale du chargeur. Le chargement n'avance que lorsque HIGH.
  • A_OE (Address Output Enable) : broche 2. Lorsque HIGH, les sorties d'adresse (A0-A7) sont pilotées ; sinon en haute impédance.
  • D_OE (Data Output Enable) : broche 3. Lorsque HIGH, les sorties de données (D0-D7) sont pilotées ; sinon en haute impédance.

• Sorties (19 au total) :

  • A0-A7 : broches 0-7. Bus d'adresses 8 bits spécifiant l'emplacement mémoire où écrire.
  • D0-D7 : broches 8-15. Bus de données 8 bits contenant l'instruction en code machine à écrire en mémoire.
  • WE : broche 16. Signal d'autorisation d'écriture — HIGH pendant le chargement actif.
  • CS : broche 17. Signal de sélection de puce — HIGH pendant le chargement actif.
  • LC (Load Complete) : broche 18. Passe à HIGH lorsque le chargement est terminé.

Paramètres configurables

• Programme assembleur : l'utilisateur peut entrer et modifier le code assembleur via la boîte de dialogue de propriétés du composant.
• Taille mémoire : le nombre maximal d'instructions qui peuvent être chargées (généralement limité par le composant mémoire connecté).

Représentation visuelle dans DigiSim.io

Le chargeur de programme assembleur est affiché sous la forme d'un bloc rectangulaire avec des entrées étiquetées sur le côté gauche (CLK, EN, A_OE, D_OE) et des sorties sur le côté droit (A0-A7, D0-D7, WE, CS, LC). Lorsqu'il est connecté dans un circuit, le composant indique visuellement son état actuel via les valeurs affichées sur ses sorties. L'utilisateur peut interagir avec le composant via sa boîte de dialogue de propriétés pour entrer et modifier le code assembleur.

Valeur pédagogique

Concepts clés

• Programmation assembleur : introduit les concepts fondamentaux de la programmation en langage assembleur.
• Génération de code machine : démontre comment les instructions assembleur lisibles par l'humain sont converties en binaire.
• Gestion mémoire : montre comment les programmes sont chargés séquentiellement en mémoire.
• Architecture des ordinateurs : relie les concepts logiciels à l'implémentation matérielle.
• Architecture du jeu d'instructions : introduit le concept de formats et d'encodage d'instructions.

Objectifs d'apprentissage

• Comprendre la relation entre le langage assembleur et le code machine.
• Apprendre comment les programmes sont chargés en mémoire pour exécution.
• Reconnaître le processus de traduction des instructions symboliques en binaire.
• Appliquer les concepts de programmation assembleur pour créer des programmes simples pour les conceptions de CPU.
• Comprendre l'interface entre logiciel et matériel dans les systèmes informatiques.

Exemples d'utilisation / scénarios

• Test de CPU : chargement de programmes de test pour vérifier la fonctionnalité du CPU.
• Circuits de démonstration : création d'exemples pédagogiques d'architecture d'ordinateur.
• Implémentation d'algorithmes : écriture de programmes assembleur pour implémenter des algorithmes basiques comme le comptage, l'addition ou les boucles simples.
• Test du système mémoire : vérification des opérations de lecture/écriture mémoire de manière contrôlée.
• Exploration du jeu d'instructions : expérimentation de différents types d'instructions et de leurs effets.

Notes techniques

• Le chargeur de programme assembleur prend en charge un langage assembleur simplifié avec des instructions courantes (LDA, STA, ADD, SUB, JMP, JZ, JNZ, HLT).
• Les étiquettes dans le code assembleur sont automatiquement résolues en adresses mémoire pendant le processus de chargement.
• Des emplacements mémoire spécifiques peuvent être initialisés avec des valeurs de données en utilisant la syntaxe @addr: value.
• Le chargeur traite les instructions séquentiellement, donc les programmes plus larges peuvent nécessiter des composants mémoire plus larges.
• Dans DigiSim.io, le comportement du chargeur simule la phase de chargement de programme d'un système informatique réel, en faisant abstraction des complexités des assembleurs et des éditeurs de liens.
• Une synchronisation correcte à l'aide des signaux WE, CS et LC est importante lors de l'intégration du chargeur avec d'autres composants.

Broches

Nom de broche	Type	Index de broche	Description
CLK	Entrée	0	Signal d'horloge — le chargeur avance sur le front montant
EN	Entrée	1	Autorisation — le chargement n'avance que lorsque HIGH
A_OE	Entrée	2	Autorisation de sortie d'adresse — pilote le bus d'adresses lorsque HIGH
D_OE	Entrée	3	Autorisation de sortie de données — pilote le bus de données lorsque HIGH
A0-A7	Sortie	0-7	Bus d'adresses 8 bits se connectant aux entrées d'adresse mémoire
D0-D7	Sortie	8-15	Bus de données 8 bits se connectant aux entrées de données mémoire
WE	Sortie	16	Autorisation d'écriture — HIGH pendant le chargement actif
CS	Sortie	17	Sélection de puce — HIGH pendant le chargement actif
LC	Sortie	18	Load Complete — HIGH lorsque le chargement est terminé

Utilisation

1. Connectez le composant à votre composant ROM ou RAM :

   • Connectez les sorties A0-A7 aux broches d'entrée d'adresse de votre composant mémoire
   • Connectez les sorties D0-D7 aux broches d'entrée de données de votre composant mémoire
   • Connectez WE à l'entrée d'autorisation d'écriture de votre composant mémoire
   • Connectez CS à l'entrée de sélection de puce de votre composant mémoire

2. Entrez votre programme assembleur dans la boîte de dialogue de propriétés du composant.

3. Connectez CLK à une source d'horloge et mettez EN, A_OE et D_OE à HIGH pour commencer le chargement.

4. Le composant va automatiquement :

   • Convertir le code assembleur en code machine
   • Écrire le code machine dans des adresses mémoire consécutives à partir de l'adresse 0
   • Maintenir WE et CS à HIGH pendant le processus de chargement
   • Mettre LC (Load Complete) à HIGH lorsque le chargement est terminé

5. Attendez le signal LC avant d'exécuter le programme avec votre CPU.

Langage assembleur pris en charge

Le chargeur de programme assembleur prend en charge un langage assembleur simple avec les instructions suivantes :

LDA addr    ; Load accumulator from memory address
STA addr    ; Store accumulator to memory address
ADD addr    ; Add value at memory address to accumulator
SUB addr    ; Subtract value at memory address from accumulator
JMP addr    ; Jump to address
JZ addr     ; Jump to address if accumulator is zero
JNZ addr    ; Jump to address if accumulator is not zero
HLT         ; Halt execution

Programme exemple

Voici un programme exemple qui compte de 1 à 10 et stocke le résultat à l'adresse mémoire 15 :

      LDA 14     ; Load 0 into accumulator (from address 14)
LOOP: ADD 13     ; Add 1 (from address 13)
      STA 15     ; Store result at address 15
      SUB 12     ; Subtract 10 (from address 12)
      JZ END     ; If result is zero (reached 10), jump to END
      LDA 15     ; Load current count back into accumulator
      JMP LOOP   ; Jump back to LOOP
END:  HLT        ; Halt

; Data section (must be included somewhere in program)
@12: 10          ; Value 10 at address 12
@13: 1           ; Value 1 at address 13
@14: 0           ; Value 0 at address 14

Conseils

• Le chargeur traite le programme séquentiellement, en écrivant chaque instruction en mémoire
• Les étiquettes (comme LOOP: et END:) sont automatiquement résolues en adresses
• Utilisez la syntaxe @addr: value pour placer des valeurs spécifiques à des adresses spécifiques
• Pour les programmes plus larges, vous pouvez avoir besoin d'augmenter la taille de votre composant mémoire
• Vérifiez le signal LC pour assurer une synchronisation correcte avec votre CPU
• Le composant prend en charge les commentaires en utilisant le caractère point-virgule (;)