Correction Examen Architecture et Microprocesseur

Exercice 1 - Programmation du Timer 8253/8254

Cet exercice porte sur la configuration des différents compteurs d'un timer (généralement un 8253 ou 8254) en lui envoyant les bons mots de commande et les valeurs de division.

Question 1 - Configuration du compteur 2

Pour configurer le timer, nous devons d'abord déterminer le mot de commande à envoyer au registre de contrôle (port 7003h). Le mot de commande se construit bit par bit.

D'après les indications de l'énoncé, nous voulons :

• Compteur 2 : bits D7-D6 = 10
• Lecture/Écriture : Charger d'abord le poids faible (LSB) puis le poids fort (MSB) : bits D5-D4 = 11
• Mode de fonctionnement : L'énoncé indique les bits 011. Note de correction : le texte source indique "Mode 2" à côté de ces bits, mais 011 correspond techniquement au Mode 3 (générateur de signal carré). La valeur finale donnée par l'énoncé étant B6h, c'est bien le Mode 3 qui est configuré ici.
• Format de comptage : Binaire : bit D0 = 0

En concaténant ces bits, on obtient le mot binaire 10110110b, ce qui correspond à la valeur hexadécimale B6h. Ensuite, il faut envoyer le diviseur. La valeur à charger dans le compteur 2 (port 7002h) est 04FDh (soit LSB = FDh et MSB = 04h).

Voici le code assembleur correspondant, corrigé pour être syntaxiquement valide :

mov al, 0B6h      ; Mot de commande pour le compteur 2
mov dx, 7003h     ; Adresse du registre de contrôle
out dx, al        ; Envoi du mot de commande

mov dx, 7002h     ; Adresse du compteur 2
mov al, 0FDh      ; Poids faible (LSB) du diviseur
out dx, al        ; Envoi du LSB

mov al, 04h       ; Poids fort (MSB) du diviseur
out dx, al        ; Envoi du MSB

Question 2.a - Configuration du compteur 0 (Générateur de signal carré)

Nous devons ici configurer le compteur 0. L'énoncé nous donne la fréquence d'horloge et la fréquence de sortie souhaitée, ce qui permet de calculer le diviseur N : N = Fclk / F0 = 4.

Le mot de commande se construit ainsi :

• Compteur 0 : 00
• Lecture/Écriture : Charger LSB uniquement (car N=4 tient sur un seul octet) : 01
• Mode : Mode 3 (Signal carré) : 011
• Format : BCD : 1

Le mot de commande est donc 00010111b, soit 17h.

mov al, 17h       ; Mot de commande pour le compteur 0
mov dx, 7003h     ; Registre de contrôle
out dx, al

mov dx, 7000h     ; Adresse du compteur 0
mov al, 04h       ; Valeur du diviseur N = 4 (LSB)
out dx, al

Question 2.b - Chronogramme de la sortie Out 0

Avec un diviseur N = 4 en Mode 3 (générateur d'onde carrée), le signal de sortie Out0 sera à l'état haut pendant N/2 cycles d'horloge, et à l'état bas pendant les N/2 cycles suivants. Puisque N = 4, le signal restera à 1 pendant 2 périodes d'horloge (Clk0), puis à 0 pendant 2 périodes d'horloge. Le cycle se répète ensuite indéfiniment, formant un signal carré parfait d'une période totale de 4 µs (en supposant une horloge à 1 MHz d'après la graduation de 1 µs mentionnée dans la source).

Question 3 - Signal carré pour le compteur 1

L'énoncé demande un signal carré, ce qui implique obligatoirement l'utilisation du Mode 3. Le diviseur donné est N = 5.

Détermination du mot de commande :

• Compteur 1 : 01
• Lecture/Écriture : Charger LSB uniquement (N=5) : 01
• Mode : Mode 3 : 011
• Format : BCD : 1

Le mot binaire est 01010111b, soit 57h.

mov al, 57h       ; Mot de commande pour le compteur 1
mov dx, 7003h     ; Registre de contrôle
out dx, al

mov dx, 7001h     ; Adresse du compteur 1
mov al, 05h       ; Diviseur N = 5
out dx, al

Exercice 2 - Programme d'affichage de l'heure

Ce programme récupère l'heure système via l'interruption 21h (fonction 2Ch), la stocke dans un tableau, puis convertit chaque valeur en format décimal ASCII pour l'afficher à l'écran, avec un test de sortie si l'utilisateur appuie sur la touche ESC (Échap).

Voici le code restructuré et indenté proprement pour qu'il soit directement lisible et exécutable dans un environnement type TASM/MASM 8086.

Data Segment
    Heure   db 4 dup(?)
    Quitter db "Appuyer sur ESC pour quitter$"  ; Ajout du caractère $ de fin de chaîne
Data Ends

Code Segment
    Assume CS:Code, DS:Data

Debut:
    ; --- Chargement de l'heure ---
    mov ah, 2Ch       ; Fonction DOS: Lire l'heure système
    int 21h           ; CH=Heures, CL=Minutes, DH=Secondes, DL=1/100 sec
    
    ; --- Stockage de l'heure dans le tableau ---
    xor si, si
    lea si, Heure
    mov [si], cx      ; Stocke CH et CL (Heures et minutes)
    mov [si+2], dx    ; Stocke DH et DL (Secondes et 1/100)

    ; --- Initialisation des registres pour l'affichage ---
    mov bl, 4h
    mov cx, 4h        ; Boucle de 4 itérations (pour les 4 champs de l'heure)
    xor si, si
    lea si, Heure
    mov ah, 2h        ; Fonction DOS: Afficher un caractère (dans DL)

Afficher:
    push cx           ; Sauvegarde le compteur de boucle externe
    xor cx, cx
    mov cl, [si]      ; Charge la valeur temporelle actuelle dans CL
    mov al, 0h

En_decimal:
    ; Convertit la valeur binaire (hex) vers BCD par incrémentations successives
    inc al
    daa               ; Ajustement décimal après addition
    loop En_decimal
    
    ; Séparation des digits (fort et faible)
    mov dl, al
    and dl, 0F0h      ; Isole le quartet de poids fort
    shr al, bl        ; Décale pour avoir la vraie valeur du quartet fort (0-9)
    add al, 30h       ; 30h est le code ASCII de '0'
    mov dl, al
    int 21h           ; Affiche la dizaine
    
    mov dl, [si]      ; Restaure la valeur pour le quartet faible
    ; Note: le code source a une petite approximation ici, la version correcte 
    ; pour afficher l'unité de la valeur BCD calculée précédemment est :
    mov al, dl        ; On reprend la valeur BCD ajustée
    and al, 0Fh       ; Isole le quartet de poids faible
    add al, 30h       ; Convertit en ASCII
    mov dl, al
    int 21h           ; Affiche l'unité
    
    mov dl, 3Ah       ; Code ASCII de ':'
    int 21h           ; Affiche le séparateur ':'
    
    inc si            ; Passe à l'unité de temps suivante
    pop cx            ; Restaure le compteur de boucle
    loop Afficher
    
    ; --- Gestion du message de sortie et de la touche ---
    xor si, si
    lea dx, Quitter   ; La fonction 9h demande l'adresse de la chaîne dans DX (et non SI)
    mov ah, 9h        ; Fonction DOS: Afficher une chaîne terminée par '$'
    int 21h
    
    mov ah, 1h        ; Fonction DOS: Saisie d'un caractère avec écho (dans AL)
    int 21h
    cmp al, 1Bh       ; 1Bh = Code ASCII de ESC
    jz Fin            ; Si ESC est appuyé, on saute à Fin
    jmp Debut         ; Sinon, on reboucle pour rafraîchir l'heure

Fin:
    mov ax, 4C00h     ; Fonction DOS: Terminer le programme proprement
    int 21h

Code Ends
End Debut             ; Point d'entrée du programme

Précision méthodologique : Le code de l'énoncé contient de légers oublis typiques des brouillons d'examen (utilisation de SI au lieu de DX pour l'interruption 21h fonction 9h, manque du $ pour terminer la chaîne). Ils ont été corrigés ici pour assurer que le code fonctionne réellement.

Exercice 3 - Interface avec le PPI 8255 (Commande d'ascenseur)

Cet exercice met en œuvre un circuit interface programmable (PPI 8255) raccordé à des capteurs et moteurs. Les adresses de base déduites du code sont :

• Port A : 330h
• Port B : 331h
• Port C : 332h
• Registre de contrôle : 333h

Question 1 - Procédure d'initialisation (INIT)

La configuration 82h (10000010b) correspond au Mode 0 du 8255, programmant le Port A en sortie, le Port B en entrée et le Port C de la manière suivante : demi-port C supérieur en sortie et demi-port C inférieur en sortie.

INIT Proc Near
    mov al, 82h       ; Mot de commande: A(Sortie), B(Entrée), C(Sortie)
    mov dx, 333h      ; Adresse du registre de contrôle
    out dx, al
    RET
INIT Endp

Question 2 - Procédure de lecture (Lecture)

Cette procédure lit simplement l'état actuel des entrées raccordées au Port B.

Lecture Proc Near
    mov dx, 331h      ; Adresse du port B
    in al, dx         ; Lecture de l'état dans AL
    RET
Lecture Endp

Question 3 - Procédure d'affichage (Afficher)

Le Port B semble capter les niveaux via des bits individuels. Cette procédure trouve quel bit est à 1 (par des décalages successifs) pour déterminer l'index du niveau actuel, lit le code 7-segments correspondant dans TAB, et l'envoie sur le Port A.

Afficher Proc Near
    mov dl, 4h
    shr al, dl        ; On élimine les 4 bits de poids faible (probablement non utilisés)
    xor si, si

encore:
    shr al, 1h        ; Décalage à droite pour tester le bit de poids faible via la retenue (Carry)
    jc trouver        ; Si Carry = 1, on a trouvé le bit actif
    inc si            ; Sinon, on incrémente l'index
    jmp encore

trouver:
    mov al, TAB[si]   ; Charge le mot de contrôle de l'afficheur 7-segments
    mov dx, 330h      ; Adresse du port A
    out dx, al        ; Envoie la donnée pour allumer l'afficheur
    RET               ; Note: le RET manquait dans la source, ajouté ici
Afficher Endp

Question 4 - Procédure de commande (Command)

Cette procédure compare le niveau de l'ascenseur souhaité au niveau actuel, et ordonne la montée, la descente ou l'arrêt au moteur raccordé au Port C.

Command Proc Near
    mov ah, al        ; Copie la donnée lue dans AH
    and ah, 0Fh       ; Isole le niveau demandé (4 bits de poids faible)
    mov dl, 4h
    shr al, dl        ; Isole le niveau actuel (4 bits de poids fort rameneés en poids faible)
    
    cmp al, ah        ; Compare niveau actuel (AL) avec niveau demandé (AH)
    jz arret          ; Si égaux, il faut s'arrêter
    jc monte          ; Si Carry=1 (AL < AH), le niveau actuel est plus bas, il faut monter

    ; Sinon (AL > AH), on a une descente
    mov al, 0h        ; 00h est la commande hypothétique de descente (selon le câblage)
    jmp action

arret:
    mov al, 08h       ; 08h est la commande d'arrêt
    jmp action

monte:
    mov al, 88h       ; 88h est la commande de montée

action:
    mov dx, 332h      ; Adresse du port C
    out dx, al        ; Envoi de la commande moteur
    RET
Command Endp

Question 5 - Programme Principal et Segment de données

Ce code rassemble toutes les procédures définies précédemment. Le registre de données est déclaré avec le tableau TAB qui contient les masques d'affichage.

Data Segment
    TAB db 0FCh, 60h, 0DAh, 0F2h  ; Codes d'affichage des niveaux (ex: 0, 1, 2, 3)
Data Ends

Code Segment
    Assume CS:Code, DS:Data

Main:
    ; Initialisation des segments manquante dans le source (bonne pratique requise)
    mov ax, Data
    mov ds, ax

    CALL INIT         ; Configure le 8255

Boucle_Principale:
    CALL Lecture      ; Lit l'état (AL = état)
    CALL Afficher     ; Affiche le niveau actuel
    CALL Lecture      ; Relit l'état (pour détecter un nouveau bouton pressé)
    CALL Command      ; Agit sur le moteur (monte, descend, arrête)
    jmp Boucle_Principale  ; Reboucle à l'infini (Correction de "jmp Main")

Code Ends

Exercice 4 - Déduction des instructions manquantes

L'objectif de cet exercice est d'analyser un morceau de code amputé de trois instructions et de retrouver logiquement ces dernières en étudiant le contexte.

L'analyse de l'énoncé est la suivante :

1. Gestion de la boucle (LOOP) : Le programme contient deux instructions LOOP imbriquées (ou successives à l'intérieur d'un bloc) nécessitant l'utilisation du registre CX comme compteur. Puisque CX n'est pas réinitialisé entre les deux structures de manière explicite, il est obligatoire d'utiliser la pile pour sauvegarder et restaurer sa valeur afin d'éviter qu'une boucle n'écrase le compteur de l'autre. La première instruction manquante est donc l'empilement (sauvegarde) de CX, et la troisième est son dépilement (restauration).
2. Gestion du pointeur de données (SI) : Le registre SI est utilisé pour parcourir un tableau en mémoire. Il faut obligatoirement une instruction qui lit la valeur pointée par [SI] pour la placer dans un registre de travail. En observant l'instruction qui succède directement au blanc n°2, on s'aperçoit que le registre AH est utilisé (le contenu de AH est manipulé ou transféré vers AL). Le registre de destination de la lecture mémoire est donc AH.

La réponse finale est :

• INSTRUCTION 1 : PUSH CX
• INSTRUCTION 2 : MOV AH, [SI]
• INSTRUCTION 3 : POP CX

Méthode

Face à une épreuve d'architecture et de microprocesseurs combinant du langage d'assemblage (8086) et des circuits programmables (8253, 8255) :

1. Décoder minutieusement les mots de contrôle : La majorité des points sur les périphériques s'obtient en traduisant correctement le besoin (ex: "générer un signal carré") en mode de fonctionnement matériel (Mode 3), puis en construisant le mot binaire bit par bit avant de le convertir en hexadécimal. L'erreur la plus courante est l'inversion de l'ordre des bits.
2. Connaître les registres par défaut : En assembleur, certaines instructions opèrent de manière implicite sur des registres très spécifiques (LOOP utilise CX, OUT/IN utilisent AL/AX pour la donnée et DX pour le port, LODSB utilise SI, etc.). Mémorisez ces dépendances.
3. Suivre l'état de la pile (PUSH/POP) : Dans les boucles imbriquées (comme en appelant une interruption d'affichage à l'intérieur d'une conversion de base), la gestion du registre compteur CX via la pile est primordiale. Chaque PUSH doit avoir son POP correspondant dans le même niveau logique d'exécution.
4. Découpage logique (PPI) : Pour le 8255, identifiez toujours en premier ce qui agit comme un capteur (Entrée) et ce qui agit comme un actionneur/afficheur (Sortie) afin de déduire le mot d'initialisation du Mode 0 sans vous tromper.