Chapitre 1 1

interruptions

CHAPITRE 1

INTERRUPTIONS

1. PRƒSENTATION
En lÕabsence dÕinterruptions, les Le mŽcanisme des interruptions permet ˆ un processeur de rŽagir ˆ un en-
pŽriphŽriques nÕont jamais la
parole. Il ne peuvent rien signaler semble dÕŽvŽnements sans pour autant surveiller par programme leur ap-
au MCU qui doit les interroger parition. Une interruption est un ŽvŽnement capable dÕinterrompre le
(on parle de scrutation ou polling) dŽroulement dÕun programme pour exŽcuter immŽdiatement et automati-
pour dŽtecter un Žtat ou un
Žv•nement particulier. Gr‰ce aux quement une routine de service en rŽponse ˆ cet ŽvŽnement. La routine de
interruptions, les pŽriphŽriques service est une routine assembleur ou une fonction C qui diff•re dÕune rou-
ont la parole. Ils peuvent
rŽclamer lÕattention du MCU. tine ou dÕune fonction classique par le fait quÕelle nÕest jamais appelŽe par
une autre fonction ou routine mais dŽclenchŽe par un Žv•nement gŽnŽrale-
ment matŽriel. LÕexŽcution dÕun programme en cours est interrompu par la
routine de service. Cette derni•re doit donc commencer par sauvegarder
void main (void){
) ... lÕŽtat du processeur dans la pile et se terminer en restaurant cet Žtat avant
)
)
initialise_IT();
...
de reprendre le dŽroulement du programme interrompu.
) // Un
) // programme
) // normal
) ...
IRQ A
interrupt A
void A_isr (void){
2. ABRƒVIATIONS
...
}
2.1 LiŽes aux interruptions
) ...
IRQ B IT : Interrupt : Interruption
interrupt B ISR : Interrupt Service Routine : Routine de service dÕinterruption.
void B_isr (void){
... IRQ : Interrupt Request : Requ•te (demande) dÕinterruption.
}
IACK : Interrupt Acknowledge : AccusŽ de rŽception dÕune IRQ.
) … NMI : Non-Maskable Interrupt : Interruption non masquable
})
IF : Interrupt Flag : Bit signalant une requ•te dÕinterruption.
IE : Interrupt Enable : Bit programmŽ pour autoriser/inhiber une interrup-
tion.

2.2 Autres abrŽviations utilisŽes

CPU : Central Processing Unit : Processeur, le coeur du microprocesseur
ou microcontroleur.
MCU : Microcontroller: Microcontr™leur
MPU : Microprocessing Unit : Microprocesseur

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
2 Trois types dÕinterruption

RTOS : Real Time Operating System : Noyau temps rŽel multit‰che.

BIOS : Basic Input / Output System : Couche logicielle pour les pŽriphŽri-
ques dÕentrŽe/sortie.
UART : Universal Asychronous Receiver Transmitter : Liaison sŽrie asyn-
chrone.
BUS SPI : Serial Peripheral Interface : Liaison sŽrie synchrone, inventŽ
par Motorola
BUS IIC ou I2C : Inter Integrated Circuit : Bus sŽrie avec adressage, in-
ventŽ par Phillips
CAN : Car Area Network : RŽseau de terrain industriel dŽdiŽ ˆ lÕautomo-
bile, inventŽ par Bosh.
ADC : Analog to Digital Converter : Convertisseur Analogique NumŽri-
que (CAN1 en fran•ais)
DAC : Digital to Analog Converter : Convertisseur NumŽrique Analogi-
que (CNA en fran•ais)
FIFO : First In Fisrt Out : File dÕattente (le contraire dÕune pile).

3. TROIS TYPES DÕINTERRUPTION

On peut distinguer les trois classes dÕinterruption suivantes, prŽsentŽes
dans lÕordre de prioritŽ dŽcroissante : les erreurs, les interruptions matŽ-
rielles et les interruptions logicielles.

3.1 Erreurs
Au minimum, tous les MCU ou Au cours de lÕexŽcution dÕun programme, diffŽrentes erreurs matŽrielles
MPU doivent rŽpondre ˆ
lÕinterruption RESET qui est bien ou logicielles peuvent survenir. LÕapparition de certaines erreurs peut •tre
sžr la plus prioritaire. En ce sens considŽrŽe comme une interruption et dŽclencher lÕexŽcution dÕune routi-
elle peut-•tre considŽrŽe comme ne de service.
une erreur. Son ISR est le
programme de dŽmarrage. Les erreurs sont matŽrielles telles que lÕacc•s ˆ une adresse invalide ou lo-
gicielles telles que la division par zŽro ou la tentative dÕexŽcution dÕun
code machine ne correspondant ˆ aucune instruction du microprocesseur.

3.2 Interruptions matŽrielles

LÕessentiel des interruptions provient des pŽriphŽriques.
Les pŽriphŽriques transmettent au microprocesseur des informations de
synchronisation de fa•on asynchrones. Ces ŽvŽnements peuvent •tre dŽtec-
tŽs par scrutation ou dŽclencher lÕexŽcution dÕune routine de service par in-
terruption.
Parmi tous les pŽriphŽriques des microcontr™leurs, la plupart sont suscep-
tibles de dŽclencher une interruption. Les pŽriphŽriques de communication
(RS232, SPI, CAN, I2C,...) signalent soit lÕarrivŽe dÕune donnŽe, cÕest ˆ
dire un registre de rŽception plein quÕune ISR doit venir lire, soit la fin de
lÕŽmission dÕune donnŽe en sortie, cÕest ˆ dire un registre dÕŽmission vide
quÕune ISR peut ˆ nouveau Žcrire. Ils peuvent aussi signaler une erreur, par
exemple la perte dÕune donnŽe ou une erreur de paritŽ lors dÕune transmis-

1. A ne pas confondre avec le rŽseau CAN citŽ plus haut.

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
 Chapitre 1 3
interruptions

sion. De m•me, les convertisseurs analogique-numŽrique dŽclenchent des

interruptions de fin de conversion pour signaler quÕune donnŽe convertie
peut •tre lue dans son registre de donnŽe. Certains ports dÕentrŽe peuvent
dŽclencher des interruptions sur dŽtection dÕun niveau ou dÕun front. Ces
ports peuvent •tre associŽs ˆ des circuits pŽriphŽriques externes au MCU
ou tout simplement ˆ un capteur binaire ou un bouton poussoir. Enfin, les
compteurs peuvent dŽclencher des interruptions pŽriodiquement lorsquÕun
compteur atteint une valeur de rŽfŽrence ou quand il dŽborde.

3.3 Interruptions logicielles

LorsquÕun programme dŽclenche de mani•re volontaire lÕexŽcution dÕune
routine de service on parle dÕune interruption logicielle. Le dŽclenchement
de ces routines passent par des instructions assembleurs particuli•res
(traps) qui dŽclenchent lÕexŽcution des routines de service comme sÕil
sÕagissait dÕune interruption matŽrielle.
Cette possibilitŽ est principalement utilisŽe pour les appels syst•me, cÕest
ˆ dire au noyau du syst•me dÕexploitation. Une routine dÕinterruption
sÕexŽcute gŽnŽralement dans un mode particulier, appelŽ superviseur qui
autorise lÕacc•s ˆ toutes les ressources du microprocesseur. LÕensemble
des routines dÕinterruptions forme lÕinterface entre le logiciel et le matŽ-
riel. Sur un PC, cette couche logicielle sÕappelle le BIOS (Basic Input/Out-
put System). Pour un syst•me ˆ base de MCU, souvent sans OS, les
interruptions logicielles sont peu utilisŽes.

4. VECTEURS DÕINTERRUPTION
Dans chaque microcontr™leur, il existe un contr™leur dÕinterruption qui
permet dÕinhiber ou dÕautoriser chaque interruption individuellement ou
collectivement. Il doit Žgalement exister un mŽcanisme permettant dÕasso-
cier une ISR ˆ chaque source dÕinterruption. Suivant le type de microcon-
tr™leur, le programmeur ˆ plus ou moins de libertŽ sur la place que peut
occuper une ISR en mŽmoire. LÕadresse ˆ laquelle le CPU se dŽroute lors
dÕune interruption est appelŽe le vecteur dÕinterruption.

4.1 Vecteurs ˆ adresses figŽs ou table de vecteur dÕinterruption

Dans les microprocesseurs simples, le constructeur fixe pour chaque sour-
ce dÕinterruption le vecteur dÕinterruption. Comme il est impossible au
constructeur de prŽvoir la taille de la routine de service, la place laissŽe
pour une interruption est au moins suffisante pour y coder une instruction
de saut vers le corps de lÕISR qui pourra •tre nÕimporte o• dans la mŽ-
moire. Cette technique est utilisŽe par les microcontr™leurs PIC de Micro-
chip et la famille 8051. Comme nous le verrons plus loin, ce nÕest pas le
cas de Motorola qui a choisi dÕutiliser une partie de la mŽmoire comme ta-
ble de vecteurs dÕinterruption o• le programmeur viendra Žcrire ses vec-
teurs.

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
4 Vecteurs dÕinterruption

...Memory... ...Memory...

interrupt A interrupt A
void A_ISR (void ) void A_ISR (void )
{ {
...Memory... ...Memory...
) É ) É
Vector Table } IT Vectors }

A_ISR jmp A_ISR

interrupt B interrupt B
B_ISR jmp B_ISR
void B_ISR (void ) void B_ISR (void )
C_ISR { jmp C_ISR {
) É ) É
} }

interrupt C interrupt C
void C_ISR (void ) void C_ISR (void )
{ {
) É ) É
} }

Figure 1 : A gauche, un MCU utilisant une table de vecteur

dÕinterruption contenant les pointeurs sur les ISR, ˆ droite
un MCU sans table de vecteurs contenant ˆ la place des ins-
truction de saut (JUMP) vers les ISR.

4.1.1 Le cas du PIC

En dehors du vecteur RESET ˆ lÕadresse 0x0000, les microcontr™leurs Mi-
crochip de la famille PIC 16F8XX ont 15 sources dÕinterruptions mais
nÕont quÕun seul vecteur dÕinterruption, qui est lÕadresse 0x0004, pour rŽ-
pondre ˆ toutes ces 15 interruptions.

TABLEAU 1. Les 15 sources dÕinterruption du PIC 16F8xx

Nû Source dÕinterruption
1 Front sur le port B
2 externe
3 timer0 overflow
4 timer1 overflow
5 timer2 overflow
6 fin de conversion A/N
7 évènement capture / compare 1
8 évènement capture / compare 2
9 Fin d’écriture sur l’EEPROM
10 Port parallèle esclave
11 SPI
12 conflit de bus
13 Rx UART

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
 Chapitre 1 5
interruptions

TABLEAU 1. Les 15 sources dÕinterruption du PIC 16F8xx

Nû Source dÕinterruption
14 Tx UART
15 Alimentation faible

Dans ce cas, lÕISR doit faire le tri. Si plusieurs interruptions sont autorisŽes,
la routine dÕinterruption doit dŽterminer la source qui a dŽclenchŽ lÕinter-
ruption pour y rŽpondre. On peut noter que les outils de dŽveloppement en
langage C (PCW de CCS par exemple) peuvent masquer le manque de vec-
teurs en gŽnŽrant automatiquement le code nŽcessaire ˆ la dŽtection de la
source dÕinterruptions (cf. listing 1 et 2). Cela peut faire croire aux dŽve-
loppeurs quÕils existent plusieurs vecteurs, ce qui nÕest pas le cas. Le com-
pilateur gŽn•re Žgalement les instructions de sauvegarde et restauration du
contexte, ce qui nÕest pas trivial sur ce microcontr™leur sans pile et dont la
mŽmoire est paginŽe. Le revers de la mŽdaille est quÕune telle interruption
exŽcute au minimum 60 instructions, ce qui peut durer 60 µs sur un PIC
cadencŽ ˆ 4 MHz. CÕest au moins 30 fois plus long que la plupart des autres
MCU.

Le compilateur permet de dŽÞnir

plusieurs ISR ce qui donne
lÕillusion quÕils existent plusieurs
vecteurs. Ce nÕest pas le cas.
Listing 1: Programme dÕinterruption avec les outils PCW de CCS pour les PIC 16F877 de
Microchip
1 #int_timer1
2 timer1_isr() {
3 ...
4 }
5 #int_lowvolt
6 lowvolt_isr() {
7 ...
8 }
9 void main() {
10 . . .
11 . . .
12 enable_interrupts(INT_TIMER1);
13 enable_interrupts(INT_LOWVOLT);
14 enable_interrupts(global);
15 while(1);
16 }

Voici le code assembleur gŽnŽrŽ :

La simplicitŽ du PIC qui nÕa quÕun .

vecteur cožte cher. Environ 60
instructions sont exŽcutŽes dans
une ISR minimale et lÕISR en
assembleur est un vrai dŽdale. Listing 2: Extrait du code assembleur gŽnŽrŽ
1 0000: MOVLW 00 <- VECTEUR RESET ...
2 0001: MOVWF 0A
3 0002: GOTO 056 ... aller au MAIN )
4 0003: NOP
5 0004: MOVWF 7F <- VECTEUR DÕINTERRUPTION ...
6 0005: SWAPF 03,W ... Sauvegarder le contexte ...
... [... 13 instructions ...]

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
6 Vecteurs dÕinterruption

Listing 2: Extrait du code assembleur gŽnŽrŽ

7 001C: BTFSC 0B.2 ... Si cÕest une IT RTCC_...
8 001D: GOTO 037 ... aller vers pŽparation RTCC_isr ...
... [... 4 instructions ...]
9 0022: BTFSC 0D.7 ... Si cÕest une IT LOWVOLT ...
10 0023: GOTO 03A ... Aller vers prŽparation LOWVOLT_isr
...
11 0024: MOVF 22,W <- restauration du contexte
... ... 17 instructions ...
12 0036: RETFIE ... RETOUR DÕINTERRUPTION
13 0037: BCF 0A.3
14 0038: BCF 0A.4
15 0039: GOTO 03D ... aller en RTCC_isr
16 003A: BCF 0A.3
17 003B: BCF 0A.4
18 003C: GOTO 052 ... aller en LOWVOLT_isr
19
20 .................... #int_RTCC
21 .................... RTCC_isr() {
22 003D: MOVLW 00
[ ... ] ... ...
23 0051: GOTO 024 ... Aller ˆ restauration du contexte
24 .................... #int_LOWVOLT
25 .................... LOWVOLT_isr() {
26 .................... /* ... */
27 0052: BCF 0D.7
[ ... ] ... ...
28 0055: GOTO 024 ... Aller ˆ restauration du contexte
29 .................... }
30
31 .................... void main() {
32 ...

4.1.2 Le cas du 8051 dÕIntel

Dans le 8051 il y a 5 (6 pour le 8052) sources dÕinterruption et autant de
vecteurs situŽs sur les adresses basses. Les outils de dŽveloppement en C
tel que le compilateur KEIL gŽn•rent automatiquement lÕinstruction de
saut vers la routine de service LJMP et la sauvegarde/restauration du con-
texte.

Le 8051 poss•de plusieurs bancs

de registres et peut basculer dÕun
banc ˆ lÕautre pour les
interruptions. Cela se traduit par
le mot clŽ using pour ce Listing 3: Programmation des interruption avec les outils KEIL pour les 8051
compilateur. 1 #include <reg51.h> /* define 8051 registers */
2 #include <stdio.h> /* define I/O functions */
3 sbit P3_0=P3^0;
4 void isr_timer(void) interrupt 1 using 2{
5 P3_0=~P3_0; /* Toggle PORT 3 bit 0 */
6 }
7
8 void main (void) {
9 while (1) ;
10 }

Le programme du listing 3 produit le code assembleur du listing 4.

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
 Chapitre 1 7
interruptions

On retrouve le saut ˆ lÕadresse

de lÕISR (ligne 2). Le corps de
lÕISR elle m•me (ligne 4 ˆ 7) est
limpide comparŽe ˆ celle du PIC.
Listing 4: Programme assembleur gŽnŽrŽ.
1 CSEG AT 0000BH
2 LJMP isr_timer
3 ...
4 USING 2
5 isr_timer:
6 CPL P3_0
7 RETI

4.2 Table de vecteurs dÕinterruption

Dans les microcontr™leur plus ŽvoluŽs, le constructeur prŽvoit une table
dans laquelle le programmeur doit placer les adresses (les vecteurs) de ses
routines de service. En fonction de la source dÕinterruption, le microcon-
tr™leur vient automatiquement lire dans cette table pour se brancher sur la
bonne ISR. La table des vecteurs dÕinterruption correspond en C ˆ une ta-
ble de pointeurs sur fonction. Les ŽlŽments de cette table sont les vec-
teurs (pointeurs sur fonction) et lÕindice dans la table sÕappelle un numŽro
de vecteur.

HC12
IRQ1 2
IT Controller
1 PTH0 3

PIEH
PIFH
CCR

4
vector
= 25

25 5
Table Vect.
Num IT. vectors 7 interrupt 25
6 25 0010 01B0
64 0010 01C4
void bouton_isr(void){
É
}

Figure 2 : : Principe dÕune interruptions vectorisŽes sur

HC12.
Lorsque le bouton est enfoncŽ (1), lÕentrŽe PTH0 est amenŽe
ˆ au niveau L (2) qui est son niveau actif. Ceci signale une
requ•te dÕinterruption. Elle est enregistrŽe par le contr™leur
dÕinterruption (3). Elle devient une interruption en attente
(pending interrupt), ce qui se traduit par un indicateur IF
(interrupt Flag) qui passe ˆ lÕŽtat 1, ici dans le registre PI-
FH. Si cette interruption est individuellement autorisŽe par
un bit IE (Interrupt Enable) dans le registre PIEH et que les
interruptions ne sont pas globalement inhibŽes par le bit I du
registre dÕŽtat, la requ•te devient une interruption (4). En
fonction de la source de lÕinterruption (ici la broche PTH0
par exemple) le MCU calcul un numŽro de vecteur (5), ici 25.
Ce numŽro sert dÕindex dans la table des vecteurs (6). Le
MCU en extrait le vecteur dÕinterruption (7) qui est lÕadresse
de lÕISR quÕil commence ˆ exŽcuter.

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
8 Vecteurs dÕinterruption

La table des vecteurs dÕinterruption existe dans tous les microcontr™leurs

Motorola dont le 68HC12. La table des vecteurs dÕinterruption du
9S12DP256 utilise lÕespace mŽmoire situŽ entre les adresses FF80 ˆ FFFF.
Il sÕagit dÕune zone de mŽmoire non paginŽe. De m•me, les vecteurs Žtant
codŽs sur 16 bit, les routines dÕinterruptions doivent •tre situŽe dans
une zone mŽmoire non paginŽe.
TABLEAU 2. Table des vecteurs dÕinterruption du HC12

autorisŽe
nû CODE adresse source
localement par
0 RESET_ISR FFFE-FFFF RESET -
1 CLKMONFA FFFC-FFFD CLOCK MONITOR FAIL PLLCTL (CME, SCME)
IL_ISR RESET
2 COP_ISR FFFA-FFFB COP RESET (WATCHDOG COP RATE SELECT
TIMER)
3 UNIMPLTR FFF8-FFF9 UNIMPLEMENTED INSTRUC- -
AP_ISR TION TRAP
4 SWI_ISR FFF6-FFF7 SWI -
5 XIRQ_ISR FFF4-FFF5 XIRQ -
6 IRQ_ISR FFF2-FFF3 IRQ -
7 RTI_ISR FFF0-FFF1 REAL TIME INTERRUPT IRQCR (IRQEN)
(RTI)
8 ECT0_ISR FFEE-FFEF TIMER 0 TIE (C0I)
9 ECT1_ISR FFEC-FFED TIMER 1 TIE (C1I)
10 ECT2_ISR FFEA-FFEB TIMER 2 TIE (C2I)
11 ECT3_ISR FFE8-FFE9 TIMER 3 TIE (C3I)
12 ECT4_ISR FFE6-FFE7 TIMER 4 TIE (C4I)
13 ECT5_ISR FFE4-FFE5 TIMER 5 TIE (C5I)
14 ECT6_ISR FFE2-FFE3 TIMER 6 TIE (C6I)
15 ECT7_ISR FFE0-FFE1 TIMER 7 TIE (C7I)
16 TOF_ISR FFDE-FFDF TIMER OVERFLOW TSCR2 (TOF)
17 PAOV_ISR FFDC-FFDD PULSE ACCUMULATOR A PACTL (PAOVI)
OVERFLOW
18 PA_ISR FFDA-FFDB PULSE ACCUMULATOR A PACTL (PAI)
INPUT EDGE
19 SPI0_ISR FFD8-FFD9 SPI0 SP0CR1 (SPIE,SPTIE)
20 SCI0_ISR FFD6-FFD7 SCI0 SC0CR2
(TIE,TCIE,RIE,ILIE)
21 SCI1_ISR FFD4-FFD5 SCI1 SC1CR2
(TIE,TCIE,RIE,ILIE)
22 ATD0_ISR FFD2-FFD3 ATD0 ATD0CTL2 (ASCIE)
23 ATD1_ISR FFD0-FFD1 ATD1 ATD1CTL2 (ASCIE)
24 PORTJ_ISR FFCE-FFCF PORT J PTJIF (PTJIE)
25 PORTH_IS FFCC-FFCD PORT H PTHIF (PTHIE)
R
26 MCZ_ISR FFCA-FFCB MODULUS DOWN COUNTER MCCTL (MCZI)
UNDERFLOW
27 PBOV_ISR FFC8-FFC9 PULSE ACCUMULATOR B PBCTL (PBOVI)
OVERFOW
28 PLLLOCK_I FFC6-FFC7 CRG PLL LOCK CRGINT (LOCKIE)
SR
29 PLLSCM_IS FFC4-FFC5 CRG SELF CLOCK MODE CRGINT (SCMIE)
R
30 BDLC_ISR FFC2-FFC3 BDLC BLCBCR1 (IE)
31 I2C_ISR FFC0-FFC1 IIC BUS IBCR (IBIE)
32 SPI1_ISR FFBE-FFBF SPI1 SP1CR1 (SPIE,SPTIE)
33 SPI2_ISR FFBC-FFBD SPI2 SP2CR1 (SPIE,SPTIE)

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
 Chapitre 1 9
interruptions

TABLEAU 2. Table des vecteurs dÕinterruption du HC12

autorisŽe
nû CODE adresse source
localement par
34 EEPROM_I FFBA-FFBB EEPROM EECTL (CCIE,CBEIE)
SR
35 FLASH_ISR FFB8-FFB9 FLASH FCTL (CCIE,CBEIE)
36 CAN0WU_I FFB6-FFB7 CAN 0 WAKE UP CAN0RIER (WUPIE)
SR
37 CAN0ERR_ FFB4-FFB5 CAN 0 ERROR CAN0RIER (CSIE,OVRIE)
ISR
38 CAN0RX_IS FFB2-FFB3 CAN 0 RECEIVE CAN0RIER (RXFIE)
R
39 CAN0TX_IS FFB0-FFB1 CAN 0 TRANSMIT CAN0TIER (TXEIE2-
R TXEIE0)
40 CAN1WU_I FFAE-FFAF CAN 1 WAKE UP CAN1RIER (WUPIE)
SR
41 CAN1ERR_ FFAC-FFAD CAN 1 ERROR CAN1RIER (CSIE,OVRIE)
ISR
42 CAN1RX_IS FFAA-FFAB CAN 1 RECEIVE CAN1RIER (RXFIE)
R
43 CAN1TX_IS FFA8-FFA9 CAN 1 TRANSMIT CAN1TIER (TXEIE2-
R TXEIE0)
44 CAN2WU_I FFA6-FFA7 CAN 2 WAKE UP CAN2RIER (WUPIE)
SR
45 CAN2ERR_ FFA4-FFA5 CAN 2 ERROR CAN2RIER (CSIE,OVRIE)
ISR
46 CAN2RX_IS FFA2-FFA3 CAN 2 RECEIVE CAN2RIER (RXFIE)
R
47 CAN2TX_IS FFA0-FFA1 CAN 2 TRANSMIT CAN2TIER (TXEIE2-
R TXEIE0)
48 CAN3WU_I FF9E-FF9F CAN 3 WAKE UP CAN3RIER (WUPIE)
SR
49 CAN3ERR_ FF9C-FF9D CAN 3 ERROR CAN3RIER (CSIE,OVRIE)
ISR
50 CAN3RX_IS FF9A-FF9B CAN 3 RECEIVE CAN3RIER (RXFIE)
R
51 CAN3TX_IS FF98-FF99 CAN 3 TRANSMIT CAN3TIER (TXEIE2-
R TXEIE0)
52 CAN4WU_I FF96-FF97 CAN 4 WAKE UP CAN4RIER (WUPIE)
SR
53 CAN4ERR_ FF94-FF95 CAN 4 ERROR CAN4RIER (CSIE,OVRIE)
ISR
54 CAN4RX_IS FF92-FF93 CAN 4 RECEIVE CAN4RIER (RXFIE)
R
55 CAN4TX_IS FF90-FF91 CAN 4 TRANSMIT CAN4TIER (TXEIE2-
R TXEIE0)
56 PORTP_IS FF8E-FF8F PORT P PTPIF (PTPIE)
R
57 PWMEMSH FF8C-FF8D PWM EMERGENCY SHUT- PWMSDN (PWMIE)
_ISR DOWN
58-63 FF80-FF8B rŽservŽ -

4.3 Interruptions externes vectorisŽes

Finalement, dans les microprocesseurs o• les pŽriphŽriques sont essentiel-
lement des composants externes, le programmeur a m•me le choix du nu-
mŽro de vecteur associŽ ˆ chaque circuit pŽriphŽrique. Ce numŽro se
programme dans un registre du circuit pŽriphŽrique et le microprocesseur
interrompu doit venir lire ce numŽro par un cycle bus particulier appelŽ cy-
cle dÕacquittement dÕinterruption (IACK).

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
10 La pile lors dÕune interruption

Si leur programmation nÕest pas

immŽdiate les interruptions
externes vectorisŽes du 68k/ ColdFire

ColdFire prŽsentent lÕavantage PŽriphŽriqueXX

IRQ1
IT Controller

de la souplesse. Tout est ICR1

IMR
IPR
1 2 IRQ4
programmable y compris les IRQ IRQ7 3 ICR7

numŽros de vecteurs associŽs IACK (CS1)

aux interruptions. Register 4
Vector Num IACK1 vectorisŽe
EN niveau 7
64
7 5
IACK4 7
A[4:2] 25

IACK7 Table Vect.

IACK
Num IT vectors
64 6
64 25 0010 01B0 interrupt XX
D[7:0] D[7:0]
8 9 64 0010 01C4 10 void XX_isr (void){
É
}

Figure 3 : Cycle IACK pour obtenir un numŽro de vecteur

sur un 68k/ColdFire
Au commencement, un pŽriphŽrique "XX " dŽtecte un Žv•ne-
ment quÕil souhaite signaler au MCU par une interruption
(1). Il Žmet donc une requ•te sur sa sortie IRQ qui est re•ue
sur lÕentrŽe, ici IRQ7, du MCU (2). Le requ•te, est enregis-
trŽe par le contr™leur dÕinterruption (3) dans un bit du regis-
tre IPR (Interrupt Pending Register). Si cette interruption est
individuellement autorisŽe dans le registre IMR (Interrupt
Mask Register) et que la prioritŽ de lÕinterruptions est supŽ-
rieure ˆ la prioritŽ du programme en cours, la requ•te de-
vient une interruption (4). En fonction de la source de
lÕinterruption (ici la broche IRQ7 par exemple) le MCU ef-
fectue un cycle de lecture particulier appelŽ cycle dÕacquit-
tement dÕinterruption (IACK pour Interrupt Acknowledge)
avec le niveau de prioritŽ comme adresse, ici 7 (5). Lors de
ce cycle, un signal particulier (IACK) indique quÕil ne sÕagit
pas dÕun cycle de lecture mŽmoire traditionnel. Un dŽcodeur
externe active lÕun des signaux IACKN , ici IACK7 (6). Le pŽ-
riphŽrique concernŽ re•oit ainsi lÕordre de transmettre son
numŽro de vecteur. Ce numŽro a ŽtŽ prŽalablement pro-
grammŽ dans un registre (7). Il est Žmis sur le bus de don-
nŽes (8). Ce numŽro sert dÕindex dans la table de vecteurs
(9). Le MCU en extrait le vecteur dÕinterruption (10) qui est
lÕadresse de lÕISR quÕil commence ˆ exŽcuter.

5. LA PILE LORS DÕUNE INTERRUPTION

Lors dÕune interruption sur le HC12, lÕŽtat du processeur est sauvegardŽ
dans la pile. DÕabord, lÕadresse de retour, cÕest ˆ dire lÕadresse de lÕinstruc-
tion qui aurait ŽtŽ exŽcutŽe si lÕinterruption nÕavait pas eut lieu, est empi-
lŽe. Ensuite, les registres Y, X D sont empilŽe. Enfin le registre dÕŽtat CCR
est empilŽ. LÕŽtat de la pile apr•s une interruption est ainsi dŽcrit par la fi-
gure 4. Lorsque lÕISR exŽcute lÕinstruction RTI (retour dÕinterruption),
lÕinterruption se termine et le CPU restaure lÕŽtat du processeur quÕil avait
sauvegardŽ dans la pile.

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
 Chapitre 1 11
interruptions

16 bit

SP CCR
B:A
Xh : Xl
Yh : Yl
RTNh : RTNl

Figure 4 : La pile du 68HC12 lors dÕune interruption.

6. DIFFƒRENTES STRATƒGIES DE PROGRAMMATION

6.1 Scrutation, interruption ou RTOS
La plupart des ŽvŽnements susceptibles de dŽclencher une interruption
peuvent •tre dŽtectŽs par scrutation dÕun registre dÕŽtat. CÕest dÕailleurs la
solution la plus simple ˆ programmer sous rŽserve quÕun seul ŽvŽnement
soit attendu. Dans ce cas, le processeur est enti•rement utilisŽ ˆ scruter les
registres dÕŽtat et ne peut pas •tre utilisŽ ˆ autre chose. Il devient intŽres-
sant dÕutiliser les interruptions lorsque plusieurs ŽvŽnements peuvent sur-
venir et quÕil est g•nant de bloquer le processeur dans une boucle dÕattente.
LÕutilisation des interruptions permet ainsi de mettre un programme en at-
tente dÕun ŽvŽnement sans pour autant bloquer le programme dans une
boucle dÕattente. Le fonctionnement du syst•me est alors basŽ sur un pro-
gramme dÕarri•re plan, qui communique par lÕintermŽdiaire de tampons
dÕentrŽe et de sortie (FIFO). Les ISR vident ou remplissent ces tampons
(cf. figure. 5).

Figure 5 : Principe dÕune application gŽrant les entrŽes-sor-

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
12 DiffŽrentes stratŽgies de programmation

ties par interruption avec des tampons dÕentrŽe et de sortie.

Il existe une troisi•me stratŽgie qui consiste ˆ utiliser un noyau temps-rŽel
multit‰che (RTOS). Dans ce cas, le processeur est partagŽ par plusieurs ta-
ches concurrentes. Les appels au syst•me bloquants, correspondant ˆ lÕat-
tente dÕun Žv•nement, provoquent la sauvegarde de la t‰che en cours
dÕexŽcution et la reprise dÕexŽcution dÕune t‰che pr•te, cÕest-ˆ-dire qui
nÕattend plus dÕŽv•nement. Les dŽtails concernant lÕutilisation et le fonc-
tionnement dÕun RTOS dŽpasse le cadre de ce chapitre. Cependant un
RTOS ne peut pas se passer dÕinterruptions. Les noyaux temps rŽel sont
con•us pour rŽpondre le plus rapidement possible aux interruptions tout en
bloquant le moins possible le CPU dans les ISR.

6.2 Interruptions imbriquŽes

Tous les microcontr™leurs et microprocesseurs mettent en jeu des prioritŽs
sur les interruptions afin de dŽfinir quelle interruption sera prise en compte
lorsque plusieurs surviennent simultanŽment. Les prioritŽs sont plus ou
moins programmables suivant les MCU. Sur le HC12, les prioritŽs sont fi-
gŽes par le constructeur. Les sources dÕinterruption les plus prioritaires
sont celles correspondant aux plus grandes adresses dans la table des vec-
teurs. Il est seulement possible dÕŽlever la prioritŽ de lÕune des interrup-
tions en utilisant le registre HPRIO. Vous trouverez pour cela les dŽtails
dans la documentation Motorola.
De plus, suivant les microprocesseurs, les routines de service peuvent •tre,
elles-m•mes, interrompues ou ne pas •tre interruptibles. Dans le premier
cas, les interruptions de fortes prioritŽs peuvent interrompre des ISR de
prioritŽ plus faible. LÕavantage dÕune routine interruptible est de minimi-
ser la latence (le temps de rŽaction) dÕune ISR prioritaire puisquÕelle nÕa
pas besoin dÕattendre la fin de lÕexŽcution des interruptions de plus faibles
prioritŽs. A contrario, cette solution est plus cožteuse en RAM puisque les
interruptions imbriquŽes sont susceptibles dÕutiliser simultanŽment la pi-
le. Comme la RAM est une ressource rare dans les petits microcontr™leurs,
les interruptions imbriquŽes y sont, en gŽnŽrale, ŽvitŽes.

ISR3 Inactive Active Inactive ISR3 Inactive Active Inactive

IRQ3 IRQ3
PENDING

ISR2 Inactive Active interr. Active Inactive ISR2 Inactive Active Inactive
prioritŽ croissante
prioritŽ croissante

IRQ2 IRQ2
PENDING

ISR1 Inactive Active interrompue Active Inactive ISR1 Inactive Active Inactive
IRQ1 IRQ1

Programme Programme
Actif interrompu Active en arri•re plan Actif interrompu Active
en arri•re plan
irq3
irq2 irq2 irq2
PILE PILE
irq1 irq1 irq1 irq1 irq1 irq1 irq2 irq3

prog. prog. prog. prog. prog. prog. prog. prog. prog. prog. prog. prog.

temps temps

Figure 6 : Interruption imbriquŽes (ˆ gauche) versus non-

imbriquŽes (ˆ droite).
Lorsque les interruptions sont elles-m•mes interruptibles, il

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
 Chapitre 1 13
interruptions

faut dimensionner lÕespace de la pile pour quÕelle puisse

contenir les contextes de toutes les interruptions imbriquŽes.
Avec un RTOS multit‰che prŽemptif, il y a autant de pile que
de t‰ches et cet espace doit alors •tre prŽvu dans chaque pile
de chaque t‰che.

A lÕinverse, lorsque les interruptions ne sont pas interrupti-

bles, les requ•tes dÕinterruption, m•me prioritaires, peuvent
rester en attente (ÇpendingÈ) assez longtemps, le temps
quÕune interruption moins prioritaire se termine. En revan-
che, les ISR nÕoccupent las pile que lÕune apr•s lÕautre.

7. EXEMPLE DE PROGRAMMES DÕINTERRUPTION SUR HC12

7.1 Avec CodeWarrior
Le programme suivant est un exemple complet de programmation des in-
terruptions avec CodeWarrior pour HC12.
Dans la fonction main (ligne 12) le bit IE (interrupt enable) correspondant
ˆ lÕautorisation des interruption associŽes au port H (registre PIEH) est ac-
tivŽ pour les 4 bits de poids faibles. Il sÕagit dÕune autorisation individuelle
dÕŽmettre des requ•tes dÕinterruption. LÕautorisation globales des interrup-
tions se fait (ˆ la ligne 18) par la macro EnableInterrupts qui correspond ˆ
lÕinstruction assembleur CLI. Cette instruction met ˆ zŽro le bit I du regis-
tre dÕŽtat CCR. Le MCU devient alors sensible aux interruptions. En lÕab-
sence dÕinterruption, ce programme attend sans rien faire dans la boucle
infinie de la ligne 20. Lorsque lÕun des 4 boutons poussoir de la carte
Star12 est appuyŽ, lÕinterruption est dŽclenchŽe. La fonction KWH_ISR (li-
gne 23 ˆ 28) sÕexŽcute, ce qui a pour effet dÕinverser lÕŽtat de lÕune des
LED associŽ au port M. Notez quÕˆ la ligne 26 on Žcrit des UN dans les
indicateurs dÕinterruption (IF) du registre PIFH ce qui a pour effet de les
remettre ˆ ZERO. Cela correspond ˆ un acquittement de lÕinterruption.
SÕil nÕest pas fait, lÕISR se relance indŽfiniment d•s quÕelle se termine ce
qui bloque le CPU et plante le programme.

Comme la table des vecteurs se

trouve dans la mŽmoire ßash du
MCU 9S12DP256, il nÕest pas Listing 5: Programme complet dÕinterruption sur CW / HC12
possible de charger le code 1 /////////////////////////////
uniquement dans la RAM, il faut
programmer la mŽmoire ßash. A 2 // DEMO INTERRUPT HC12 //
dŽfaut, la table des vecteurs nÕest 3 // TARGET = 9S12DP526 //
pas modiÞŽe, le vecteur nû25 4 // Compiler = CodeWarrior //
pointe donc nÕimporte o• (mais 5 /////////////////////////////
sžrement pas sur son ISR) et le 6
programme plante d•s le 7 #include <hidef.h> // for "EnableInterrupts" macro
dŽclenchement de la premi•re 8 #include "interrupt.h" // for "PORTH_ISR" macro
interruption. 9 #include "6812dp256.h" // for 9S12dp256's registers
10
11 void main(void){
12 PIEH = 0x0F; // Enable interrupt on port H3-0
13 PERH = 0xFF; // Enable Pull-Up on Port H

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
14 Trouvez vos BUGS

Listing 5: Programme complet dÕinterruption sur CW / HC12

14
15 DDRA = 0xFF; // Port A OUT (Bargraph)
16 DDRM |= 0xC0; // Port M 7-6 OUT (Bargraph)
17
18 EnableInterrupts // Idem {__asm CLI;}
19
20 while(TRUE); // Infinite loop.
21 }
22
23 interrupt PORTH_ISR // Is vector num 25
24 void KWH_isr(void){
25 PTM ^= 0x80; // Toggle Port M bit 7
26 PIFH = 0xFF; // Write 1s in port H IT falgs
27 // to clear them.
28 }
29 ////////////////////END OF DEMO/////////////////

Le mot clŽ interrupt (ligne 23), qui nÕest pas standard, indique au com-
pilateur que cette fonction est associŽe au vecteur dÕinterruption nû25,
cÕest-ˆ-dire ici les interruptions du port H. Le compilateur va gŽnŽrer une
ISR assembleur, qui se termine par lÕinstruction RTI, et place lui-m•me le
vecteur dans la table des vecteurs dÕinterruption.

7.2 Avec un autre compilateur

Avec dÕautres outils, la dŽclaration dÕune fonction dÕinterruption peut-•tre
diffŽrente et lÕŽcriture dans la table des vecteurs doit, le plus souvent, se
faire explicitement. Voici par exemple comment peut une ISR avec des
outils de dŽveloppement diffŽrents. La ligne 7 correspond ˆ la dŽfinition
du pointeur sur la fonction TOFhandler dans la table des vecteurs
TOF_vector[]. LÕadresse du vecteur est dŽfini par la directive #pragma
abs_address ˆ la ligne 6.

Listing 6: Routine de service en C avec un autre compilateur

1 #pragma interrupt_handler TOFhandler
2 void TOFhandler(void){
3 TFLG2 = 0x80; // TOF interrupt acknowledge
4 PORTT ^= 0x40; // toggle bit 6
5 }
6 #pragma abs_address:0xffde
7 void (*TOF_vector[])() = { TOFhandler };
8 #pragma end_abs_address

8. TROUVEZ VOS BUGS

8.1 Si le programme plante avant de dŽclencher une interruption :
¥ VŽrifiez avec le debugger dans la mŽmoire que les vecteurs associŽs
aux interruptions autorisŽes pointent effectivement sur vos ISR.

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
 Chapitre 1 15
interruptions

¥ VŽrifier que votre projet est bien con•u pour tŽlŽcharger le programme
en FLASH. Si seule la RAM est programmŽe, les vecteurs dÕinterrup-
tion ne seront pas modifiŽes et pointeront nÕimporte o•.

8.2 Si une ISR se dŽclenche une seule fois puis reste bloquŽe
¥ Les fonctions dÕinterruption ne doivent jamais •tre appelŽes ˆ partir
dÕune autre fonction comme des fonctions usuelles. Autrement lÕins-
truction de fin dÕinterruption (RTI) qui ne trouve pas dans la pile ce
quÕelle attend fait planter le syst•me.
¥ Avant la fin dÕune routine dÕinterruption, la cause de lÕinterruption doit
•tre supprimŽe (gŽnŽralement en Žcrivant un UN dans un registre IF)
sinon lÕinterruption se redŽclenche indŽfiniment et le syst•me est blo-
quŽ.

8.3 Si lÕinterruption ne se dŽclenche pas du tout

¥ VŽrifiez avec le debugger dans les registres du MCU que la requ•te
dÕinterruption se fait bien. Le bit IF correspondant doit •tre ˆ 1.
¥ VŽrifiez avec le debugger que lÕinterruption est pas autorisŽe. Le bit IE
correspondant doit •tre ˆ 1.
¥ VŽrifiez avec le debugger que les interruptions ne sont pas globale-
ment inhibŽes. Le bit I du registre dÕŽtat doit •tre ˆ 0.
¥ VŽrifiez avec le debbuger dans la mŽmoire que le vecteur associŽ ˆ
cette interruption pointe effectivement sur votre ISR.
¥ VŽrifiez avec le debbuger que lÕinterruption ne se dŽclenche pas en y
pla•ant un point dÕarr•t.

9. POUR ALLER PLUS LOIN

Certains points liŽs ˆ la programmation avec des interruptions sont assez
dŽlicats. Ils ne seront quÕŽvoquŽs ici.

9.1 Interruptions et rŽentrance.

LorsquÕune ISR appelle une fonction qui est appelŽe Žgalement par dÕautre
ISR ou par le programme dÕarri•re plan, la fonction doit prŽsenter certaines
caractŽristiques pour fonctionner normalement. Le fait quÕils puissent
exister diffŽrentes occurrences simultanŽes dÕune fonction implique quÕel-
le soit rŽentrante. En particulier, elle ne doit pas utiliser de donnŽes sta-
tiques comme variables temporaires.

9.2 Section critiques

Parfois il est ennuyeux quÕune interruption intervienne au cours dÕune opŽ-
ration manipulant une donnŽe. Cela peut conduire ˆ un Žtat des variables
incohŽrent. Il est alors nŽcessaire de dŽfinir des sections de code qui doi-
vent sÕexŽcuter de fa•on atomique, cÕest ˆ dire sans pouvoir •tre interrom-
pu au milieu, comme sÕil sÕagissait dÕune seule instruction assembleur. On

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ
16 Pour aller plus loin

appelle section critique de telles section de code o• les interruptions sont

inhibŽes. Bien sžr, les sections critiques nuisent ˆ la rŽactivitŽ du syst•me
qui risque de mettre plus longtemps pour rŽpondre aux interruptions. Elles
doivent donc •tre aussi courtes que possible.

9.3 Quand le Retour dÕinterruption se fait rouler

Dans un RTOS multit‰che prŽemptif, chaque t‰che dispose de sa propre pi-
le. Le lancement dÕune telle t‰che est un joli tour de passe-passe. En effet,
pour dŽmarrer une t‰che, la fonction de crŽation de t‰che crŽŽ artificielle-
ment dans la mŽmoire une pile qui simule celle quÕaurait eut la t‰che si elle
avait ŽtŽ interrompu. Puis le pointeur de pile est modifiŽ pour pointer sur
cette nouvelle pile. La t‰che est dŽmarrŽe par lÕinstruction de retour dÕin-
terruption RTI. En effet, cette instruction va chercher dans la pile les regis-
tres quÕelle pense avoir sauvegardŽs. TrompŽe par cette nouvelle pile, elle
initialise en fait ses registres avec un contexte crŽŽ de toute pi•ce pour lui
faire exŽcuter la nouvelle t‰che.
De m•me, pour basculer dÕune tache ˆ lÕautre, une interruption logicielle
lance une routine de changement de contexte. Cette routine modifie le
pointeur de pile pour quÕil pointe sur la pile de la tache ˆ relancer. Ainsi,
le retour dÕinterruption ne retournera pas ˆ la tache interrompue mais ˆ une
autre t‰che.
Il est clair que la programmation dÕune routine de crŽation de t‰che ou de
changement de contexte nŽcessite une parfaite connaissance de lÕŽtat de la
pile au moment des interruptions. CÕest probablement la partie la plus dŽ-
licate dans un RTOS.

P r o g r a m m a t i o n d e s s y s t • m e s e m b a r q u Ž s e t a p p l i c a t i o n s u r S t a r 1 2 - I U T C A C H A N - D Ž p . G E i i 1 Ñ