[[info:accueilinfo|{{ :iconemaison.jpg?nolink&25|Sommaire "Bases d'algorithmique et de programmation"}}]] ===== Programmer en assembleur 6800 - 6811 ===== [Mise à jour le : 9/10/2024] En cours de rédaction * **Ressources** * Jeu d'instruction du MC6800 * Simulateur SDK6800/6811 \\ ==== 1. Généralités ==== {{ :info:prog:motorola_mc6800_microprocessor.jpg?nolink&140|}} « Le 6800 est un microprocesseur **8 bits** produit par Motorola et sorti peu de temps après l'Intel 8080 en 1975. La famille de processeurs **6800/6811** a alimenté l'explosion précoce de l'informatique domestique. Ses **dérivés** ont été les processeurs de choix pour de nombreux ordinateurs personnels, notamment **Apple**, Commodore64, **Nintendo**, etc., et de nombreuses consoles de jeux. Ses descendants directs sont encore largement utilisés aujourd'hui. » \\ ==== 2. Le simulateur SDK6800/6811 ==== * **Ressource** : Mise en oeuvre du simulateur \\ \\ L’assembleur place les instructions-machine et les données en mémoire conformément aux directives d’assemblage. La **mémoire du simulateur** est présentée sous forme **matricielle** comme ci-dessous : {{ :info:prog:orgmemsimul.png?nolink&500 |}} * **Organisation du simulateur** {{ :info:prog:sdk6800.png?nolink |}} ==== 3. Langage d'assemblage et code machine ==== {{:info:prog:instruction.png?nolink&150 |}} Le **langage d’assemblage** est un équivalent du langage machine pour lequel les chaînes binaires de l’instruction-machine sont remplacées par des **mnémoniques alphanumériques** plus aisément mémorisable et manipulable par un être humain. Un **traducteur** transforme ce langage vers le langage machine équivalent : c’est l’**assembleur**. {{ :info:prog:assembleur.png?nolink |}} ===3.1 Organisation d'une ligne de code === Le **code source** d'un programme écrit en assembleur se décompose en champs de texte : {{ :info:prog:ligne_de_code_assembleur.png?nolink&350 |}} {{ :info:prog:exassemb6800.png?nolink|Exemple}} * Le champ **Étiquette** ou **Label** est utilisé pour définir un symbole. Pour ignorer ce champ, on introduit au moins un espace ou une tabulation. \\ * __Exemple__ : //msg// * Le champ **Opération** est occupé par un **opcode** ou une **directive d'assemblage**. * __Exemple d'opcode__ : //ldx// signifiant loadX, charge une valeur dans le registre x. * __Exemple de directives d'assemblage__ * **.str** signifie string. Cette directive force l'assembleur a identifier ce qui suit entre guillemet comme étant une chaine de caractères. * **.org** //adresse// signifie origine. Cette directive force l'assembleur à placer ce qui suit à la position //adresse// (ici le texte Hello World est placé entre les adresses 1000₁₆ et 100A₁₆) * Le champ **Opérande(s)** contient une adresse ou des données. Il est ignoré lorsque l’instruction utilise le mode d’adressage implicite. * __Exemples d'opérandes__ : #msg, pstring, $1000, "Hello World" * Le champ **Commentaire** est utilisé pour la documentation du logiciel. Un commentaire commence par un **point-virgule** et peut se situer à la fin ou au début d’une déclaration. * __Exemple__ : ;label op. operande comment \\ ===3.2 Un premier programme étape par étape=== ☛ Ouvrez le simulateur SDK6800/6811 en cliquant sur {{:info:prog:icosdk6800.png?nolink|}} **v3 ← v1 + v2** # Les variables v3, v2 et v1 sont des octets, 0 ≤ vx₁₀ ≤ 255 *** ÉTAPE 1 - Positionner, déclarer et initialiser les variables dans la mémoire** \\ Pour effectuer ces opérations, nous allons utiliser des directives d’assemblage et des étiquettes. Les directives d’assemblage sont des **pseudo-instructions** : elles ne correspondent à aucune instruction-machine ; ce sont des ordres destinés à l’assembleur. - **Positionnement des variables dans la mémoire** avec **.org** \\ ☛ **Positionnez** les variables à partir de l’adresse **0020**₁₆ dans la mémoire du simulateur comme ci-dessous. Le symbole **$** signifie que la valeur qui le suit est en **hexadécimal** (base 16). {{ :info:prog:prog1a.png?nolink |}} \\ - **Déclaraion et initialisation des variables** \\ La position des variables étant fixée, vous allez les **identifier** à l'aide d'une **étiquette**, les **déclarer** à l'aide de la directive **.byte** et les **initialiser** en leur affectant une valeur. \\ ☛ **Complétez** le code comme ci-dessous dans le simulateur. Ajoutez v2 et v3. {{ :info:prog:prog1b.png?nolink |}} {{ :info:prog:etiquette.png?nolink&200|}} Une **étiquette** ou **label** est une chaîne de caractères permettant de **nommer** une **instruction** ou une **variable**. Une étiquette correspond à une **adresse** dans le programme. *** ÉTAPE 2 - Positionner et rédiger le programme ** \\ __Rappel__ : on souhaite effectuer l’opération v3 ← v1 + v2 \\ {{ :info:prog:prog1c.png?nolink|}}\\ Les registres du processeur sont mis à contribution dans cette deuxième étape. Le MC6800 possède seulement deux **accumulateurs** (**A** et **B**) pour effectuer des calculs. La manière dont les registres accèdent aux données est appelée : **mode d’adressage**. \\ \\ Le programme est réalisé avec **3 instructions** : {{ :info:prog:instructions.png?nolink |}} \\ ☛ **Complétez** le code comme ci-dessous dans le simulateur. {{ :info:prog:prog1d.png?nolink |}} \\ * ** ÉTAPE 3 - Identifier le code machine dans la zone mémoire **