La programmation des ATMEL AVR
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (1.04 MB, 45 trang )
La programmation des ATMEL AVR
JUILLOT Guillaume
2 septembre 2003
Table des mati`
eres
Introduction
I
Les
I.1
I.2
I.3
I.4
I.5
I.6
I.7
I.8
I.9
3
microcontrˆ
oleurs AVR pour les nuls
Qu’est-ce qu’un microcontrˆ
oleur ? . . . .
Les entr´ees/sorties d’un microcontrˆoleur
Timers/Counters et g´en´eration de PWM
Convertisseurs analogique/num´erique . .
Communication s´erie USART . . . . . .
Comparateur analogique . . . . . . . . .
Watchdog Timer . . . . . . . . . . . . .
Modes d’´economie d’´energie . . . . . . .
Interruptions internes et externes . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5
5
5
6
7
7
8
8
8
9
II La programmation des microcontrˆ
oleurs en C
II.1 D´ebuter avec Imagecraft . . . . . . . . . . . . . . . . . . . . . .
II.2 La s´eparation de code en plusieurs fichiers et quelques fonctions
II.2.1 La d´efinition de fonctions utiles `a l’aide de #define . . .
II.2.2 Rajouter un fichier `
a un projet . . . . . . . . . . . . . .
II.3 Les interruptions avec ImageCraft AVR . . . . . . . . . . . . .
II.4 L’assembleur dans un programme en C . . . . . . . . . . . . . .
II.5 Quelques compl´ements sur le compilateur ICC AVR . . . . . .
. . . .
utiles
. . . .
. . . .
. . . .
. . . .
. . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
11
11
13
14
14
15
16
16
III La simulation des progammes
III.1 Premiers pas avec AVR Studio 4
III.2 Workspace . . . . . . . . . . . . .
III.3 Programme en cours . . . . . . .
III.4 Contrˆ
ole du d´eroulement . . . . .
III.5 Choix de la vue . . . . . . . . . .
III.6 Output view . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
19
19
20
21
21
22
22
IV L’impl´
ementation r´
eelle sur le microcontrˆ
oleur
IV.1 L’alimentation . . . . . . . . . . . . . . . . . . . . . . . . . . . .
IV.2 L’horloge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
IV.3 Le port de programmation . . . . . . . . . . . . . . . . . . . . . .
IV.4 Comment impl´ementer notre programme dans le microcontrˆoleur
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
23
23
23
24
26
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Le mot de la fin
29
A Sch´
ema de l’ATmega128
31
B Conversion hexad´
ecimal/binaire/d´
ecimal
B.0.1 Convention d’´ecriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
33
33
1
2
`
TABLE DES MATIERES
C Aide `
a la programmation
C.1 Type de donn´ees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
C.2 Gestion des entr´ees/sorties . . . . . . . . . . . . . . . . . . . . . . . . . . .
C.3 Interruptions externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
C.4 Timer/Counter0 (8 bits) . . . . . . . . . . . . . . . . . . . . . . . . . . . .
C.5 Timer/Counter2 (8 bits) . . . . . . . . . . . . . . . . . . . . . . . . . . . .
C.6 Timer/Counter1 et 3 (16 bits) . . . . . . . . . . . . . . . . . . . . . . . . .
C.7 Interruptions pour Timers/Counters . . . . . . . . . . . . . . . . . . . . .
C.8 G´en´eration de PWM sur OC0 (8 bits) . . . . . . . . . . . . . . . . . . . .
C.9 G´en´eration de PWM sur OC2 (8 bits) . . . . . . . . . . . . . . . . . . . .
C.10 PWM sur OC1A, OC1B, OC1C, OC3A, OC3B et OC3C (de 8 `a 10 bits)
C.11 USART . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
35
35
35
35
36
36
37
37
37
38
38
39
Adresses Internet utiles
41
Index
43
Introduction
Ce document a ´et´e ´ecrit dans le cadre de la coupe 2003 de robotique e=M6. Il a pour but
de vous pr´esenter toutes les phases de d´eveloppement d’un projet sur les microcontrˆoleurs de la
famille AVR de chez ATMEL.
Cette pr´esentation est d´ecompos´ee en quatre parties. La premi`ere sera une description aussi
compl`ete que possible des possibilit´es qu’offrent les microcontrˆoleurs choisis. Suivront les rudiments de la programmation en C et en assembleur, `a l’aide du compilateur Imagecraft. Un aspect
important est la simulation du programme, qui se fera `a l’aide de AVR Studio 4 dans la troisi`eme
partie du pr´esent document. Je terminerai en pr´esentant la mise en pratique du programme en
l’impl´ementant sur le microcontrˆ
oleur.
Les exemples donn´es seront valables pour un ATmega128. Il est possible qu’ils ne soient plus
valables pour un autre microcontrˆ
oleur. Dans tous les cas il est vivement recommand´
e
d’avoir une datasheet compl`
ete de l’ATmega128 sous les yeux pour mieux pouvoir
suivre les exemples. Utilisez ´egalement la datasheet d’un autre microcontrˆoleur si vous souhaitez
adapt´e les exemples au microcontrˆ
oleur de votre choix.
3
4
INTRODUCTION
Chapitre I
Les microcontrˆ
oleurs AVR pour
les nuls
Les microcontrˆ
oleurs de la famille AVR d’ATMEL poss`edent de nombreuses caract´eristiques
diff´erentes, aussi bien en termes de vitesse, m´emoire, nombre d’entr´es/sorties mais aussi au niveau
des fonctions particuli`eres qui sont disponibles. Il conviendra donc de choisir le microcontrˆoleur
en fonction de l’utilisation qui est `
a faire - par exemple, il est conseill´e d’´eviter d’utiliser un
ATmega128 si l’on ne cherche qu’`
a g´en´erer un PWM1 .
I.1
Qu’est-ce qu’un microcontrˆ
oleur ?
Un microcontrˆ
oleur est compos´e d’un microprocesseur, de m´emoire ROM pour stocker le
programme et d’une m´emoire RAM volatile pour conserver les r´esultats interm´ediaires lors de
l’ex´ecution du programme.
Mais les microcontrˆ
oleurs poss`edent des avantages incomparables pour l’informatique embarqu´ee par rapport aux microprocesseurs. Ce sont d’abord les broches qui peuvent servirent
d’entr´ees/sorties mais surtout toutes les fonctions p´eriph´eriques. En effet, selon le microcontrˆoleur
consid´er´e, on peut trouver :
– plusieurs Timers/Counters
– G´en´eration de signaux PWM
– Nombreux convertisseurs analogiques/num´eriques
– Communication s´erie USART
– Comparateur analogique
– Watchdog Timer
– Oscillateur RC interne
– Modes d’´economies d’´energie
– Interruptions internes et externes
I.2
Les entr´
ees/sorties d’un microcontrˆ
oleur
La plupart des pattes d’un microcontrˆoleur peuvent servir soit d’entr´ees, soit de sorties, et ce
choix peut changer `
a tout instant comme le veut le d´eveloppeur.
Les entr´ees/sorties sont regroup´ees par huit et le groupement de huit pattes ainsi form´e est
appel´e port et se voit attribu´e une lettre. Par exemple, les broches 44 `a 51 forment le port A.
1 PWM = Pulse Width Modulation, c’est un signal rectangulaire caract´
eris´
e par le rapport cyclique
(tempshaut /tempsbas ), c’est-`
a-dire avec un temps a
` 1 diff´
erent du temps `
a 0.
5
6
ˆ
CHAPITRE I. LES MICROCONTROLEURS
AVR POUR LES NULS
Chaque patte est ensuite num´erot´ee selon sa position au sein de ce port. Par exemple, la broche
46 est appel´ee PA52 . Trois registres3 servent `a g´erer les entr´ees/sorties :
– DDRx4 : indique quelles sont les pattes consid´er´ees comme des entr´ees et celles consid´er´ees
comme des sorties. Si le ni`eme bit de DDRx (not´e DDxn) est `a 1, alors la ni`eme patte du
port x (not´ee Pxn) est consid´er´e comme une sortie. Si DDxn est `a 0, alors Pxn est consid´er´ee
comme une entr´ee.
– PORTx : la valeur du ni`eme bit de PORTx (not´e PORTxn) d´efinit la valeur de sortie de
Pxn. Si PORTxn=1, alors Pxn=+Vcc, si PORTxn=0, alors Pxn=Gnd.
– PINx : la valeur du ni`eme bit de PINx (not´e PINxn) est la valeur qui est appliqu´ee `a l’entr´ee
du microcontrˆ
oleur. Par exemple, si on applique +Vcc `a Pxn, alors PINxn=1.
La plupart des pattes poss`edent des fonctions p´eriph´eriques qui inhibent l’utilisation en tant
qu’entr´ees/sorties. Si l’on utilise les fonctions p´eriph´eriques, il ne faut en aucun cas modifier les
bits DDRxn, PORTxn et PINxn correspondants.
I.3
Timers/Counters et g´
en´
eration de PWM
Les Timers/Counters, not´es TCNTn o`
u n est le num´ero Timer/Counter, sont des compteurs
cadenc´es selon une certaine fr´equence d´efinie. Lorsqu’il atteint son maximum (MAX5 ), il passe `a 0
et recommence `
a compter. Ce passage de MAX `a 0 peut s’accompagner d’une interruption interne
(cf. Interruptions internes et externes en page 9).
` ces Timers/Counters se rajoutent un comparateur dont on peut d´efinir le seuil `a l’aide du
A
registre OCRn. Lorsque le TCNTn atteint la valeur de OCRn, alors la patte OCn change de valeur, passant de 0 `
a 1 ou de 1 `
a 0 selon la configuration puis retournant `a la valeur initiale lorsque
TCNTn passe de MAX `
a 0.
Ces Timers/Counters peuvent donc avoir plusieurs utilisations. D’abord, le programmeur peut
savoir le temps ´ecoul´e depuis qu’il a lanc´e le Timer/Counter. Ou encore, l’interruption de passage
de MAX `
a 0 peut ˆetre utilis´ee pour temporisation, et commencer ou arrˆeter un programme au
bout d’un certain temps. La derni`ere utilisation, tr`es utile en robotique pour la commande de servomoteurs, est la g´en´eration de signaux PWM. En effet, si la patte OCn change de valeur lorsque
le TCNTn atteint la valeur du comparateur OCRn, on obtient sur OCn un signal alternativement
`a 1 puis `
a 0 avec des dur´ee `
a 0 et `
a 1 r´eglables. On a bien OCn qui est un signal PWM dont on
peut d´efinir le rapport cyclique en mettant la bonne valeur dans OCRn.
Plusieurs registres sont utilis´es pour configurer les Timers/Counters :
TCCRn, OCRn, ASSR, TIMSK et TIFR. Leurs configurations sont compliqu´ees, il convient de
se reporter aux chapitres correspondants de la datasheet. La valeur du Timer/Counter, accessible
via le registre TCNTn, peut ˆetre modifi´ee `a tout instant afin de r´einitialiser ma s´equence `a partir
` noter que la
d’une certaine valeur, apr`es avoir atteint MAX, le compteur recommencera `a 0. A
fr´equence de comptage peut ˆetre un sous-multiple de la fr´equence du microcontrˆoleur ou encore
ˆetre impos´ee par une horloge externe connect´ee `a une patte du microcontrˆoleur.
Certains compteurs fonctionnent sur 16 bits. Ils pr´esentent plusieurs avantages : ils peuvent
compter plus loin donc plus longtemps ; lors d’une utilisation pour g´en´erer du PWM, la r´esolution
est plus ´elev´ee ; et surtout ils poss`edent deux comparateurs dont les seuils peuvent ˆetre r´egl´es
diff´erement, ce qui permet d’obtenir sur les pattes OCnA et OCnB deux signaux PWM de
mˆeme fr´equence mais de rapport cyclique diff´erent `a l’aide d’un seul Timer/Counter. Dans le
2 Les plus perspicaces auront remarqu´
e que l’ordre des num´
eros sur le port A est invers´
e par rapport aux num´
eros
des pattes. En r´
ealit´
e, cela d´
epend du port, certains sont dans le bon sens, d’autres non. Voir dans la datasheet.
3 Un registre est une variable interne de huit bits, utilis´
ee pour d´
efinir le comportement du microcontrˆ
oleur ou
pour savoir dans quel ´
etat il se trouve.
4 x repr´
esente la lettre du port, par exemple DDRA ou DDRB ...
5 pour un compteur sur m bits, alors MAX = 2m − 1
´
I.4. CONVERTISSEURS ANALOGIQUE/NUMERIQUE
7
cas de Timer/Counter sur 16 bits, le registre TCNTn se d´ecompose en deux registres TCNTnL et
TCNTnH tandis que OCRn se d´ecompose en OCRnAL et OCRnAH pour le premier comparateur
et OCRnBL, OCRnBH pour le deuxi`eme comparateur.
I.4
Convertisseurs analogique/num´
erique
Le monde r´eel ´etant continu, c’est-`a-dire analogique, tandis que les microcontrˆoleurs fonctionnent en num´erique, il faut bien avoir une interface entre les deux : le convertisseur analogique/num´erique6 . Son fonctionnement est simple `a comprendre : `a intervalles de temps r´eguliers,
la tension analogique est mesur´ee puis arrondie afin de pouvoir ˆetre convertie en num´erique. La
conversion est donc d’autant plus fid`ele que le nombre de bits du codage est ´elev´e et est inversement
proportionnelle `
a la plage de tension analogique en entr´ee. Les microcontrˆoleurs de la famille AVR
poss`edent des convertisseurs embarqu´es donc il n’est pas n´ecessaire d’en concevoir ou d’en acheter.
Par exemple, l’ATmega128 poss`ede un CAN fonctionnant sur 10 bits. Ce CAN peut convertir
jusqu’`a 8 signaux analogiques par intermittence. Le temps maximum de conversion est de 260µs
mais peut ˆetre diminu´e en r´eduisant la r´esolution (nombre de bits du codage). L’´echelle de tension
en entr´ee est par d´efaut [0, V cc] mais peut ˆetre pass´ee `a [0, Vref ] o`
u Vref ≤ V cc est une tension
appliqu´ee `
a la patte Aref (no 62). A noter que les CAN peuvent ˆetre configur´es pour ne faire
qu’une conversion ou pour convertir en continu la tension analogique, la conversion ´etant alors
r´eguil`erement mise `
a jour selon la dur´ee de conversion.
I.5
Communication s´
erie USART
USART est l’abr´evation pour Universal Synchronous and Asynchronous serial Receiver and
Transmitter, c’est un syst`eme de communication point-`a-point tr`es flexible.
Les donn´ees sont transmises par trames de 7 `a 13 bits. La trame a le format suivant :
❉
☎
❉☎
❉☎
❉☎
❉☎
❉☎
❉☎
❉☎
❉☎
❉☎
☎
❉
(IDLE) ❉ St ☎ 0 ☎❉ 1 ☎❉ 2 ☎❉ 3 ☎❉ 4 ☎❉ [5] ☎❉ [6] ☎❉ [7] ☎❉ [8] ☎❉ [P] ☎ Sp1 [Sp2] ❉ (St/IDLE)
❉
❉
☎
☎❉
☎❉
☎❉
☎❉
☎❉
☎❉
☎❉
☎❉
☎❉
☎
St : bit de d´epart, toujours `
a0
n : bits de donn´ees
P : bit de parit´e
Sp : bit(s) de fin, toujours `a 1
IDLE : pas de transfert, la ligne doit ˆetre `a 1
Fig. I.1 – Trame USART
Les ´el´ements entre crochets sont facultatifs, leur pr´esence est d´efinie par le d´eveloppeur. Le bit
de parit´e permet de v´erifier rapidement s’il y a eu une erreur de transmission mais n’est pas fiable
`a 100%.
L’USART se d´ecompose en trois parties :
L’´
emetteur : se charge d’´emettre sur la patte TXDn, `a la fr´equence configur´ee, la trame selon la
valeur stock´ee dans le registre UDR ; il s’occupe donc automatiquement de la g´en´eration des
bits Start, Stop et ´eventuellement Parity. Des interruptions peuvent ˆetre d´eclench´ees lorsque
la transmission est termin´ee.
6 en
abr´
eg´
e, CAN ou ADC en anglais pour Analog to Digital Converter
ˆ
CHAPITRE I. LES MICROCONTROLEURS
AVR POUR LES NULS
8
Le r´
ecepteur : d`es d´etection sur la patte RXDn d’un bit Start valide (c’est-`a-dire `a 0), chaque
bit de la trame est alors ´echantillon´e selon la fr´equence configur´ee ou selon l’horloge sur XCK,
et stock´e dans un registre temporaire jusqu’`a r´eception de la trame compl`ete. Ensuite, la
valeur re¸cue est d´eplac´ee dans le registre UDR accessible par le programme. Une interruption
peut ˆetre d´eclench´ee lors de la fin de r´eception pour pr´evenir qu’une trame est arriv´ee. Si le
programme n’a pas lu une trame lorsqu’une deuxi`eme trame arrive, la premi`ere trame est
perdue. Si la transmission s’est mal d´eroul´ee, par exemple si la trame est non conforme, si le
bit de parit´e n’est pas correct ou si des donn´ees re¸cues n’ont pas ´et´e lues, divers drapeaux7
passent `
a 1 et les donn´ees erron´ees sont effac´ees.
Le g´
en´
erateur d’horloge : lors d’une utilisation en mode synchrone, un g´en´erateur est d´eclar´e
maˆıtre et l’autre esclave. Le maˆıtre g´en`ere le signal d’horloge selon le d´ebit souhait´e et l’envoit sur la patte XCK du microcontrˆoleur. L’horloge esclave re¸coit ce signal d’horloge sur
sa patte XCK et l’utilise pour ´echantilloner les trames ou les ´emettre au bon rythme. En
mode asynchrone, l’USART en reception se charge de synchroniser son horloge sur la trame
arrivante.
La configuration doit ˆetre faite avant toute tentative d’envoi de donn´ees et ne devra pas ˆetre
chang´ee tant que des donn´ees restent `
a ´emettre/recevoir. Il faut bien veiller `a ce que la configuration
soit toujours identique sur les deux microcontrˆoleurs pour le format de la trame, le d´ebit et qu’en
mode synchrone les deux pattes SCK soient reli´ees et qu’un USART soit en maˆıtre et l’autre en
esclave.
I.6
Comparateur analogique
Outre les convertisseurs analogiques/num´eriques, les microcontrˆoleurs AVR poss`edent un comparateur analogique. Celui-ci compare les deux tensions appliqu´ees aux pattes AIN0 et AIN1. Si
AIN 0 < AIN 1 alors le bit ACO (5`eme bit du registre ACSR) passe `a 1. Sinon, ACO reste `a 0.
De plus, une interruption peut ˆetre d´eclench´ee lors du passage `a 1 de ACO.
I.7
Watchdog Timer
Le Watchdog Timer se charge de faire des RESET `a intervalle de temps r´egulier. Il utilise un
oscillateur RC interne en tant qu’horloge cadenc´ee `a 1MHz. Ce syst`eme permet de recommencer le
mˆeme programme `
a intervalles de temps r´eguliers ou encore de se r´eveiller d’un mode d’´economie
d’´energie apr`es un certain lapse de temps (voir paragraphe suivant). A noter que la m´emoire RAM
n’est pas perdu au cours de ce RESET, ce qui permet d’augmenter le temps entre deux r´eex´ecution
du programme en tenant `
a jour un compteur qui est d´ecr´ement´e `a chaque Watchdog Reset jusqu’`a
ce qu’il atteigne 0 et alors on commence r´eellement le programme.
I.8
Modes d’´
economie d’´
energie
Certaines applications ne n´ecessitent pas que le microcontrˆoleur tourne continuellement. Il
serait donc souhaitable de le d´esactiver, de ”l’endormir”, pour qu’il consomme aussi peu d’´energie
que possible. Ceci est possible grˆ
ace aux Sleep Mode. Plusieurs modes sont disponibles, afin de
pouvoir ”endormir” ce dont on n’a pas besoin et de conserver ce qui doit l’ˆetre.
Une fois configur´e, il suffit pour entrer dans le mode d’´enregie d’ex´ecuter l’instruction SLEEP.
La sortie du mode se fait via une interruption externe ou interne, selon le mode utilis´e.
7 Un
drapeau est un bit indiquant qu’un ´
ev`
enement s’est produit.
I.9. INTERRUPTIONS INTERNES ET EXTERNES
I.9
9
Interruptions internes et externes
Certains ´ev`enements peuvent intervenir `a n’importe quel instant et doivent ˆetre g´er´es sans
attendre. Il est ´evident que de faire constament une batterie de tests pour voir si tel ou tel
´ev`enement s’est produit n’est pas performant du tout. Les interruptions sont LA solution `a ce
probl`eme. En effet, d`es qu’un ´ev`enement se produit, si l’interruption est correctement configur´ee,
le microcontrˆ
oleur arrˆete imm´ediatement son ex´ecution pour ex´ecuter une autre portion de code
g´erant cet ´ev`enement. D`es que cette portion de code a fini d’ˆetre ex´ecut´ee, le microcontrˆoleur
retourne `
a son programme principal, `a l’endroit o`
u il l’avait quitt´e.
Les interruptions possibles sont de deux types :
externe : lorsqu’une des pattes passe dans un certain ´etat ou tant que la patte est dans un ´etat
d´efini
interne : par exemple lorsque qu’un compteur d´epasse sa valeur maximale8 , lorsqu’un transfert
via USART est termin´e...
Plusieurs choses sont `
a faire pour configurer et utiliser les interruptions :
1. Pour les interruptions internes, configurer le registre correspondant pour d´eclencher l’interruption ; par exemple pour d´eclencher une interruption sur un Overflow du Timer/Counter0,
on configure le registre TIMSK en mettant le bit no 0, TOIE0, `a 1.
2. Pour les interruptions externes, ce sont les registres EICRA, EICRB, EIMSK et EIFR qu’il
faut configurer pour qu’un certain ´etat sur une ou plusieurs des pattes INT0 `a INT7 d´eclenche
une interruption.
3. Il faut ensuite dire au microcontrˆoleur ce qu’il doit ex´ecuter. Pour cela, les premiers blocs
` chaque type d’interruption est
de m´emoire sont allou´es `
a un Reset and Interrupt Vector. A
associ´e une adresse dans ce Vector o`
u le d´eveloppeur met une instruction ”jmp LABEL”,
LABEL ´etant l’adresse de la m´emoire o`
u se trouve le code `a ex´ecuter.
4. Ensuite, on programme le code qui doit ˆetre ex´ecut´e en le mettant `a l’adresse LABEL d´efinie
ci-dessus. Nous verrons dans le chapitre sur la programmation en C en page 15 comment ces
deux ´etapes peuvent ˆetre r´ealis´e facilement.
5. Il reste `
a activer la gestion des interruptions a` l’aide de la commande assembleur sei. La
gestion des interruptions peut ˆetre desactiv´ee `a l’aide de la commande assembleur cli.
A noter que le retour au programme principal se fait via la commande assembleur reti et non
via ret comme pour un retour depuis une sous-fonction classique.
8 on
appele cela Overflow
10
ˆ
CHAPITRE I. LES MICROCONTROLEURS
AVR POUR LES NULS
Chapitre II
La programmation des
microcontrˆ
oleurs en C
Normalement, `
a ce niveau, vous vous dˆıtes : ”Que ¸ca a l’air bien les microcontrˆoleurs, ce
doit ˆetre trop dur `
a programmer.” Et bien, vous vous trompez ! Evidement si l’on ´etait oblig´e de
programmer en assembleur, ce serait gal`ere. Mais heureusement, les microcontrˆoleurs AVR ont
l’avantage de disposer de moultes compilateurs, ce qui permet de programmer en C, ce qui est,
vous l’avouerez, tout de mˆeme plus facile.
Parmis ces compilateurs, il y a entre autres1 : GCC AVR - compilateur sous license GNU
c’est-`a-dire libre d’utilisation ; Imagecraft - alias ICC AVR ; et CodeVision AVR. Si GCC AVR est
gratuit, il a le gros d´esavantage de fonctionner sans interface graphique mais `a l’aide de MakeFile.
Les aficionados de la programmation en C sous Linux ne seront gu`ere gˆen´es mais moi si. C’est
pourquoi j’ai choisi d’utiliser une version de d´emonstration d’Imagecraft, les limitations de cette
d´emo n’´etant gu`ere gˆenant pour de petits projets.
Pour les adeptes de Linux, reportez-vous aux rapports de mes pr´edecesseurs `a cette adresse :
/>
II.1
D´
ebuter avec Imagecraft
Apr`es un d´etour sur pour t´el´echarger la d´emo d’Imagecraft et
apr`es l’avoir install´e, on le lance et les choses s´erieuses vont commencer.
Si vous ˆetes prˆets, nous allons pouvoir commencer. Un projet est souvent compos´e de plusieurs
fichiers qu’il faut regroup´e. Pour cela, on cr´ee un ... Project ! Dans le menu Project, choisissez
New. Cr´eez un r´epertoire o`
u vous voulez que le projet soit stock´e puis donnez-lui son nom2 . Pour
l’exemple qui suit, vous prendrez comme r´epertoire debut et comme nom de projet debut. Ouvrez
le projet ainsi cr´e´e via Project/Open. Ensuite faites File/New et vous pouvez commencer `a ´ecrire
du code.
Maintenant que tout est prˆet pour commencer `a programmer, je vous propose de faire un
programme qui consiste `
a faire clignoter une LED3 . D’abord, choisissons o`
u sera connect´e cette
1 Voir
sur pour plus de d´
etails
AVR ne g`
ere pas les noms de fichiers longs. Pour cr´
eer un projet dans un r´
epertoire donc le chemin
d’acc`
es contient des caract`
eres illicites pour des noms de fichiers courts, il faut donner dans la case Nom du fichier
l’arborescence compl`
ete en format nom de fichier court. Par exemple C:\mesdoc~1\codeav~1\debut.prj
3 LED est le sigle anglais pour Diode Electro-Luminescente, c’est une petite ampoule.
2 ICC
11
ˆ
12 CHAPITRE II. LA PROGRAMMATION DES MICROCONTROLEURS
EN C
DEL. Si personne ne s’y oppose, je propose la patte PA04 .
Ensuite, il faut que le microcontrˆoleur sache quelle portion de code ex´ecuter au d´emarrage.
Pour cela, on inclue ce code dans la fonction main. Voici donc le d´ebut de notre code :
void main(void){
Explications : main est l’entr´ee du programme, c’est vers l`a que se dirigera le microcontrˆoleur d`es sa
mise sous tension. void est un mot anglais signifiant ”rien”. Plac´e avant le nom de la fonction - ici
main -, void indique que le programme ne renvoie pas de r´esultat comme par exemple pourrait le
faire une fonction somme. Ensuite, entre paranth`eses se trouve les param`etres de la fonction, c’est`a-dire ce que la fonction a besoin de connaitre. Ici void soit ”rien” mais une fonction somme aura
besoin des deux nombres `
a additionner donc la fonction deviendrait : int somme(int n, int m)5 .
Le symbole { sert `
a indiquer le d´ebut de la fonction. A la fin de la fonction, il faut mettre }.
Nous avons vu dans le paragraphe sur les entr´ees/sorties, en page 5, que les pattes pouvaient
servir `a la fois d’entr´ee ou de sortie. Ici il faut dire au microcontrˆoleur que la patte PA0 est une
sortie. Il faut donc mettre le bit 0 de DDRA `a 1. La premi`ere instruction de notre programme est
donc :
DDRA=0x01;
En effet 0x indique que le nombre est en h´exad´ecimal. Donc 0x01=00000001 en binaire6 . On
voit bien7 que le bit 0 de DDRA est mis `a 1. PA0 est d´esormais une sortie pour le microcontrˆoleur.
Le point-virgule ” ;” sert `
a indiquer que l’instruction est finie.
Certains doivent se dire que c’est g´enial, que le compilateur comprend tout de suite ce que
DDRA signifie. Et bien non. En r´ealit´e le registre DRRA, comme tous les registres, est un endroit
de la m´emoire dont l’emplacement change selon le microcontrˆoleur sur lequel on travaille. Il faut
donc pr´eciser au compilateur quel microcontrˆoleur est utilis´e afin qu’il puisse remplacer DDRA par
son adresse m´emoire. Heureusement pour nous, pas besoin de red´efinir `a chaque fois les adresses de
tous les registres utilis´es, il suffit de mettre au tout d´ebut du programme, avant mˆema la fonction
main, la d´eclaration suivante :
#include <iom128v.h>
La commande #include permet d’ins´erer dans le programme sur lequel on travaille des portions
de code d´efinis dans un autre fichier, en l’occurence iom182v.h
Maintenant il faut allumer la LED. Pour cela, il faut mettre `a 1 le bit 0 de PORTA. Ce qui se
fait via :
PORTA=0x01;
Etant donn´ee la vitesse d’´execution8 , il faut patienter un peu avant d’´eteindre la LED. On
utilise pour cela une boucle qui ne fait rien :
for(i=0;i<10000;i++);
La boucle for compte depuis i=0 tant que i<10000 en faisant i++ , c’est-`a-dire en augmentant i
de 1 `a chaque boucle. i ne tombe pas du ciel et doit ˆetre d´eclar´e au d´ebut de la fonction afin que
le compilateur sache ce qu’est i. On mettra donc la d´eclaration suivante avant DDRA=0x01 ; :
int i ;
4 Souvenez-vous,
PA0 est la patte no 0 du port A, num´
erot´
e 51
= entier en anglais
6 Voir en annexe, page 33 pour la conversion h´
exad´
edimal/binaire/d´
ecimal
7 Les bits sont num´
erot´
es de droite `
a gauche. En effet, le bit 0 est le bit le moins important et est donc mis le
plus `
a droite, tout comme les unit´
es sont plac´
es `
a droite des dizaines, eux-mˆ
emes `
a droite des centaines...
8 A 16 MHz, il faut 62.5ns pour faire l’instruction pr´
ec´
edente.
5 int
´
II.2. LA SEPARATION
DE CODE EN PLUSIEURS FICHIERS ET QUELQUES
FONCTIONS UTILES
13
Ainsi le compilateur sait que i est un entier.
On peut d´esormais ´eteindre la LED et attendre `a nouveau. On rajoute donc `a la suite du
programme les instructions :
PORTA=0x00 ;
f o r ( i =0; i <10000; i ++);
Il faut maintenant recommencer `
a allumer, attendre, ´eteindre, attendre... Pour cela, on englobe
les 4 derni`eres instructions dans un bloc :
while ( 1 ) {
les 4 instructions
}
Ainsi les 4 derni`eres instructions seront r´ep´et´ees ´eternellement.
Il reste `
a finir la fonction main par } et le programme est termin´e. Voici le programme au
complet :
#include <iom128v . h>
void main ( void )
{
int i ;
DDRA=0x01 ;
while ( 1 )
{
PORTA=0x01 ;
fo r ( i =0; i <10000; i ++);
PORTA=0x00 ;
for ( i =0; i <10000; i ++);
}
}
Sauvegardez le code (File/Save) dans le fichier code.c par exemple. Ensuite, indiquez quel
microcontrˆ
oleur est utilis´e via le menu Project/Option/Target/Device Configuration. Indiquez maintenant que le fichier code.c fait partie du projet en cliquant doit sur Files dans la partie
droite de votre ´ecran et en s´electionnant Add Files... Il ne reste plus qu’`a compil´e `a l’aide de
la touche F9 ou via le menu Project/Make Project. Si aucune erreur n’apparait dans le bas de
votre ´ecran, vous avez programm´e votre premier projet sur microcontrˆoleur AVR. F´elicitations !
Vous pouvez passer `
a la simulation, en page 19, ou alors en apprendre plus sur la programmation
C en continuant ci-dessous.
II.2
La s´
eparation de code en plusieurs fichiers et quelques
fonctions utiles
Vous avez peut-ˆetre remarqu´e que dans le programme pr´ec´edent les registres DDRA et PORTA
sont enti`erement modifi´es. Il y a des cas o`
u cela n’est pas souhait´e et o`
u on souhaite passer le bit
0 `a 1 sans modifier les autres bits. Nous allons donc pour cela cr´eer des fonctions suppl´ementaires.
Mais ces fonctions ont de grandes chances d’ˆetre n´ecessaires dans un autre projet, et on a pas trop
envie de les r´e´ecrire le moment venu. Nous allons donc les mettre dans un fichier s´epar´e qui sera
inclus dans les projets qui en ont besoin.
ˆ
14 CHAPITRE II. LA PROGRAMMATION DES MICROCONTROLEURS
EN C
II.2.1
La d´
efinition de fonctions utiles `
a l’aide de #define
Comment faire pour passer le n`eme bit du registre x `a 1 sans modifier les autres bits ? Le
registre x est de la forme ( y , y , y , n`eme bit , y , y , y , y ) o`
u y=0 ou 1. Il suffit de savoir9 que
(y OU 0)=y et que (y OU 1)=1. Il suffit donc de faire x OU ( 0 , 0 , 0 , 1 au n`eme bit , 0 , 0 , 0
, 0 ) pour obtenir le registre x identique sauf le n`eme bit qui est pass´e `a 1. Ceci se fait en C par
l’instruction :
x|=(1<
On peut de mˆeme ´ecrire x+=3 pour augmenter x de 3. Ensuite (x<
00110000 car 6 en binaire est 00000110.
Pr´esentons maintenant la d´eclaration #define. Par exemple, #define x 3 plac´ee au d´ebut
du programme, entre les #include et la premi`ere fonction, indique au compilateur qu’il doit
remplacer tout les x qu’il trouve par un 3. Ce remplacement ne doit se faire que si x n’est pas
d´efinit, on met donc cette d´eclaration dans un bloc :
#ifndef nom du bloc de d´efinition
#define nom du bloc de d´efinition
liste des d´efinitions
#endif
Une macro10 ne se termine pas par un point-virgule car celui-ci sera mis par le d´eveloppeur
dans son programme lors de l’appel de cet macro. Il est possible de faire une macro sur plusieurs
lignes selon le format suivant :
#define nom de la macro \
instruction1 ; \
instrution2 ; \
...
derni`ere instruction
Cette fois des ; sont mis car, je le rappele, le compilateur ne fait que remplacer le nom de la macro
par sa d´efinition.
II.2.2
Rajouter un fichier `
a un projet
Nous allons donc maintenant d´efinir 4 fonctions tr`es utiles pour tout projet. Pour cela, apr`es
avoir relanc´e et ouvert le projet debut si vous l’aviez quitt´e depuis, faites File/New. Entrez ensuite
les d´eclarations suivantes :
#i f n d e f
#define
#define
#define
#define
#define
FONCTIONS UTILES
FONCTIONS UTILES
SET BIT ( o c t e t , b i t ) ( o c t e t |= (1<< b i t ) )
CLEAR BIT( o c t e t , b i t ) ( o c t e t &= ˜(1<< b i t ) )
IS SET ( o c t e t , b i t ) ( ( o c t e t & (1<< b i t ) ) ! = 0 )
IS CLEAR ( o c t e t , b i t ) ( ( o c t e t & (1<< b i t ) ) = = 0 )
#endif
9 L’op´
eration
10 Une
OU se fait bit `
a bit avec les r`
egles suivantes : (0 OU 0)=0 ; (0 OU 1)=1 ; (1 OU 0)=1 ; (1 OU 1)=1
macro est une fonction ´
ecrite `
a l’aide d’un #define
II.3. LES INTERRUPTIONS AVEC IMAGECRAFT AVR
15
Enregistrez ce fichier sous le nom fonctions utiles.h dans le r´epertoire debut. Pourquoi .h
alors qu’avant c’´etait debut.c ? Et bien parce que la r`egle veut que les fichiers secondaires soient
dans un ”header”. Mais dans un header, on ne peut ´ecrire que des #define et non du code. Dans
ce cas, on s´epare les #define qu’on met dans un .h et les portions de code qu’on met dans un .c
qui porte le mˆeme nom que le .h.
Ensuite clic droit sur Header dans la partie droite de votre ´ecran puis Add Files... pour
ajouter les fonctions utiles au projet. Puis il faut dire au programme principal qu’il a le droit
d’utiliser ce fichier. Cela se fait en mettant :
#include ”fonctions utiles.h”
juste apr`es les autres #include. Les plus observateurs auront remarqu´e que l’ont a mis des guillemets au lieu de <> comme `
a la page 12. Les <> signifient que le fichier se trouve dans le r´epertoire
o`
u est install´e le compilateur alors que les guillemets indiquent que le fichier est dans le mˆeme
r´epertoire que le projet.
On peut maintenant utiliser les macros SET BIT et CLEAR BIT dans la fonction main. Par
exemple :
SET BIT(DDRA,0);
pour mettre `
a 1 le bit 0 de DDRA.
II.3
Les interruptions avec ImageCraft AVR
Nous avons vu, en page 9 que la gestion des interruptions est lourde `a faire en assembleur.
Heureusement, le C et Imagecraft sont l`a pour nous aider. Si les ´etapes 1,2 et 5 restent inchang´ees,
voil`a comment faire pour s’occuper des ´etapes 3 et 4. Pour l’exemple, nous allons allumer une LED
sur PA0 d`es que la patte PD0 passe `
a 1, PD0 ´etant la patte correspondant `a INT0, l’interruption
externe no 0.
Lors du d´eclenchement d’une interruption, le programme principal est interrompu et une certaine fonction s’ex´ecute. Dans notre cas, cette fonction va allumer la LED, appelons-la allume si
vous le voulez bien. Si tous les #include ont ´et´e correctement fait, la fonction s’´ecrit facilement
par :
void a l l u m e ( )
{ SET BIT (PORTA, 0 ) ; }
Il faut maintenant dire au compilateur que c’est cette fonction qui doit ˆetre appel´ees lors de
l’interruption externe. Pour cela, Imagecraft poss`ede la d´eclaration :
#pragma interrupt handler nom de la fonction:iv nom de l’interruption.
Dans notre exemple, on aura donc :
#pragma i n t e r r u p t h a n d l e r a l l u m e : iv INT0 ;
Ainsi, l’interruption INT0 ex´ecutera la fonction allume quand elle se d´eclenche.
ˆ
16 CHAPITRE II. LA PROGRAMMATION DES MICROCONTROLEURS
EN C
Reste `
a ´ecrire le reste et on obtient in fine :
#include <iom128v . h>
#include ” f o n c t i o n s u t i l e s . h”
#pragma i n t e r r u p t h a n d l e r a l l u m e : iv INT0
void a l l u m e ( )
{
SET BIT (PORTA, 0 ) ;
}
void main ( void )
{
SET BIT (DDRA, 0 ) ;
// l a p a t t e 0 du p o r t A e s t une s o r t i e
CLEAR BIT(DDRD, 0 ) ; // l a p a t t e 0 du p o r t D e s t une e n t r e e
EICRA = 0 x03 ;
EICRB = 0 x00 ;
EIMSK = 0 x01 ;
TIMSK = 0 x00 ;
ETIMSK = 0 x00 ;
asm ( ” s e i ” ) ;
while ( 1 ) ;
}
Les valeurs attribu´ees `
a EICRA, EICRB, EIMSK, TIMSK et ETIMSK sont trouv´ees d’apr`es
la datasheet. asm(”sei”) est expliqu´e dans le paragraphe suivant. Le compilateur se charge de
terminer la fonction traitant une interruption par l’instruction reti au lieu d’un ret habituel,
le d´eveloppeur n’a rien `
a se souci´e. Dans l’exemple donn´e, le microcontrˆoleur ex´ecute sans cesse
l’instruction while(1), c’est-`
a-dire ne fait rien. D`es que la patte PD0 passe `a 1, la fonction allume()
est appel´ee. Lorsqu’elle se termine, le microcontrˆoleur retourne o`
u il s’´etait arrˆet´e, c’est-`a-dire `a
l’instruction while(1).
II.4
L’assembleur dans un programme en C
Il est parfois n´ecessaire d’ins´erer des commandes assembleur directement dans le code C. Cela se
fait via l’instruction asm("instruction en assembleur") ; qui ins`ere l’instruction en assembleur
dans le code compil´e. Voici quelques exemples les plus fr´equents :
asm ( ”nop” ) ; // i n s t r u c t i o n ne f a i s a n t r i e n pendant un c y c l e d ’ h o r l o g e
asm ( ” s e i ” ) ; // l e s i n t e r r u p t i o n s s o n t p r i s e s en compte
asm ( ” c l i ” ) ; // l e s i n t e r r u p t i o n s ne s o n t p l u s p r i s e s en compte
Un autre cas o`
u le recours `
a l’assembleur est n´ecessaire est lorsque l’on cherche `a mettre
une temporisation d’une dur´ee pr´ecise. Dans ce cas, on n’a d’autres choix que de regarder le
code compil´e en assembleur pour voir combien de temps nos instructions durent afin d’adapter la
longueur de la boucle de temporisation.
II.5
Quelques compl´
ements sur le compilateur ICC AVR
Ce compilateur fournit un outil tr`es utile pour tous d´eveloppeurs : l’Application Builder qui
se trouve dans le menu Tools. Cet outil ´ecrit automatiquement les lignes de configurations du
microcontrˆ
oleur selon les besoins que vous aurez sp´ecifi´es. Ainsi, il devient facile de d´emarrer
un projet n´ecessitant la gestion de plusieurs Timers/Counters, d’interruptions multiples ou de
´
II.5. QUELQUES COMPLEMENTS
SUR LE COMPILATEUR ICC AVR
17
communication USART sans avoir `
a ouvrir la datasheet du microcontrˆoleur pour trouver quels
registres doivent ˆetre initialis´es et avec quelles valeurs.
J’ai remarqu´e quelques probl`emes avec le compilateur au sujet de la gestion des entiers longs.
En effet, si les op´erations sur les int et les float ne posent aucuns probl`emes, il n’en est pas de mˆeme
pour les long. Si vous souhaitez faire des calculs sur de grands entiers, pr´ef´erez donc l’utilisation
de float partout. Ce probl`eme est facilement rep´erable grˆace `a la simulation des programmes, ce
que je vais vous pr´esenter dans le chapitre suivant.
ˆ
18 CHAPITRE II. LA PROGRAMMATION DES MICROCONTROLEURS
EN C
Chapitre III
La simulation des progammes
Apr`es avoir ´ecrit son code, on aimerait bien voir comment les instructions s’enchaˆınent pour
voir si tout fonctionne comme pr´evu. Cela se fait grˆace `a AVR Studio 4, logiciel gratuit d´evelopp´e
par ATMEL. Courrez le t´el´charger sur />puis installez-le.
La simulation est conforme au comportement r´eel du microcontrˆoleur dans la mesure o`
u le
simulateur est correctement programm´e. A l’heure o`
u j’´ecris ces lignes, des bugs subsistent. Par
exemple, la gestion des Timer/Counter, et particuli`erement de la g´en´eration de signaux PWM, ne
marche absolument pas. Il ne faut donc pas s’y fier dans ces domaines. De mˆeme, l’impl´ementation
des programmes dans le microcontrˆ
oleur via le cˆable AVR ISP (voir en page 23) pr´esente parfois
certaines difficult´es incompr´ehensibles. Ce dernier point peut ˆetre r´esolu en utilisant conjointement
les version 3 et 4 de AVR Studio, la version 3 ne pr´esentant aucun probl`eme avec AVR ISP.
Peut-ˆetre ces probl`emes seront-ils r´esolus dans les futurs versions de AVR Studio 4 lorsque vous
souhaiterez l’utiliser, alors essayez donc si la version 4 vous convient.
III.1
Premiers pas avec AVR Studio 4
Apr`es l’avoir lanc´e, faites File/Open et ouvrez le fichier debut.cof. Vous avez ensuite le menu
suivant qui s’affiche1 :
o`
u vous choisissez AVR Simulator et ATmega128.
1 Si ce n’est pas la premi`
ere fois que vous ouvrez le fichier, AVR Studio 4 vous signale que ce fichier est d´
ej`
a
associ´
e `
a un projet et vous demande si vous voulez ouvrir ce projet. R´
epondez oui `
a moins que vous ne vouliez
retomber sur la fenˆ
etre affich´
ee ci-dessus.
19
20
CHAPITRE III. LA SIMULATION DES PROGAMMES
Apr`es avoir cliquez sur Finish, l’´ecran suivant devrait apparaitre :
Voyons `
a quoi servent les diff´erentes parties de cet ´ecran.
III.2
Workspace
C’est l`
a que vous pouvez voir l’´etat de votre microcontrˆoleur. Vous pouvez ainsi voir les valeurs
de tous les registres du microcontrˆ
oleur mais aussi les modifier en temps r´eel. A cˆot´e de chaque
registre se trouvent des cases symbolisant les bits du registre. La premi`ere case est le bit 7 du
registre2 et ainsi de suite. Si la case est colori´ee, le bit est `a 1, il est `a 0 sinon. Dans l’exemple
donn´e, PORTA=0x21, soit le bit 0 et 5 `a 1.
2 Rappelez-vous
que les bits sont repr´
esent´
es dans l’ordre inverse : page 12
III.3. PROGRAMME EN COURS
21
Un autre outil important de cette fenˆetre est la Stop Watch. C’est un chronom`etre qu’on remet
a` z´ero en cliquant droit dessus et en choisissant Reset StopWatch. Cela permet de savoir le temps
´ecoul´e entre deux instructions quelconques. Attention, le calcul est fait `a une certaine fr´equence
d’horloge, visible juste au-dessus de la Stop Watch. La fr´equence de l’horloge peut ˆetre modifi´ee
via le menu Debug/AVR Simulation Options.
III.3
Programme en cours
C’est l`
a qu’on peut suivre o`
u en est le programme dans son d´eroulement. La prochaine instruction `a ˆetre ex´ecut´ee est indiqu´ee par la fl`eche jaune. C’est ici qu’on peut placer des Breakpoints3 .
Pour mettre un Breakpoint ou en enlever un, il suffit de faire un clic droit sur l’instruction o`
u l’on
souhaite installer/enlever un Breakpoint puis de choisir Toggle Breakpoint.
Un autre outil tr`es utile accessible depuis cette fenˆetre est de pouvoir suivre en temps r´eel la
valeur des variables du programme. Pour cela, on selectionne cette variable, on clique droit et on
choisit Add To Watch. C’est ce qui a ´et´e fait dans l’exemple pour la variable i.
III.4
Contrˆ
ole du d´
eroulement
Cette barre contrˆ
ole le d´eroulement du programme. Les principaux boutons sont :
Start et Stop Debugging : Comme vous devez vous en doutez, ces deux boutons permettent
de commencer et d’arrˆeter le d´eroulement du programme.
3 Points
d’arrˆ
et, voir Contrˆ
ole du d´
eroulement en page 21
22
CHAPITRE III. LA SIMULATION DES PROGAMMES
Run : Permet d’ex´ecuter le programme. Dans ce mode, le Workspace et la fenˆetre Watch sont
inacessibles. Ce mode se termine soit en cliquant sur Break, soit lorsque le logiciel rencontre
un Breakpoint. Ce mode est tr`es utile pour sortir de boucles d’attente de longue dur´ee en
mettant un Breakpoint sur la premi`ere instruction apr`es la boucle. Associ´e `a la Stop Watch,
on peut savoir la dur´ee de la boule (cf. page 21).
Break : Permet d’interrompre l’ex´ecution du programme lors qu’on est en mode Run ou AutoStep.
Reset : Comme son nom l’indique, recommence le programme depuis le d´ebut.
Step Into : Mode pas-`
a-pas. Ex´ecute la seule instruction indiqu´ee par la fl`eche jaune. Si cette
instruction fait appel `
a une sous-fonction, la fenˆetre du programme en cours s’ouvre sur cette
sous-fonction et le d´eveloppeur peut ex´ecuter les instructions de cette sous-fonction en mode
pas-`
a-pas.
Step Over : Mode pas-`
a-pas ´egalement, mais `a la diff´erence de Step Into s’il y a appel d’une
sous-fonction, celle-ci est ex´ecut´ee enti`erement sans que le d´eveloppeur ne puisse suivre son
d´eroulement.
Step Out : Termine la fonction en cours d’ex´ecution puis retourne au programme qui l’a appel´ee
en redonnant la main au d´eveloppeur.
Run To Cursor : Ex´ecute le programme jusqu’au curseur4 .
AutoStep : Equivalent `
a Run mais ici le d´eveloppeur voit le Workspace et la fenˆetre Watch.
Le d´eroulement est plus lent qu’en mode Run mais on peut voir ce qui se passe dans le
microcontrˆ
oleur ou les variables du programme.
III.5
Choix de la vue
Register et Memory Window : Affichent la vue s´electionn´ee dans la fenˆetre Workspace.
Watch : Affiche la fenˆetre Watch qui permet d’afficher la valeur de variables choisies, voir page
21.
Toggle Disassembler Window : Permet d’afficher le code assembleur dans la fenˆetre du programme en cours et d`es lors d’ex´ecuter les instructions en assembleur au pas-`a-pas. Tr`es utile
pour voir comment le programme a ´et´e compil´e notamment pour connaitre les instructions
utilis´ees dans une boucle afin de pouvoir adapt´e le nombre d’occurences pour obtenir une
dur´ee pr´ecise.
III.6
Output view
Cette fenˆetre permet de voir si la simulation se d´eroule bien, par exemple s’il n’y a pas eu
d’erreurs de chargement du projet. En r´esum´e, c’est l`a que seront affich´es les messages provenant
du simulateur.
4 La
barre verticale qui clignote `
a l’endroit o`
u le texte tap´
e est ins´
er´
e
Chapitre IV
L’impl´
ementation r´
eelle sur le
microcontrˆ
oleur
Si tout marche comme il faut sur le papier et sur la simulation, passons aux choses s´erieuses et
voyons ce que ¸ca donne dans la r´ealit´e. Et bien c’est l`a que les choses se gˆatent et je dois avouer
que le chemin jusqu’au microcontrˆ
oleur fonctionnel est long et sem´e d’embˆ
uches. Mais avec ce
document, tout devrait aller (enfin, j’esp`ere). Construisons donc une carte pour programmer cet
ATmega128. Cette programmation ce fera via un cˆable AVR ISP, disponible chez de nombreux
fournisseurs de mat´eriel ´electronique.
IV.1
L’alimentation
Le microcontrˆ
oleur est aliment´e en 0V - 5V, aussi stable que possible. Evidement, on relie les
masses ensemble sur le 0V d’une part, et les Vcc ensemble sur le 5V d’autre part. De plus, doivent
ˆetre aussi reli´ees `
a Vcc deux pattes : AV cc - l’alimentation du convertisseur analogique-num´erique
- et P EN - inutilis´e pour la programmation via AVR ISP.
IV.2
L’horloge
Plusieurs solutions s’offrent `
a vous pour cadencer le microcontrˆoleur. On verra plus loin comment indiquer au microcontrˆ
oleur la solution choisie, en page 27
L’ocillateur interne : Certains microcontrˆoleurs de la famille AVR poss`edent un oscillateur interne, par exemple l’ATmega128 en poss`ede quatre fonctionnant `a 1, 2, 4 ou 8 MHz. Cette
solution offre l’avantage d’ˆetre facile `a mettre en oeuvre (rien `a faire) mais a l’inconv´enient
d’avoir une fr´equence instable selon la tension d’alimentation, la temp´erature, etc... et surtout de ne pas pouvoir fonctionner jusqu’au 16 MHz maximum de l’ATmega128.
L’horloge externe : Il suffit de fournir un signal carr´e sur la patte XTAL1, mais encore faut-il
pouvoir le g´en´erer ce signal.
L’oscillateur RC externe : Cette solution pr´esente l’avantage de pouvoir aller plus haut en
fr´equence (jusque 12 MHz sur l’ATmega128) et de choisir des fr´equences autres que celles de
l’oscillateur interne mais pr´esente encore le gros inconv´enient d’ˆetre instable en temp´erature
et tension d’alimentation.
Le quartz ou le r´
esonnateur : C’est la solution pour ˆetre pr´ecis, stable et atteindre les 16 MHz
mais peut pr´esenter des difficult´es de mise en oeuvre. Les quartz `a deux pattes se branche sur
XTAL1 et XTAL2 avec deux condensateurs entre chaque pattes et la masse, comme indiqu´e
sur le sch´ema ci-dessous.
23
