[Jérémy]

Bonjour à tous ,

Nous voila dans le dur de la programmation . Sujet très important, les INTERRUPTIONS !

Qu'est ce qu'une interruption ??

Une interruption est en fait un sous programme (comme vu ICI) , qui va se déclencher tout seul mais avec nos conditions. J'entends par la , que nous n'allons pas l’appeler, mais qu'elle va s’exécuter toute seule en fonction de certains critères choisis.

Une interruption est ultra rapide car en fait les conditions d’exécution de l'interruption sont vérifiées à chaque cycles . c'est à dire entre deux lignes de code, on vérifie si on doit faire l’interruption ou non ? même pendant une pause.

L'interruption peut se déclencher de plusieurs façons , par soft (débordement d'un Timer par exemple) ou par hard (appui sur un BP par exemple). Dans le premier exemple on surveillera donc le Timer et dans le second cas, la broche d'entrée du BP. Il y a différents critères permettant de déclencher une interruption, suivant le type de PIC utilisé (changement d'état de broches, fin d’écriture en EEPROM, reception UART ...) .

Cette rapidité d'interruption va nous permettre d'effectuer des taches avec une grande précision ou une grande réactivité ( l’arrêt d'une commande d'urgence par exemple) . Une fois l'interruption effectuée , le programme revient la où il s’était arrêté , et continue son petit bonhomme de chemin !.

Pour commencer à utilisé les interruptions il va donc falloir les configurées , pour que le µC sache de quoi il s'agit , ce qu'il doit faire , et à quel moment il doit le faire . Comme il existe plusieurs interruptions par µC, il faudra toujours configurer celle qui nous intéresse.

Nous allons commencer par les autorisées, qu'en pensez vous ?



Pour se faire nous devons configurer le registre prévu à cet effet . Il s’agit du registre INTCON ( pour l'interruption 0). Ce registre comme tout les autres se compose de 8 bits, qu'il faut mettre à 1 ou à 0 suivant la configuration que l'on souhaite. L'explication de chaque bit de configuration est donné dans la Data-Sheet du PIC18F45K22 . Dans notre cas à la page 116.

bit 7 : GIE/GIEH pour Global Interrupt Enable , ce bit autorise ( si mis à 1) toutes les interruptions. s'il est à 0 aucune INT ne pourra être effectuées.
bit 6 : PEIE/GIEL pour Peripheral Interrupt Enable . interruption sur un périphérique extérieur . (pas utile pour le moment)
bit 5 : TMR0IE : TMR0 Overflow Interrupt Enable . Interruption sur le débordement du Timer0 (très intéressant pour les temporisations)
bit 4 : INT0IE : INT0 External Interrupt Enable . Autorise les INT sur les broches du µC, (BP par exemple)
bit 3 : RBIE : Port B Interrupt-On-Change Interrupt Enable . Autorise les INT sur changement d'état d'une broche du Port B

Les 3 derniers bits sont des drapeaux (Flag en anglais) . Ils permettent de déterminer quelle est l'interruption qui à été déclenchée . POURQUOI FAIRE ?

Si vous utilisez plusieurs interruptions, il faut savoir qu"elles seront toutes dans la même fonction. Étant donné quelles sont toutes dans la même fonction il va falloir les distinguer les unes des autres , pour savoir laquelle à été appelées . c'est le rôle de ces flag qui sont mis à 1 quand l'interruption correspondante est déclenchée.

bit 2 : TMR0IF : TMR0 Overflow Interrupt Flag , Ceci est notre drapeau, quand une interruption sur débordement du Timer est enclenché
bit 1 : NT0IF : INT0 External Interrupt Flag Ici , c'est notre drapeau quand il y a eu une INT hard ( extérieur , notre BP par exemple).
bit 0 : RBIF : Port B Interrupt-On-Change Interrupt , Et enfin notre drapeau pour signaler un changement d'état sur une broche du PORT B ( à définir)

Une fois ces drapeaux mis à 1, pour signaler notre INT, il faudra les remettre à 0 , par soft pour ré-armé nos INT . sinon elles ne fonctionneront plus . Le ré-armement du flag ( mise à 0) doit obligatoirement se faire dans l'interruption en question .

Si on prends pour exemple la création d'une temporisation de 1 seconde grâce au Timer0 on configurera notre registre INTCON ainsi :

bit7 : 1 on autorise les Interruptions
bit6 : 0 désactivation des iNT périphériques
bit5 : 1 autorise l'iNT sur débordement du Timer0
bit4 : 0 désactivation des INT extérieurs
bit3 : 0 désactivation sur changement d'état
bit2 : 0 mise à 0 de notre flag pour "armer" notre INT
bit1 : 0 non utilisé
bit0 : 0 non utilisé

Ce qui nous donne :

Code : Tout sélectionner

INTCON = 0b10100000        // en binaire
ou
INTCON = 160            // en décimal
ou encore
INTCON = 0xA0            // en hexa           

Perso j'utilise le binaire dans ce cas la , car j'ai un meilleur visu de l’état des bits du registres.

Voila Notre interruption est "armée" et prête . Le résultat en sera qu'a chaque débordement du Timer0 le sous-programme d'interruption aura lieu .

Code : Tout sélectionner

//#################################       DECLARATION      #########################################

//    Ici vos déclarations de variables ou constantes

//#################################        FONCTION       #########################################

void interrupt() {            // Votre fonction d’interruption est appelée ainsi

  if (INTCON.TMR0IF == 1) {        // Ici on test pour savoir quel flag à été mis à 1 , et donc savoir de quel interruptions il s'agit .
                                      // dans notre exemple on test le bit TMR0IF vous savez le bit 2 du registre INTCON vu un peu plus haut dans le Tuto
                                  // je rappelle qu'on peut écrire aussi  if (INTCON.TMR0IF) quand vous aurez l'habitude
    Ici les taches a effectuer    // Ici on exécute notre routine d’interruption . ceci doit être le plus succinct possible. car il faut vite "ré-armer" notre INT.
    
    INTCON.TMR0IF = 0;            // NE PAS OUBLIER DE RE-ARMER NOTRE INTERRUPTION , on remet le flag à 0 pour une nouvelle détection.
  }
}

//#########################     FONCTION PRINCIPALE ET CONFIGURATION    #################################

void main() {           // ceci contiendra notre programme, c'est la fonction principale(main) et elle est obligatoire.

                        // Ici vos différentes configurations
     
     INTCON = 0b10100000;    // On configure nos INT
     
     
 //#################################     Boucle infinie    #########################################

 while(1)                 // Ici c'est notre boucle sans fin.
 {
      
      Ici votre programme        // votre programme qui boucle normalement , vous pouvez même laissé vide , si tout ce passe dans votre interruption.

  }
 }

Conseils :

- Les débordement est le fait qu'une variable passe de 255 à 0 ( 255 + 1 = 256 = 0) ou en hexa de 0xFF à 0x00 . il en va de même de un INT sur 2 octets , de 65535 à 0.

- La fonction d'interruption doit être aussi courte que possible , sinon il se pourrait quelle passe au travers d'autres interruptions ; En exagérant exprès , disons que vous faites une tempo de 1seconde . si votre traitement d'interruption dure plus que 1 seconde . alors vous louperez une interruption étant donné que vous êtes encore dans la routine de l’interruption quand une autre surviens.

- Il faut savoir que quand vous êtes dans une interruption le bit GIE est mis automatiquement à 0 , désactivant la possibilité d'autres interruptions. il est remis automatiquement à 1, à la sortie de l’interruption pas besoin de vous en souciez !

Pour le moment nous en resterons la pour les interruptions !
Dans le Tuto suivant nous utiliserons ces interruptions, afin de les voir dans un cas concret !

n’hésitez à poster si vous avez des questions, ou si un point vous parait peu clair .