Les interruptions du microprocesseur

I ) Introduction :

Un  système  à  base  de  microprocesseur  peut  comporter  plusieurs périphériques tels que : un Ecran, une souris, une imprimante, un disque dure, un CNA (convertisseur numérique analogique), un CAN etc ..

Pour  dialoguer  avec  ces  périphériques  le  microprocesseur  a  trois façons de communiquer avec ces derniers :

-     En questionnant de façon continue le périphérique pour vérifier que des données peuvent être lues ou écrites  (Polling).

-     En l'interrompant lorsqu'un périphérique est prêt à lire ou écrire des données (interruption)

-     En établissant une communication directe entre deux périphériques (DMA : Direct memory acces).

I-1/ Le polling :

Bien que le polling soit une façon simple d'accéder à un périphérique , le débit des données dans un périphérique est parfois beaucoup plus lent que la vitesse de fonctionnement d'un processeur , et le polling peut donc être très inefficace . On lui préfère en général la méthode par interruptions.

I-2 ) Le DMA :

En  cas  de  transfert  de  données  de  grande  quantité  entre  deux périphériques, il peut être plus efficace de laisser communiquer entre eux les deux  périphériques  plutôt  que  de  solliciter  le  processeur.  Ce  type  de communication avec les entrées/sorties s'appelle gestion de transfert par DMA,  Le  processeur  indique  au  contrôleur  de  DMA  quels  sont  les périphériques  qui  doivent  communiquer,  le  nombre  et    éventuellement l'adresse des données à transférer, puis il initie  le transfert. Le processeur n'est  pas  sollicité  durant  le  transfert,  et  une  interruption  signale  au processeur la fin du transfert.

I-3 ) L'interruption :

Il arrive fréquemment qu'un périphérique ou un programme nécessite une  intervention  du  microprocesseur  à  cet  effet  il  est  possible  de l'interrompre quelques instants, celui-ci va effectuer l'instruction demandée, est exécuter, une fois qu'elle rend le travail initial.

Ce  mode  d'échange  est  principalement  basé  sur  l'initiative  du périphérique. Grâce à ce mécanisme d'interruption, le dispositif périphérique prend l'initiative de l'échange.

Une interruption est un évènement qui provoque l'arrêt du programme en  cours  et  provoque  le  branchement  du  microprocesseur  à  un  sous- programme particulier dit de "traitement de l'interruption".

Remarque 1 : (ordre de priorité)

Lorsque un périphérique reçoit des données pour le processeur, il envoie  au  processeur  un  signal d'interruption.  Si  celui-ci  peut  être interrompu ( à condition qu'il ne soit pas en train de communiquer avec un périphérique de plus haute priorité) , il stoppe la tâche en cours , sauve son état  (  ces  registres)  en  mémoire  (la  zone  pile  )  et  appelle  la  routine correspondant au numéro d'interruption .

Remarque 2 : (plusieurs interruptions):

Le fonctionnement des périphériques se fait en général d'une manière asynchrone, donc plusieurs interruptions peuvent être déclenchées en même temps, il existe souvent un contrôleur d'interruptions destiné à gérer les conflits entre interruptions

II ) Interruption matérielle et logicielle :

II-1 ) Interruption Matériel :

II-1-1 ) Introduction

Une interruption est signalée au processeur par un signal électrique sur une borne spéciale. Lors de la réception de ce signal, le processeur (traite) l'interruption dès la fin de l'instruction qu'il était en train d'exécuter. Le traitement de l'interruption consiste soit :

- à l'ignorer et passer normalement à l'instruction suivante : c'est possible uniquement    pour    certaines    interruptions, nommées interruptions masquables.  Il  est  en  effet  parfois  nécessaire  de  pouvoir  ignorer  les interruptions pendant un certains temps, pour effectuer des traitements très urgents  par  exemple.  Lorsque  le  traitement  est  terminé,  le  processeur démasque les interruptions et les prend alors en compte.

-     à exécuter un  traitant d'interruption  (interrupt handler). Un traitant d'interruption  est  un  programme  qui  est  appelé  automatiquement lorsqu'une interruption survient. L'adresse de début du traitant est donnée  par  la  table  des vecteurs  d'interruptions  (voir  paragraphe suivant ) . Lorsque le (programme d'interruption) traitant a effectué son travail, il exécute l'instruction spéciale IRET qui permet de reprendre l'exécution à l'endroit où elle avait été interrompue.

II-1-2 ) Cas du processeur 8086 :

Le    microprocesseur    8086    possède    trois    lignes    principales d'interruption : INTR, NMI, et RESET

Ces trois entrées permettent l'arrivée d'une demande (interruption externe) extérieur.

Remarque : Contrôleur d'interruptions dans un PC

L'ordinateur est relié à plusieurs périphériques, mais nous venons de voir qu'il n'y avait qu'un seul signal de demande d'interruption, INTR. Le contrôleur d'interruptions  est un circuit spécial, extérieur au processeur, dont  le  rôle  est  de  distribuer  et  de  mettre  en  attente  les  demandes d'interruptions provenant des différents périphériques.

Le contrôleur d'interruptions (PIC : Programmable Interruption Controler)

La figure précédente  indique les connexions entre le microprocesseur et le contrôleur d'interruptions.

Le contrôleur est relié aux interfaces gérant les périphériques par les bornes IRQ (InteRrupt reQuest). Il gère les demandes d'interruption envoyées par les périphériques, de façon à les envoyer une par une au processeur (via INTR). Il est possible de programmer le contrôleur pour affecter des priorités différentes à chaque périphérique. Avant d'envoyer l'interruption suivante, le contrôleur attend d'avoir reçu le signal INTA, indiquant que le processeur a bien traité l'interruption en cours.

A ) NMI  : (No masquable interrupt )

Une interruption est dite non masquable signifie qu'elle doit toujours être reconnue par le microprocesseur dés que le signal électrique a été déclenché.

Remarque :

La reconnaissance de l'interruption NMI est généralement à la fin du cycle de l'instruction en cours, or les instructions du 8086 peuvent exiger un temps d'exécution plus ou moins long selon le nombre de cycles machines  (comme  l'instruction  de  multiplication)  donc  le  temps  de réponse va dépendre de l'instruction en cours. Ce temps est appelé temps de prise en charge de l'interruption.

Pendant la demande d'une interruption NMI tous les indicateurs sont empilés pour sauvegarder leurs valeurs en cours, puis l'indicateur IF (indicateur d'autorisation d'interruption : Interruption Flag) est mis à zéro (ce qui interdit toute arrivée de demande d'interruption sur la ligne INTR. Ensuite l'indicateur TF est mis à zéro (Trap Flag : indicateur pas à pas), puis le microprocesseur empile les registres CS et IP dans la pile. Enfin le microprocesseur charge le registre IP avec la valeur à 16 bits qui se trouve à l'adresse mémoire 00008H dans le vecteur d'interruption (voir figure suivante), et le registre CS sera ensuite chargé avec la valeur de 16 bits  située  à  l'adresse  0000AH,  donc  le  microprocesseur  maintenant pointe sur le programme d'interruption qu'il va exécuter puis revenir à son programme principal.

Remarque : (Le vecteur d'interruption)

Nommer  aussi  table  d'interruption,  il  contient  toujours  les adresses des programmes d'interruptions aux quels le microprocesseur doit se brancher. Le microprocesseur se branche toujours à l'adresse 4 * n et 4 * n +1 pour chercher le contenu sur 16 bits du CS Si on demande l'interruption INT n.

Déroulement d'une interruption externe masquable (exemple dans un PC) :

Reprenons  les  différents  évènements  liés  à  la  réception  d'une interruption masquable :

1. Un signal INT est émis par un périphérique (ou par l'interface gérant celui- ci).

2. Le contrôleur d'interruptions reçoit ce signal sur une de ses bornes IRQi. Dès que cela est possible (suivant les autres interruptions en attente de traitement), le contrôleur envoie un signal sur sa borne INT.

3. Le microprocesseur prend en compte le signal sur sa borne INTR après avoir  achevé  l'exécution  de  l'instruction  en  cours  (ce  qui  peut  prendre quelques cycles d'horloge). Si l'indicateur IF=0, le signal est ignoré, sinon, la demande d'interruption est acceptée.

4. Si la demande est acceptée, le microprocesseur met sa sortie INTA au niveau 0 pendant 2 cycles d'horloge, pour indiquer au contrôleur qu'il prend en compte sa demande.

5. En réponse, le contrôleur d'interruption place le numéro de l'interruption associé à la borne IRQi sur le bus de données.

6. Le processeur lit le numéro de l'interruption sur le bus de données et l'utilise pour trouver le vecteur d'interruption. Ensuite, tout se passe comme pour un appel système c'est à dire que le processeur :

(a) sauvegarde les indicateurs du registre d'état sur la pile ;

(b) met l'indicateur IF à 0 (masque les interruptions suivantes) ;

(c) sauvegarde CS et IP sur la pile ;

(d) cherche dans la table des vecteurs d'interruptions l'adresse du traitant d'interruption, qu'il charge dans CS:IP.

7. La procédure traitant l'interruption se déroule. Pendant ce temps, les interruptions sont masquées (IF=0). Si le traitement est long, on peut dans certains cas ré-autoriser les interruptions avec l'instruction STI.

8. La procédure se termine par l'instruction IRET, qui restaure CS, IP et les indicateurs à partir de la pile, ce qui permet de reprendre le programme qui avait été interrompu.

II-2 ) Interruption logiciel :

Les   interruptions   logicielles   sont   semblables   aux   interruptions matérielles.  L'unique  différence  réside  dans  le  fait  que  les  interruptions logicielles sont émises par des programmes. Les cinq premières interruptions sont définies par Intel. Les autres interruptions sont définies par le DOS et le BIOS. Ces interruptions ont une fonction définie, par exemple la lecture et l'écriture sur le disque, l'écriture des données à l'écran, etc. Contrairement  à  l'entrée  INTR  du  microprocesseur,  l'interruption logicielle ne peut être ni invalidé ni masquée.

Exemple d'interruption software :

Fonctions BIOS :

Int 1Ah, Fct 02h  Date et heure : Lecture de l'horloge temps réel BIOS (> AT) : Cette fonction permet de lire l'heure de l'horloge temps réel alimentée par batterie. Comme ce type d'horloge n'existe que sur les AT, seul ce modèle de PC soutient cette fonction.

Entrée :

AH    = 02h

Sortie :

Flag Carry =0 : Tout va bien, dans ce cas

                  CH = Heures

                  CL = Minutes

                  DH = Secondes

Flag Carry =1 : La batterie de l'horloge est déchargée

Remarques :

-        Toutes les indications sont fournies en format BCD.

-        Le  contenu  des  registres  BX,  SI,  DI,  BP  et  des  registres  de segment n'est pas modifié par cette fonction. Le contenu de tous les autres registres peut avoir été modifié.

Fonction DOS :Int 21h, Fct 06h    Entrée/sortie directe de caractère :

Cette fonction permet de sortir des caractères sur le périphérique de sortie standard ou de les lire sur le périphérique d'entrée standard. Le caractère  reçu  ou  écrit  chaque  fois  n'est  pas  examiné  par  le  système d'exploitation. Rien de particulier ne se produit donc lorsqu'un caractère Ctrl-C apparaît. Comme l'entrée et la sortie standard peuvent être redirigées sur d'autres périphériques ou vers un fichier, les caractères sortis ne doivent pas nécessairement apparaître sur l'écran ni les caractères lus provenir obligatoirement du clavier. Toutefois, lorsque l'accès se fait sur un fichier, il est impossible pour le programme d'appel de détecter si tous les caractères de ce fichier ont déjà été lus ou bien si le support (disquette, disque dur) sur lequel figure ce fichier est déjà plein. Pour l'entrée d'un caractère, la fonction n'attend pas qu'un caractère soit prêt mais revient immédiatement au programme d'appel dans tous les cas.

Entrée :

AH  = 06h
DL  = 0 - 254 : Sortir ce caractère 
DL  = 255 : Lire un caractère Sortie :
Pour la sortie de caractères : aucune
Pour l'entrée de caractères :
Flag Zéro =1 : aucun caractère n'est prêt
Flag Zéro =0 : Le caractère entré figure dans le registre AL

Remarques :

                Lorsque  des  codes  étendus  sont  lus,  le  code  0  est  tout  d'abord renvoyé dans le registre AL. La fonction doit être appelée à nouveau pour lire le code étendu lui-même.

- Le caractère de code ASCII 255 ne peut être sorti à l'aide de cette fonction puisqu'il est interprété comme d'entrée d'un caractère.

- Le contenu des registres AH, BX, CX, DX, SI, DI, BP, CS, DS, SS, ES et du registre de flags n'est pas modifié par cette fonction.

Exemple de programme : lecture et affichage d'un caractère sur

l'écran :

CODE SEGMENT ASSSUME CS :CODE PROG PROC
DEBUT :        
MOV  AH,06H             ; préparer l'interruption de lecture d'un
MOV  DL,255              ; caractère
INT 21H
JZ DEBUT                   ; si le bit ZF = 0 => aucune touche n'est appuyée
MOV DL,AL                ; afficher le caractère appuyer .
INT 21H
MOV AX,4C00H          ; retour au DOS
INT 21H PROG ENDP
CODE ENDS
END PROG

Int 21h, Fct 09h    Sortie d'une chaîne de caractères

                Cette  fonction  permet  de  sortir  une  chaîne  de  caractères  sur  le périphérique de sortie standard. Comme ce périphérique standard peut être redirigé  sur  un  autre  périphérique  ou  vers  un  fichier,  il  n'y  a  aucune garantie que la chaîne de caractères apparaisse sur l'écran. Si la sortie est redirigée sur un fichier, le programme d'appel n'a aucune possibilité de détecter si le support (disquette, disque dur) sur lequel figure le fichier est déjà  plein,  autrement  dit  s'il  est  encore  possible  d'écrire  la  chaîne  de caractères dans le fichier.

Entrée :

AH   = 09h

DS     = Adresse de segment de la chaîne de caractères DX            = Adresse d'offset de la chaîne de caractères

Sortie : Aucune

Exemple : affichage d'un message sur l'écran :

DONNEE SEGEMENT
MESSAGE   DB  ‘ BONJOUR ISET DE NABEUL $',13,10
DONNEE ENDS
CODE SEGMENT
ASSUME   CS : CODE , DS : DONNEE
PROG PROC
MOV AX , DONNEE MOV DS , AX
LEA DX , MESSAGE   ; Pointé le message par DX MOV AH , 09H
INT 21H                      ; afficher le message
MOV AX,4C00H          ; Retour au DOS
INT 21H
PROG ENDP CODE ENDS END PROG

Remarques :

                  La chaîne de caractères doit être stockée dans la mémoire sous forme d'une séquence d'octets correspondant aux codes ASCII des caractères composant la chaîne. La fin de la chaîne de caractères doit être signalée au DOS à l'aide d'un caractère "$" (code ASCII 36).

-  Si  la  chaîne  de  caractères  contient  des  codes  de  commande  comme Backspace, Carriage Return ou Line Feed, ceux-ci seront traités comme tels.

- Seul le contenu du registre AL est modifié par l'appel de cette fonction. Exemple de programme utilisons les interruptions : affichage de l'heure d'un PC :

;********************************************************************************
;********************************************************************************
;****************** Programme affichage de l'heur du PC *************************
;********************************************************************************
;********************************************************************************
code segment assume cs:code
;*********************** programme principal ************************************
prog proc debut: mov ah,02
int 1aH                ; interruption qui permet de lire l'heur du PC
mov bl,ch             ; ch = heure
call affiche        ; afficher les heurs
 mov bl,cl            ; cl=minute
call affiche         ; afficher les minutes
mov bl,dh              ; dh=seconde
call affiche            ; afficher les secondes
prog endp             ; fin de la procédure principale 
mov dl,13             ; retour chariot
mov ah,06 
int 21h 
jmp debut
affiche  proc       ; procédure d'affichage d'un nombre BCD
mov dl,bl
and dl,0f0h       ; masquer pour avoir les dizaines 
ror dl,1            ; faire une rotation
ror dl,1 
ror dl,1 
ror dl,1
add dl,30h         ; ajouter 30H pour avoir le code ASCII correct 
mov ah,06          ; du chiffre a afficher
int 21h 
mov dl,bl 
and dl,0fh 
add dl,30h 
mov ah,06 
int 21h 
mov dl,':'
mov ah,06
int 21h ret
affiche endp
code ends
end prog

Fonctions Gestionnaire de souris

Int 33h, Fct 00h    Réinitialisation du driver de souris Initialise le driver de souris et enclenche ainsi le test de la souris. Entrée :

AX                             = 0000h

Sortie :

AX                              = FFFFh : dans ce cas, un driver de souris est installé

BX                             = Nombre de boutons de la Souris (à partir de 1.0)

AX                              = 0000h : erreur, aucun driver de souris n'est installé

Remarques :

               L'appel de cette fonction agit sur toute une série de paramètres de la souris qui peuvent être fixés à l'aide des différentes fonctions de la souris :

- Le curseur de la souris est placé au centre de l'écran puis caché. Il apparaîtra désormais en mode graphique sous forme d'une flèche, alors qu'il sera représenté en mode de texte sous forme d'une case de texte en inversion vidéo. Le curseur de la souris est systématiquement affiché dans la page 0 de l'écran, indépendamment du mode. La zone de déplacement sélectionnée est la totalité de l'écran.

-  Les  gestionnaires  d'événements  installés  par  un  programme.  Ils  sont désactivés.

Int 33h, Fct 01h    Afficher le curseur de la souris sur l'écran

Après appel de cette fonction, le curseur de la souris devient visible sur l'écran et suit désormais les déplacements de la souris sur l'écran.

Entrée :

AX                             = 0001h

Sortie :

Aucune

Remarques :

                 L'appel de cette fonction entraîne l'incrémentation d'un compteur interne, en fonction duquel le curseur de la souris est ou non affiché sur l'écran. Si ce compteur contient la valeur 0, le curseur de la souris sera affiché sur l'écran, alors que la valeur -1 a pour effet de le faire disparaître de l'écran. Lorsque la fonction 00h (Reset) est appelée, ce compteur est tout d'abord fixé sur -1, pour prendre ensuite la valeur 0 lors du premier appel de cette fonction, ce qui se traduit par la réapparition du curseur sur l'écran.

Int 33h, Fct 03h    Lire la position de la souris et l'état des boutons de la souris :

            L'appel de cette fonction fournit la position actuelle de la souris et l'état des différents boutons de la souris.

Entrée :

AX                             = 0003h

Sortie :

BX                             = Etat des boutons de la Souris (à partir de 1.0) Bit  Signification

0                                1 = bouton gauche de la souris appuyé

1                                1 = bouton droit de la souris appuyé

2                                1 = bouton central de la souris appuyé

3-15                          Aucune (0)

CX                             = Position horizontale de la Souris (à partir de 1.0) DX = Position verticale de la souris

Remarques :

              Les  ordonnées  renvoyées  dans   les  registres  CX  et DX  ne se rapportent pas à l'écran physique mais aux positions en points écran dans l'écran virtuel de la souris.

              Si la souris ne possède que deux boutons, les informations fournies sur le bouton central sont dépourvues de signification