Systèmes Embarqués: Chapitre V Développement Du Logiciel Embarqué

Systèmes Embarqués
Ce(tte) œuvre est mise à

disposition selon les termes de
Chapitre V
la Licence Creative Commons
Attribution - Pas d’Utilisation
Développement du logiciel embarqué
Commerciale 4.0 International.
1 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman
OUTLINE
1) Exploration Matérielle
Mémoires, Interruptions, Conversion A/N, N/A, Timers, Interfaces de
communication
2) Langages de programmation pour l’embarqué
3) Approches de conception
Déroulement cyclique, Déroulement quasi-parallèle et évenementiel
(interruption/RTOS), State diagram, …
4) Sécurité des systèmes

EXPLORATION MATÉRIELLE

Mémoires dans les microcontrôleurs
Cas du ATmega328

Cas du ATmega328
• Mémoire Flash :
• Programmable en ligne et sur carte
• 32 Koctets, organisés en 16K de 16
bits
• Program Counter (PC) = 15 bits

Cas du ATmega328
• EEPROM :
• 1 KOctets,
• Accessible en lecture/écriture
• Adressable par SFRs:
• EEPROM Address Register, EEPROM Data Register,
• EEPROM Control Register

II: Atmega8 – Basic features

Cas du ATmega328
• Mémoire SRAM :
• 32 GPR’s et
• 64 SFR’s mappée sur
l’espace mémoire de la
SRAM
• 2 Koctet de SRAM
interne est accessible à
partir de l’addresse
0x0100 à 0x08FF
• 5 Modes d’addressage
Directe and indirecte

Cas du ATmega328
• General Purpose Registers:
• Bien que n'étant pas
physiquement implémenté en
tant que SRAM, les GPR peuvent
être adressés à partir de la SRAM
• X, Y and Z registres 16-bit utilisés
pour l’adressage indirect,
• Configuration des E/S de l’UAL :

• 1x 8-bit operand, 8-bit result
• 2x 8-bit operands, 8-bit result
• 2x 8-bit operands, 16-bit result
• 1x 16-bit operand, 16-bit result

General Purpose I/O
• Un port d'entrée/sortie communique avec l'extérieur du microcontrôleur
par le biais de plusieurs fils (broches), en général regroupés par paquets de
8 ou 16.
• Un port d'entrée / sortie a pour rôle d'imposer (Output) ou de lire (Input)
un niveau de tension (associé aux niveaux logiques '0' ou '1' ) sur
l'ensemble de ses broches.
• Selon le microcontrôleur, le niveau logique '1' peut être 5V, 3V3 ou encore
1V8.
• Des registres accessibles en lecture ou écriture par le cœur pour configurer
et utiliser le périphérique.
• au minimum deux registres de configuration (l'un qui spécifie pour chaque broche sa
direction, l'autre spécifiant la technologie utilisée)
• et un registre d'utilisation qui est à l'image logique des broches.
General Purpose I/O
• Technologies des ports en sortie:
Mode Push Pull Mode Open Drain
 le niveau logique de la broche est  Le port ne peut imposer que le niveau logique '0'.
imposé par le port
 Le niveau '1' est fixé par un circuit extérieur.
General Purpose I/O
• Technologies des ports en entrée: Mode Pull Down
Mode Floating input
 le circuit extérieur impose le potentiel

de la broche
Mode Pull Up
 Le potentiel de la broche se retrouve au potentiel de

référence (VCC ou GND) grâce à la résistance de rappel.
 Le circuit extérieur doit avoir une résistance de sortie
faible devant R, sinon, la tension chute
General Purpose I/O
Cas du ATmega328
• Le ATmega328 dispose de 23 lignes d'entrée/sortie constituées en 3 ports de 8
bits chacun.
• portB, portC, portD
• Tolèrent une tension de 5V
• La plupart des lignes sont connectées en interne à des contrôleurs de
périphériques du microcontrôleur qui les utilisent, selon le cas, comme entrée ou
comme sortie.
• Le pilote de sortie peut fournir un courant de 20 mA
• 3 registres E/S pour chaque port:
• Registre des données (r / w):
• PORTB, PORTC, PORTD
• Registre de direction des données (r / w):
• DDRB, DDRC, DDRD
• Registre port des broches d'entrée (r):
• PINB, PINC, PIND

General Purpose I/O
Cas du ATmega328
• Diodes de protection sur
VCC et GND,
• Pullup interne peut être
utilisée pour les broches
d'entrée.

General Purpose I/O
Cas du ATmega328
• Block diagramme
C-Example 1 - Configure Pin B3 as output, set output level to VCC:
DDRB |= (1<<3); PORTB |= (1<<3);
C-Example 2 - Configure Pin D2 as input with pullup, read pin value:
DDRD &= ~(1<<2); PORTD |= (1<<2);

DDRD = DDRD & 1111 1011 ~(0000 0100)
uint8_t x = (PIND & (1<<2))>>2; 0000 0001

General Purpose I/O
Cas du ATmega328
• Fonctions
Alternatives

Contrôleur d’interruption
• Une interruption, est un événement externe ou interne au système qui interrompt le
déroulement du programme en cours et oblige le système à exécuter une routine particulière.
• Le système d’interruption est un dispositif incorporé au séquenceur qui détecte les signaux
d’interruption. Ces signaux arrivent de façon asynchrone, à n’importe quel moment, mais ils ne
sont pris en compte qu’à la fin de l’opération en cours.
• Événements externes
• Changement sur une entrée spécifique appelée entrée d’interruption. (tout µC en a au moins
une),
• Changement sur un bit de port.
• Événements internes
• Débordement Timer
• Fin écriture EEPROM
• Fin de conversion A/N
• ……

Déroulement d’une interruption
Programme principal
main() Routine d’interruption
début Si une interruption doit modifier le

Initialisations déroulement du programme principal,
on fera en sorte que sa routine
interruption Actions modifiera une variable globale qui
Actions 1 sera testée dans le programme
Boucle de principal.
fonctionnement
interruption Fin
normal.
Actions 2
Cette routine peut se produire à
n’importe quel moment du
Fin programme principal.

Déroulement d’une interruption Mémoire
0000 0001 • un signal arrive

IP
Compteur instruction 0000 0001
0101 -Interne
0000 0001
Unité de ou
contrôle 0000 0111
Horloge UC -Externe
0010 0101
0001 0001
Unité arithmétique et 0000 0100

logique
0101 0010
UAL 0001 0001
Registres

Déroulement
Interruption
d’une interruption Mémoire
0000 0001
IP • l’adresse en cours est sauvegardée
021301
10
Unité de 0000 0001 En fonction de l’interruption, l’UC

contrôle
0000 0111 modifie l’adresse vers le sous-
UC
Horloge 0101 programme de traitement de
0010 0101
l’interruption
0001 0001

logique
0101 0010
UAL 0001 0001
0000 0100
Registres 0101 0010
0001 0001
0000 0111
• Les instructions se déroulent
IP 0010 0101
Compteur instruction
1023
0001 0001
Unité de
contrôle
UC 0000 0100
Horloge 0101
0101 0010
0001 0001

logique
0101 0010
UAL
0001 0001
0000 0001
0000 0001
Registres 0000 0001

0000 0001 A la fin du sous-programme le

IP contrôle est rendu à l’adresse
0101 interrompue
Unité de 0000 0001
contrôle
0000 0111
UC
Horloge
0010 0101
0001 0001

logique
0101 0010
UAL 0001 0001
Registres

Cas du ATmega328
• ATmega328 a 26 source interruption
• 1 source de Reset
• 2 sources d’interruption externe
• Interruption sur changement d’état des E/S peut s’appliquer sur les 24 pins
des GPIO,
• Evénement sur les périphériques internes.

24
Cas du ATmega328
Sources d’interruption
• Si une seconde interruption intervient

pendant le traitement de la première,
le programme le traitera aussitôt la
première fini.
• La priorité des interruptions va par
ordre croissant
exp : INT1 prioritaire sur ADC

Cas du ATmega328
• Lorsqu'une interruption se produit :
• le microcontrôleur termine l'instruction en cours,
• stocke l'adresse de l'instruction suivante sur la pile
• et commence à exécuter des instructions dans la routine de
service d'interruption (ISR) désignée correspondant à la
source d'interruption particulière.
• Il éteint également le système d'interruption pour empêcher
d'autres interruptions pendant que l'on est en cours.
• L'exécution de l'ISR est effectuée en chargeant l'adresse de
début du sous-programme de service d'interruption
spécifique pour cette interruption dans le compteur de
programme.
• La routine de service d'interruption commence à être
exécutée. L'exécution de l'ISR se poursuit jusqu'à ce que le
retour de l'instruction d'interruption (reti) soit rencontré.
• Le pointeur d’instruction restitue sa valeur pour revenir au
programme principal.

Convertisseur A/N et N/A
Rôle des convertisseurs
Pré- Te P P Post-
s(t) traitement CAN o
r CPU
o
r CNA traitement y(t)
t t
se (t ) = s( kTe ) ŝk ŷk ŷ( kTe )
• Assurent la conversion de format entre des données d’E/S

analogiques et le CPU du microcontrôleur
• Les blocs de prétraitement et de post-traitement gèrent les
problèmes d’interface entre les E/S et les convertisseurs

Conversion N/A
• Convertit un code binaire en une tension ou courant continu
d’amplitude équivalente
• En pratique un filtre est requis après la sortie
Sortie analogique
Entrée numérique Sortie analogique
par paliers
bit 0
011010010101010100101
101010101011111100101
000010101010111110011
010101010101010101010
111010101011110011000
CNA n bits Filtre
100101010101010001111
bit n
 x0 20 + x1 21 + x2 2 2 +  + xn −1 2 n −1 
Vout =k n 
 2 
Tension de référence k

Conversion N/A
Exemples de montage

Conversion A/N
• Convertit une tension ou courant analogique en un code binaire équivalent
• Opère souvent en échantillonnant d’abord la valeur analogique à convertir (rôle
de l’E-B ou « S&H »)
011010010101010100101
101010101011111100101
000010101010111110011
010101010101010101010
111010101011110011000
100101010101010001111

Conversion A/N
Exemples de montage

Conversion A/N
Paramètres à considérer dans un Convertisseur N-A
code/tension
• La résolution : Représente la valeur analogique
correspondant à 1 bit (pas de quantification) Q
• Dépend du nombre de bits utilisés et d’un paramètre de
référence (souvent une tension)
• Temps de stabilisation « settling time » : temps
entre le départ de la transition et la nouvelle valeur à
la précision requise (0.5 LSB par ex.) tension/code
• Le rapport signal/bruit Vref Vref : Tension de référence
Q=
2n − 1 n : Longueur du mot binaire
• La linéarité et les autres erreurs
• Type d’interface
Conversion A/N
Nombre de bits et résolution
• Gamme de température de 0 K à 300o K à convertir en une tension entre 0
et 2.5 V, numérisée avec des convertisseurs A/N de 8 et 10 bits
• 8 bits :
• 2.5 / 28 -1= 0.0098 V, ou environ 10 mV par pas
• En degrés K, cela correspond à 300o K / (28-1)= 1.2o K par pas
• 10 bits :
• 2.5 / (210 -1)= 0.00244V, ou environ 2.4 mV par pas
• En degrés K, cela correspond à 300o K / (210 -1)= 0.29o K par pas
• Oui , mais le niveau de bruit est-il inférieur à 2.4 mV ?
• En général, on parcourt le chemin inverse : on part de considérations de

résolution pour trouver le nombre de bits

Conversion A/N Constituants de la chaîne d’acquisition
Capteur 1 Capteur i Capteur n
conditionneur
amplificateur
filtre
Multiplexeur analogique
S&H
logique
CAN

Conversion A/N Constituants de la chaîne d’acquisition

Périphérique ADC du ATmega328
• Résolution 10 bits (précision 8 bits sur ADC4 et ADC5)
• Jusqu'à 15 kSPS à la résolution maximale
• 6 canaux multiplexés
• Plage de tension d'entrée 0 – VCC
• Tension de référence interne de 2,56 V sélectionnable
• Mode de conversion libre exécution ou unique
• Interruption à la fin de la conversion

• Convertisseur par
approximation
successive


• Modes de conversion:
• Single Conversion :
• vous devez lancer chaque conversion à part.
• 25 cycles d'horloge
• Free Runing :
• vous ne lancez la conversion qu'une seule fois, puis l'ADC lance automatiquement
la conversion suivante dès que la conversion précédente est terminée.
• 25 cycles d'horloge pour la première conversion « étendue » , 13 cycles pour le
reste,
• La conversion analogique-numérique n'est pas instantanée, cela
prend du temps. Cette durée dépend du signal d'horloge utilisé par
l'ADC. Le temps de conversion est proportionnel à la fréquence du
signal d'horloge ADC, qui doit être comprise entre 50 kHz et 200
kHz.
• Le module ADC contient un prescaler qui divise l'horloge du
système en une fréquence d'horloge ADC acceptable.
• Par exemple, si vous utilisez un signal d'horloge ADC de 200 kHz,
• Temps de conversion normale = 13 / 200e3 = 65us
• Temps de conversion étendue = 25 / 200e3 = 125us.

Exercice 1
Une tension de référence de 2,56V est utilisée comme référence pour le convertisseur d'un
ATMega328 sur 10 bits.
a) Quelle est la résolution en tension de ce convertisseur ? Q= 2,56V/1023 = 2,5mV

b) A quelle tenson correspond le nombre 0x12F ? V= N*q = 303 * 2,5mV = 757 mV
c) Une tension de 2V est présente sur l'entrée. Quelle sera la valeur de la conversion ? N = 2V/q =
800
d) Un thermomètre LM35C peut mesurer une température entre -40 °C et +110 °C avec une
précision de 1,5 °C et une résolution de 10mV/°C. Quel nombre retournera le convertisseur pour
une température de 45 °C ?

Exercice 2
a) Trouver les valeurs des tensions en fonction
de l'appui sur les boutons poussoirs. On
supposera pour ce calcul que Vcc = 5V.
b) Calculer les valeurs numériques 10 bits

correspondantes.
c) Écrire l’algorithme complet capable d'identifier

l’interrupteur appuyé.

Exercice 3
Déterminer la fréquence d’échantillonnage du convertisseur si on considère la configuration
suivante :
- Horloge oscillateur = 1 MHz,
- ADC prescaler = CK/128,
- Mode de conversion : free running

Périphérique Timer
Qu’est ce qu’un Timer?
• Un compteur numérique est un circuit
à base de bascules synchrones qui
effectue des cycles d’incrémentation
(ou de décrémentation).
• Lorsque l’événement de
déclenchement est une horloge de
fréquence constante, on obtient un
timer.
• ATmega328 dispose de 3 timers

appelés timer0, timer2 (8 bits) et
timer1 (16bits)

Applications du Timer
(a) Mesure de temps
entre deux
événements
(b) Mesure de la période
entre deux
impulsions
(c) Mesure de la largeur
d’une impulsion
Utilisation de la scrutation ou des interruptions

Cas du ATmega328
• On peut changer le comportement du Timer en agissant sur les
registres internes
• TCCRx - Timer/Counter Control Register. Configuration du prédiviseur.
• TCNTx - Timer/Counter Register. La valeur en cours du timer.
• OCRx - Output Compare Register
• ICRx - Input Capture Register (seulement pour timer 16bit)
• TIMSKx - Timer/Counter Interrupt Mask Register. Activation de
l’interruption sur Timer
• TIFRx - Timer/Counter Interrupt Flag Register. Indique l’occurrence d’une
interruption sur Timer

Périphérique Timer : Unité de comptage
Cas du ATmega328
• Choix de la source de l’horloge • Valeur maximale de comptage est

• Interne : Fréquence CPU • 256 pour Timer 8bit,
• Externe : front montant/descendant (mode
comptage) • 65536 pour Timer 16bit.
• À diviser par une constante de prédivision
(1,8,64,256,1024)

Périphérique Timer : Unité de comparaison
Cas du ATmega328

Périphérique Timer : Structure matérielle
Cas du ATmega328

Périphérique Timer : Modes de fonctionnement
Cas du ATmega328
• Normal Mode – always counts up, no clear, counter just overruns
• Clear Timer on Compare match (CTC mode)
• Fast PWM Mode
• Phase Correct PWM mode

Cas du ATmega328
• Clear Timer on Compare match (CTC mode)
OCn

Cas du ATmega328
• Fast PWM Mode

Cas du ATmega328
• Phase Correct PWM mode

Exercice Fpb0 = Ftov/2
Ftov = Ftmr0 / (256-ValInit)
Ftmr0 = Fclk / PSC
• On dispose d’un microcontrôleur cadencé à
4Mhz. Le Timer0 est utilisé pour générer une
interruption qui fait inverser l’état de la sortie
PB0. Ce Timer est configuré comme suit :
• Clock interne,
• Prescaler = 8
a)Donner en justifiant la fréquence d'oscillation
du bit b0 du PORTB?
b)Que devient cette fréquence si TCNT0 est
initialisé à chaque interruption à la valeur
100.
c)On veut maintenant générer un signal de
fréquence 1 kHz. Pour cela :
- Calculer la valeur de la pré division
- Calculer la valeur de décomptage
- Comment faire pour générer un signal de
sortie de rapport cyclique 1/4.

Interfaces de communication série
Interface UART/USART
• Un émetteur-récepteur asynchrone
universel
• Une trame UART est constituée des bits

suivants :
• un bit de start toujours à 0 : servant à la
synchronisation du récepteur
• les données : la taille peut varier
(généralement entre 5 et 9 bits)
• éventuellement un bit de parité paire ou
impaire
• et un bit de stop toujours à 1 (la durée peut
varier entre 1, 1,5 et 2 temps bit)
• Le niveau logique de repos est le 1.

Interface UART/USART du ATmega328
• Générateur interne de fréquence de
cadencement
• Echanges de données sur 8 ou 9 bits
• Communication en Full-duplex (peut
émettre et recevoir en meme temps)
• Protection des débordements
• Détection de faux départs de
transmission
• Filtrage de l'entrée
• Plusieurs interruptions programmables
sur le mode émission et réception

Interface SPI
• Opère en mode Full-duplex.
• Les circuits communiquent selon un schéma maître-esclaves, où le
maître s'occupe totalement de la communication. Plusieurs esclaves
peuvent coexister sur un même bus, dans ce cas, la sélection du
destinataire se fait par une ligne dédiée entre le maître et l'esclave
appelée chip select
• Le bus SPI utilise quatre signaux logiques :
• SCLK — Serial Clock, Horloge (généré par le maître) Pin13
• MOSI — Master Output, Slave Input (généré par le maître) Pin11
• MISO — Master Input, Slave Output (généré par l'esclave) Pin12
• SS — Slave Select, Actif à l'état bas (généré par le maître) Pin10

Interface I2C
• I2C est un bus série synchrone bidirectionnel half-duplex.
• Plusieurs équipements, soit maîtres, soit esclaves, peuvent être connectés
au bus.
• Les échanges ont toujours lieu entre un seul maître et un (ou tous les)
esclave(s), toujours à l'initiative du maître (jamais de maître à maître ou
d'esclave à esclave). Cependant, rien n'empêche un composant de passer
du statut de maître à esclave et réciproquement.
• La connexion est réalisée par l'intermédiaire de deux lignes :
• SDA (Serial Data Line) : ligne de données bidirectionnelle,
• SCL (Serial Clock Line) : ligne d'horloge de synchronisation bidirectionnelle,
• Il ne faut également pas oublier la masse qui doit être commune aux
équipements.
• Les 2 lignes sont tirées au niveau de tension VDD à travers des résistances
de pull-up (RP).

LANGAGES DE PROGRAMMATION POUR
L’EMBARQUÉ

Langages logiciels
• A l'origine, seulement des codes binaires
• 1100 0101 1111 0001
• Le langage d'assemblage était plus facile
http://www.computerhistory.org/revolution/minicomputers/11/331

Langages de description logicielle
• La liste est grande…

•Langages conçus pour l’embarqué

•Langages utilisés pour l’embarqué

•Langages utilisés pour l’embarqué

Histoires des langages clés
 Dennis M. Ritchie dans les laboratoires AT & T
•C Bell (1972)
 "... un langage de programmation
• C++ généraliste ..."
• Java  D'abord utilisé pour Unix
• JavaScript  Encore plus commun pour embarqué
• Python  Langage de haut niveau avec des capacités de

bas niveau
• Lua  Puissant, donc dangereux
•C
1978
• C++ Brian W. Kernighan
/ Dennis M. Ritchie
• Java
• JavaScript 1983
une définition
• Python explicite et
indépendante
de la machine
pour le C
• Lua
 La mise en œuvre de C orienté objet la plus
•C réussie [en tout cas en embarqué]
• C++  Conçu pour les grands projets
• Java
• JavaScript
• Python
• Lua
•C  Développé par Sun [maintenant Oracle] pour
définir un code embarqué portable,
• C++
 Principalement utilisé pour les applications
• Java Internet au début,
• JavaScript  Trouve sa place dans les systèmes embarqués

 Disponibilité de Variantes temps réel
• Python
 Convient aux applications post-déploiement
• Lua  Syntaxe assez similaire à C ++
•C  "Le langage assembleur du Web"
• C++  Rien à voir avec Java
• Java  Utilisé pour créer des fonctionnalités sur des
• JavaScript pages Web
• Python  Également utilisé dans de nombreux appareils
• Lua embarqués portables

 Pensé comme un langage de script
•C
 Mais plus polyvalent que ça
• C++
 Interprété : bytecodes exécuté par une
• Java
machine virtuelle [comme Java]
• JavaScript
 Philosophie minimaliste
• Python
 Très large gamme de bibliothèques disponibles
• Lua
•C  Langage d'extension de programme, conçu
pour épauler une programmation procédurale
• C++
générale, à l'aide d'équipements de description
• Java de données.
• JavaScript  Lua est destiné à être utilisé comme un

puissant et léger langage de script par
• Python
n'importe quel programme qui en aurait besoin
• Lua  Petit et portable - source ouverte
CHAINE DE COMPILATION DANS LA
PROGRAMMATION EN C

Du langage informatique au
langage machine…
• Les langages informatiques peuvent être groupés en fonction du
processus de traduction utilisé pour convertir les instructions en code
binaire:
• Assembleurs
• ASM, List.
• Interpréteurs
• Python, JavaScript, VB,…
• Compilateurs
• C/C++, Pascal,…

Interpréter vs Compiler un programme
Processus d’interprétation :
• Une instruction est extraite (fetch) du code source d'origine.
• L'interprèteur vérifie la seule instruction pour les erreurs. (Si une erreur est trouvée, la
traduction et l'exécution cessent, sinon ...)
• L'instruction est traduite en code binaire.
• L'instruction codée binaire est exécutée.
• Le processus d'extraction et d'exécution se répète pour l'ensemble du programme.
Processus de compilation :
• Le compilateur prend tout le programme en entrée, il n'a pas besoin d'être compilé à
chaque fois
• Les erreurs sont affichées après que le programme entier est vérifié
• Le code d'objet intermédiaire est généré
• L’exécution se fait en entier sur le programme généré
Chaine de compilation C
Programmateur Compilateur C

Flux de données d’un compilateur C
#include Bibliothèques pré compilées
<stdio.h> (fichiers objet)
Bibliothèques Fichiers
en C (texte) header
main() *.c *.h
{ puts(" Bonjour
à tous ");
}
Éditeur de lien
Préprocesseur Compilateur C LINKER
remplace les Transforme le fichier C en un Lie (donne des adresses
#define et effectue fichier objet (code machine), aux fonctions) tous les
les #include les fonctions pré compilées fichiers objets et crée un
Fichier sont déclarées dans les fichiers fichier exécutable
source C *.h
contenant la
fonction
main
Fichier de Programme
symboles exécutable
pour debug *.hex

Processus de programmation
Programmation hors ligne, hors circuit
• Charger le fichier hex du programme compilé dans la

mémoire programme du microcontrôleur
• Principalement utilisé pour charger le BootLoader Programmateur universel de mémoires.

Programmation hors ligne, sur circuit (Programmation In-situ)

• Un circuit interne sur la carte à microcontrôleur permet de générer
les tensions spécifiques de programmation à partir de la tension
d'alimentation.
• Il permet aussi de communiquer avec le programmateur via une
liaison série.
• La plupart des composants programmables par ISP utilisent une
variante du protocole JTAG dédiée à la programmation ;
• Cela permet ainsi de faciliter l'intégration de tels dispositifs avec des
procédures de tests automatisés.
• Bootloader est un petit programme chargé dans le microcontrôleur à programmer.
• Son rôle est de programmer en ligne et sur circuit le microcontrôleur.
• Il permet de télécharger des programmes sur le microcontrôleur via des interfaces
series (RS232/USB).
Code chargé par
un équipement
programmateur
Programmation en ligne,
sur circuit
Code chargé par

le Bootloader

Exemple 1- Chaîne
de compilation C pour AVR

Exemple 2- Processus Arduino de
construction et de chargement pour AVR

Exemple 2- Processus Arduino de construction
et de chargement pour AVR
https://grahamwideman.wikispaces.com/Arduino+--+Project+structure+and+build+process
Exemple 2- Processus Arduino de construction
et de chargement pour AVR
https://grahamwideman.wikispaces.com/Arduino+--+Project+structure+and+build+process
APPROCHES DE CONCEPTION

Approches de conception
• La fonctionnalité d’un système peut être toujours décomposée en
sous-fonctions (modularisation).
• Il existe plusieurs stratégies pour exécuter ces sous-fonctions :
• Déroulement cyclique,
• Déroulement événementiel,
• RTOS, etc.
• Il est crucial d’analyser le déroulement du programme durant la phase
de conception afin de pouvoir définir une structure adéquate pour ce
dernier.

Approches de conception
• Exemple à considérer : Voltmètre digitale (VMD)
Cahier des charges:

• Temps de conversion A/D : 75 ms.
• Afficheur LCD, dont l’intensité commence à diminuer après 50 ms et doit par conséquent être « rafraîchis »
• Pas de buffer à l’entré du LCD, pour des raisons de coûts.

Déroulement cyclique
• Toutes les fonctions du programme sont Fonction
1
exécutées l’une après l’autre.
• Lorsque la dernière fonction du cycle à été Fonction Fonction
exécutée, le programme continue avec n 2
l’exécution de la première fonction de ce
dernier.
• L'intervalle de temps nécessaire pour
Fonction Fonction
exécuter un cycle entier dépend n-1 3
essentiellement du temps requis pour
exécuter ses différentes fonctions.

• La programmation de l’approche cyclique est Fonction
1
relativement simple.
• Les fonctions sont appelées l’une après l’autre dans
la boucle principale de la fonction main(). Fonction Fonction
• Les évènements (par exemple, l’actionnement d’un n 2
commutateur ou la réception de données via
l'interface série) sont scrutés périodiquement dans
cette boucle (anglais : polling).
• Néanmoins, les spécifications pour les
applications embarquées exigent souvent, que Fonction Fonction
les évènements doivent être traités dans un n-1 3
délai très court. Ce qui n’est pas forcément
possible avec cette approche.

• Le cycle de rafraîchissement y est trop grand pour
éviter le scintillement de l'écran.
• Exemple VMD. • Le programme n’utilise pas les temps d'attentes sur
le hardware afin de réaliser d’autres tâches.
• Par exemple, lorsque le programme attend sur
l’indicateur de fin de la conversion durant la phase
while (1) { Read_A_D_Converter(), il pourrait traiter les
mesures précédentes et en afficher le résultat sur
ADC_val = Read_A_D_Converter(); l’afficheur LCD.
Voltage = Process_measurements(ADC_val);
Display_results(Voltage);
}

Déroulement quasi-parallèle et
évènementielle
• Les événements peuvent Fonction
1
interrompre le processus cyclique
en déclenchant une interruption.
Fonction Fonction
• La routine de service n 2
d'interruption (abréviation en
anglais : ISR) est ainsi appelée en ISR
temps réel pour traiter
l'événement.
Fonction Fonction
• Le déroulement du programme n-1 3
devient ainsi quasi-parallèle et Variable
Globale
évènementielle.

évènementielle
• Cette approche est souvent Fonction
1
utilisée dans les systèmes
embarqués.
Fonction Fonction
• Les interruptions sont relativement n 2
faciles à programmer.
• Les critères temps réel du système ISR
sont ainsi bien remplis.
Fonction Fonction
n-1 3
Variable
Globale

évènementielle
• Néanmoins il subsiste le problème de la Fonction
communication entre l’ISR et les fonctions 1
de la boucle principale.
• Cette communication nécessite le recours à
des variables globales.
Fonction Fonction
• Il est important d’exclure les accès mutuels à n 2
ce genre de variable de sorte qu’une partie
du programme n’y puisse accéder à un
instant donné.
• Cela signifie, qu’une fonction de la boucle ISR
principale doit verrouiller l'interruption (dont
la routine de service pourrait également
accéder à cette variable) durant l’accès à
cette variable. Fonction Fonction
n-1 3
• Pour des applications plus complexes, qui Variable
nécessitent plusieurs interruptions et Globale
variables globales, cela peut conduire à des
interdépendances dissimulées et entraîner
des crashs du système.
évènementielle
• Exemple VMD.
Global Variable
ADC_val
while (1) {
Voltage = Process_measurements(ADC_val);
Display_results(Voltage);
Delay_ms(40);
} ADC_IRQ() {
ADC_val = Read_A_D_Converter();
}
Déroulement quasi-parallèle avec RTOS
• Les applications embarqués plus complexes sont souvent réalisées avec des
systèmes d'exploitation temps réel (abréviation anglaise : RTOS).
• Bien que ces systèmes nécessitent plus de ressources que l’approche quasi-
parallèle et évènementielle, ils offrent néanmoins des outils
supplémentaires pour résoudre les problèmes de cette dernière.
• RTOS: toutes les demandes de traitement sont encapsulées dans des
tâches et ordonnancées à la demande
• Meilleures fluidité du programme et réponse aux évènements
• Multitâche (illusion)
• ISRs plus concises par conséquent déterministes
• Meilleure communication
• Meilleure gestions des ressources

• But : Satisfaire des contraintes temporelles, Deux
types:
• Hard real-time, doit s’assurer que les tâches critiques sont
terminées à temps
• Soft real-time, si elle ne sont pas terminées à temps, doit
encore essayer de les terminer à temps
• Besoins clé de la conception:
• Prédictibilité et déterminisme
• La vitesse est importante. Généralement assurée par une
conception simple d’OS design et parfois pour pouvoir
assurer la prédictibilité et le déterminisme
• Responsivité et contrôle utilisateur: faire du bon travail
assez rapidement et les priorités peuvent être ajustées
par l’utilisateur
• Crash−sécurisé: parfois éteindre tout le système n’est pas
la bonne manipulation à faire
• Nécessité un ordonnancement et une allocation de la
mémoire avancés

• Exemple VMD.
ADC_val
while (1) { while (1) {
OS_delay(75); OS_delay(50);
ADC_val = Read_A_D_Converter(); Voltage = Process_measurements(ADC_val);
} Display_results(Voltage);
}
Problème?? Solution : Mutex, Sémaphore, Queue de messages, boite aux lettres
State-Event
• Les systèmes techniques ont un nombre fini
d'états, dans lequel ils peuvent se trouver à un
instant donné.
• Ils réagissent à des événements qui peuvent se
produire durant leur fonctionnement.
• En fonction de l'état actuel du système, ces
événements peuvent déclencher des activités et
éventuellement générer un changement d’état
de ce dernier.

State-Event
• Un état (State) est une disposition, dans laquelle le système entre
durant une période limitée.
• Différentes activités (anglais : Activity) peuvent être exécutées au sein
d'un état.
• Exemples d’état : « Sonnerie », « Conversation » etc.
• Un événement (anglais : Event) est une influence extérieure sur le
système ou un changement dans le système.
• Un événement est de courte durée (quantité de temps négligeable) et a
toujours un impact sur le système.
• Exemples d'événements: « combiné est décroché », « numéro est
sélectionné » etc.
• Une transition décrit le passage d'un état à un autre.
• Une transition est toujours déclenchée par un événement.
• Exemples de transitions : Le décrochement du combiné (évènement)
change l’état du system de « Téléphone libre » à « Saisir le numéro ».
• Une action est exécutée au cours d'une transition.
• La transition « Téléphone libre » à « Saisir le numéro » augmente la
tonalité.

State-Event
-Conception-
• Tableau d’états (exemple)

State-Event
-Conception-
• Diagramme d’états (même exemple)
Correspondant s’annonce
Conversation
Combiné est raccroché
/Pause Sonnerie
Combiné est décroché /Pause
Numéro libre est sélectionné

Téléphone Combiné est décroché /Activer la tonalité d’appel
libre /Activer la tonalité bip
Combiné est raccroché Saisir le

/Pause Combiné est raccroché /Pause numéro
Chiffre est sélectionné
Occupé /Transmettre le chiffre
Numéro occupé est sélectionné
/Activer la tonalité occupée

State-Event
-Conception-
• Diagramme d’états (même exemple)
Correspondant s’annonce
Conversation
Combiné est raccroché Sonnerie

/Pause
Numéro libre est sélectionné

Téléphone Téléphone
/Activer la tonalité d’appel
libre actif
Combiné est décroché

/Activer la tonalité bip Saisir le
numéro
Chiffre est sélectionné
Occupé /Transmettre le chiffre
Numéro occupé est sélectionné
/Activer la tonalité occupée
State-Event
-Conception-
• Implémentation : Instructions switch emboîtées
• l'imbrication de deux structures switch

• La structure externe permet de gérer les états possibles
• la structure interne est responsable du traitement des différents évènements.
State-Event
-Conception-
• Implémentation : Instructions switch emboîtées
State-Event
-Exemple-
Start
Rec
Haut
Av
Bas
State-Event
-Exemple-
State-Event
-Exemple-
• Structures Disponibles :
State-Event
-Exemple-
• Exemple :
State-Event
-Exemple-
Exercice d’application
Chronomètre
• Des boutons pour les fonctions Start, Stop et
Clear.
o Start lance le chronomètre.
o Stop arrête le comptage sur le chronomètre.
o Clear efface la valeur du temps écoulé si le
chronomètre est à l’arrêt.
• Un Timer déclenche une interruption toutes les
1 ms. Le Timer contrôle ainsi un compteur
elapsed_time_counter qui compte les
millisecondes depuis le démarrage du système.
• Un écran pour afficher le temps écoulé avec une
résolution de 1 ms. L'affichage doit être mis à
jour 10 fois par seconde.
Chronomètre
1) Proposer un pseudo-code du programme en se basant sur une approche de
conception avec déroulement quasi-parallèle et événementiel. Nous
supposons que chaque bouton peut générer une interruption.
• Utiliser une variable appelée state pour indiquer si le chronomètre est arrêté ou en
cours d'exécution.
• Utiliser une variable appelée elapsed_time pour savoir combien de temps s'est écoulé
depuis l’appuie sur le bouton Start.
• Utiliser une variable appelée display_delay pour savoir combien de millisecondes
restent jusqu'à ce que l'affichage soit à nouveau mis à jour.
Chronomètre
Main thread: Start ISR: Stop ISR: Clear ISR:
state = stopped state = running state = stopped if state == stopped
display_delay = 100 elapsed_time = 0
elapsed_time = 0
Timer ISR:
if state == running
elapsed_time += 1 ms
display_delay -= 1
if display_delay == 0 {
display (elapsed_time)
display_delay = 100
}
Chronomètre
2) Proposer l’organigramme puis le pseudo-code du programme en se basant sur une
approche de conception avec déroulement cyclique sans utiliser d'interruptions. Nous
supposons que le Timer met à jour un registre matériel appelé elapsed_time_register
toutes les millisecondes.
• Utiliser une variable appelée state pour indiquer si le chronomètre est arrêté ou en cours
d'exécution.
• Utiliser une variable appelée start_time pour enregistrer l’instant où le bouton Start est
appuyé.
• Utiliser une variable appelée stop_time pour enregistrer l’instant où le bouton Stop est
appuyé.
• Utiliser une variable appelée next_display_update pour indiquer l’instant de mise à jour
de l'affichage.
Chronomètre
Chronomètre
Chronomètre
Main thread: if clear switch pressed {
state = stopped if state == stopped {
display elapsed_time_counter start_time = stop_time
next_display_update = elapsed_time_counter + 100 }
while (1) { }
if start switch pressed { if elapsed_time_counter > next_display_update {
if state == stopped { if (state == running)
start_time = elapsed_time_counter display (elapsed_time_counter - start_time)
state = running else
} display (stop_time – start_time)
} next_display_update = next_display_update + 100
if stop switch pressed { }
if state == running { }
stop_time = elapsed_time_counter
state = stopped
}
}
Chronomètre
3) Proposer une autre approche de l’implémentation logicielle basée sur le modèle
state-event.
Travail à faire
SÉCURITÉ DES SYSTÈMES
Introduction
• Les exigences de qualité pour les systèmes embarqués sont très élevées.
• La qualité peut être déterminée statistiquement.
• Les probabilités de défaillance (MTTF Mean Time To Fail, ou MTBF, Mean Time Between Failure) des
composants sont en générale connue.
• Cela permet de définir la probabilité de défaillance du système en entier ou le temps nécessaire pour
que celui-ci atteigne un état jugé comme étant dangereux.
• La qualité de la partie matérielle peut être augmentée grâce à la redondance.
• «fail-safe mécanismes »
• La redondance vise principalement à réaliser des systèmes sures et fiables.
• Les options suivantes peuvent être envisagées en fonction des champs d’application :
• Surveillance de la partie logicielle à l’aide d’un Watchdog
• Surveillance de la partie matérielle (horloge et alimentation) par des composants supplémentaires.
• Surveillance de la partie matérielle par la partie logicielle (CRC, Test de la RAM etc.).
• Partie matérielle redondante (dédoublement d’entrée/sorite, deux processeurs en parallèle ou trois
avec une stratégie de décision majoritaire).
• Partie logicielle redondante (Les mêmes programmes sont exécutés sur des processeurs différents).
Introduction
• Le développement du logiciel peut être amélioré qualitativement par des mesures
appropriées.
• La fiabilité des logiciels embarqués doit être très élevée.
• Le développement de logiciels de bonnes qualités n'est possible qu’avec plusieurs
mesures:
• Des ingénieurs bien formés et qualifiés qui ont une bonne connaissance des pièges courants.
• Révision des spécifications, de la conception et du code.
• Une conception du logiciel de haute qualité.
• Code de haute qualité grâce à l'utilisation des normes et des directives SW.
• Mécanismes de détection d'erreur dans le logiciel.
• Utilisation des outils d'analyse de code statique.
• Des tests approfondis durant la phase de développement.
• Tests du système complet avant et pendant la mise en service.
• Une documentation complète, compréhensible et actualisée.
Programmation C dans l’embarqué
• Le langage C, qui est le plus couramment utilisé dans les systèmes embarqués,
n’est malheureusement pas sure au niveau des types et présente également de
nombreux autres pièges.
• Par exemple, les pointeurs en C
• Il faut prendre les précautions nécessaires durant la programmation.
• Il est fortement recommandé de toujours n’utiliser qu’un sous-ensemble du langage de
programmation C.
• l’association MISRA-C définit une listes exhaustive de tels recommandations
• Pourquoi faut-il utiliser le langage C pour programmer les systèmes embarqués,
alors que ce dernier est lacunaire?
• Premièrement ; il n’existe (presque) pas d’autres alternatives dans domaine de la
programmation des microcontrôleurs .
• Deuxièmement ; il est plus opportun d’utiliser un langage de programmation que l’on connaît
(en particulier ses faiblesses), pour lequel il existe de bon compilateur, qu’un langage qui
n’est pas répondu et pour lequel il n’existe que des mauvais outils de développement.
MISRA-C
• Définit 122
règles
«nécessaires»
et 20 règles
«consultatifs»
Problèmes typiques en C
La loi de Murphy
«Tout ce qui est

susceptible de mal tourner
tournera nécessairement
mal. »
Dépassement de capacité dans les tableaux
• Ce code est syntaxiquement correct
char array[10];
char counter = 0;
…
for (counter = 0; counter <= 10; counter++){
array[counter] = 0;
}
• PB : dépassez les limite du tableau « array » lorsque « counter = 10 ».
• Conséquence?
• Dans le pire de cas, le relieur (anglais : linker) réserve de l’espace mémoire pour la variable counter
directement à la suite du tableau array.
• Dans ce cas l’instruction « array[counter] = 0 » efface systématiquement le contenu de la variable counter.
• La boucle for devient ainsi une boucle infini.
Dépassement de capacité dans la pile (anglais : stack)
• Ce problème est identique à celui lié aux dépassements de capacité
dans les tableaux.
• Lorsque vous dépassez les limites de votre pile (trop d’appels de
fonctions imbriqués ou trop de variables locales), vous risquez
d’accéder aux segments de la RAM qui contiennent des variables ou -
selon l’architecture- des instructions.
• Les erreurs, qui résultent de ce genre de dépassement, vont se
manifester à un instant donné en cours de l’exécution.
Dépassement de capacité dans la pile (anglais : stack)
• Quelles sont les solutions pour résoudre ces problèmes :
• Agrandissement de la taille de la pile. Des nombreux environnements de
développement permettent de définir la taille de la pile à l’aide d’options
pour le linker.
• Réduction de la taille des variables locales dans les fonctions.
• Eviter les appels de fonction récursive!
Pointeur NULL
• Un pointeur, qui n’est pas initialisé, adresse la case mémoire NULL (ou
même quelque part ailleurs).
• une erreur de programmation classique
• Une allocation de mémoire pour construire une liste dynamique, qui
échoue par manque de mémoire disponible, retourne également
l’adresse NULL.
• se produit à n’importe quel instant.
• Quelles sont les solutions pour résoudre ces problèmes :
• Il faut comparer la valeur de chaque pointeur avec l’adresse NULL avant de
l’utiliser! Cette vérification peut se réaliser soit avec :
• if(pointer != NULL), ou avec :
• assert(pointer != NULL).
Les interruptions
• Un microcontrôleur possède de nombreux vecteurs d'interruption,
qui sont rassemblés dans son tableau des vecteurs d’interruption.
• Que se passe-t-il lorsqu’apparaît une interruption, qui n’a pas été
prévue et n’est par conséquent pas traitée (comme par exemple la
division par zéro) ?
• Dans ce cas, le contrôleur va accéder au tableau des vecteurs d’interruption
afin de charger l’instruction correspondante à cette interruption.
• Si ce vecteur contient la valeur zéro, le programme est relancé (reset).
• Sinon le programme fait un saut à une adresse inconnue, qui engendrera
probablement un crash du système.
Les interruptions
• Quelles sont les solutions pour résoudre ce problème :
• Il faut toujours initialiser tous les vecteurs d'interruption.
• Si vous n'utilisez pas une interruption donnée, implémentez pour cette
dernière une routine traitement d’interruption (anglais : ISR) par défaut.
• Dans cette routine de service, vous pouvez soit afficher un message d'erreur
ou implémenter une boucle infinie pour le débogage.
Allocation de mémoire dynamique
• La mémoire est allouée dynamiquement dans les programmes afin de générer
des listes.
• Cela marche bien tant que la mémoire disponible est suffisante.
• Des problèmes apparaissent inévitablement lorsque la mémoire requise n’est
plus disponible.
• le programme n’a plus de ressource en mémoire.
• Un autre problème est la fragmentation de la mémoire qui peut survenir avec
l’allocation de la mémoire dynamique.
• Quelles sont les solutions pour résoudre ce problème ?
• Essayez de définir les structures de données autant que possible de façon statique.
• Assurez-vous que la mémoire, qui a été allouée dynamiquement, soit également de nouveau
libérée.
• Testez le système également en termes de ressources en mémoire : Exécutez votre
programme durant des heures ou des jours et regardez ensuite si l’espace mémoire
disponible reste constant.
Les conditions de courses (race condition)
• Les situations de course surviennent lorsqu’il y a une interaction
asynchrone entre la partie matérielle (hardware) et la partie logicielle
(software).
• Ils se produisent lorsque les données sont lues systématiquement par
le logiciel, alors qu’ils ont changé de manière asynchrone par le
hardware.
Problèmes typiques en C partie entière du
temps qui s’écoule
2
Les conditions de courses unsigned int timer_hi;
(race condition)
interrupt timer(){
• Le code ci-dessus est
erroné. ++timer_hi; partie fractionnaire du
• Le problème peut être } temps qui s’écoule
résolu à l’aide d’approches
différentes: unsigned long read_timer(void){
• Considération du 1 unsigned int low, high;
problème dans la
phase de conception low = read_word(timer_register);
• Désactiver high = timer_hi;
systématiquement les
interruptions durant return (((unsigned long)high)<<16
les accès Hardware + (unsigned long)low);
• Utilisation des « 3 Une information erronée sur le temps
registres de capture » }
Code réentrant
• Les applications embarqués sont toujours programmées à l’aide
d’interruptions ou parfois également avec des systèmes d'exploitation
temps réel.
• Risque d’accès simultané (sans précautions spécifiques) aux mêmes
ressources (interfaces matérielles, variables globales).
• Les fonctions doivent être programmé afin qu’elles soient
réentrantes. C'est à-dire que :
• Les variables globales ne doivent être accessibles que de façon exclusive
(atomique).
• Il ne faut pas appeler les fonctions non réentrantes (attention avec les
fonctions des libraires standards).
• Les interfaces matérielles ne doivent être accessibles que de façon exclusive.
Programmation défensive
• La programmation défensive signifie que l’on considère toutes les
éventualités :
• arguments transmis aux fonctions non plausibles, transmission de données
erronées, séquences temporelles pas prévues, etc.). Lorsque
• Elle est recommandée pour des systèmes ou la sécurité est
essentielle,
• Cette approche nécessite plus de code et, par conséquence, plus de

puissance de calcul, plus de capacité de stockage et plus de
développement.
Optimisation du code C
• Les compilateurs C essayent de générer un code objet le plus optimisé
que possible. Cela signifie que ce dernier doit être à la fois aussi
rapide et compact que possible.
• Le résultat du compilateur peut également être influencé de façon
significative par la manière dont le code C est défini.
• Eviter autant que possible les variables globales.
• Définir plutôt les variables locales à l’intérieur des fonctions.
• Le compilateur peut ainsi stocker ces dernières dans des registres locales - plutôt que de
les placer dans la mémoire externe (RAM). Ce qui diminue le temps d’accès aux
variables.
• Réduire autant que possible le nombre de variables locales
• Le nombre des registres est limité et les variables, qui ne peuvent pas être
stockées dans des registres, sont placées sur les piles.
• Au besoin, essayer d’utiliser ces dernières de façon limitée à l’intérieur de la
fonction.
• le compilateur peut attribuer un seul registre aux divers variables durant l'exécution de
la fonction.
• Evitez les opérations de prises d’adresse avec les variables locales.
• Cela empêche le compilateur de les stocker dans des registres.
• L’assembleur en ligne ne devrait être utilisé qu’en dernier recours.
• Le compilateur n’a pas de droit d’optimiser le code C autour de ces derniers.
• Utiliser plutôt les sous-routines en assembleur.
• Eviter de définir des fonctions avec des listes des paramètres variables
(comme printf).
• L’appel de ces fonctions nécessite en générale plus de ressources systèmes.
• Remplacer les fonctions très courtes (1 à 3 lignes de code) par des macros
ou des fonctions en ligne (inline).
• Les ressources systèmes nécessaires à l’appel des fonctions peuvent ainsi être
réduites au maximum.
• Le compilateur copie littéralement les lignes de code des fonctions en ligne aux endroits
appropriés dans le programme.
• La transmission des arguments aux fonctions devrait être réalisée à
l’aide de paramètres au lieu de variables globales.
• Dans le premier cas, le compilateur utilise les registres pour transmettre les
arguments.
• Cette procédure est beaucoup plus rapide que l'accès systématique aux
variables globales, qui sont stockées dans la mémoire externe (RAM).
• Les premiers arguments sont en général transmis avec des registres et les
suivants avec la pile. Par conséquent, il faut faire également attention au
nombre d’arguments, qui vont être transmis à la fonction
• Utiliser le mot-clé « volatile » pour indiquer au compilateur, que la
variable ne peut pas être stockée dans un registre.
• Cette dernières sera ainsi toujours déposée dans la mémoire externe (RAM).
• Cette définition est même indispensable pour les variables qui permettent
d’accéder à la partie matérielle comme par exemple le « Timer ».
• Essayer les différents niveaux
d'optimisation du compilateur.
• Le niveau le plus haut
ne génère ici pas forcément
le code le plus rapide
ou le plus compact.
• Utiliser pour la définition des variables toujours le type de données le
plus adéquat en fonction de la taille de la CPU (8, 16 ou 32 bits).
• Autrement, le compilateur doit effectuer une voire plusieurs opérations cast.
• Les opérations arithmétiques avec le type char sont en principe très efficaces
sur les microcontrôleurs 8 bits.
• Un microcontrôleur 8 bits est en générale dépassé avec les calculs à virgule
flottante. (temps d'exécution très longs).
• Contraintes d'alignement pour
les adresses des variables (arch
32 bits) : Essayer de déclarer
systématiquement les membres
32 bits en premier, les membres
16 bits en second et les
membres 8 bits à la fin dans les Long (32) Long (32)
structures de données. short (16)

Long (32)
Long (32)
short (16) short (16)
• Cela empêche le compilateur de short (16) Char Char Char short (16)
short (16) Char Char Char Char Char
devoir insérer des espaces libres Char Char Char Char
("padding") entre les différents
types de membres. Ce qui a
tendance à augmenter la taille de
la structure de données.
• Write simple and understandable code !
• Ne pas définir de code «intelligent », qui n’est pas compréhensible pour votre
collègue (et pour vous après quelques jours).
• Le compilateur ne comprend pas ce code et ne peut donc l'optimiser.
• Définir une structure « switch » au lieu d'un tableau de saut (Jump-

Table).
• Le compilateur va générer un tableau de saut optimal pour le microcontrôleur
sélectionné pour cette instruction.
• Le code reste ainsi parfaitement portable.
Spécification et exécutions des tests
• Il existe de nombreuses normes et directives pour effectuer des tests
logiciels, dont les plus recommandées sont les suivantes :
• IEEE 829, Standard for Software Test Documentation
• IEEE 1008, Standard for Software Unit Testing
• IEEE 1012, Standard for Software Verification and Validation
• Code standard/de débogage
#define _DEBUG
...
statement;
...
#ifdef _DEBUG
// additional testing and error messages output
#endif
Watchdog
• La tâche du Watchdog (horloge de surveillance) est de réinitialiser un
microcontrôleur (c. à d. de ramener le système à un état défini) à
partir d'un état indéfini.
• Cet état est souvent le résultat d’un comportement erroné du
programme, comme par exemple une boucle infinie. Dans le langage
courant on appelle cela un plantage informatique (system crash).
• L’utilisation d'un watchdog est fortement recommandée même avec
des applications très simples.
Watchdog
• WatchDog Timer (WDT)
• Timer qui fonctionne indépendamment de la CPU
et qui peut être utilisée pour déclencher une interruption
ou réinitialiser le microcontrôleur
• Dans quel cas l’utiliser?
• Effectuer une tâche à intervalles réguliers
• Se réveiller du sommeil (Wake-up) à un intervalle de temps
• Réinitialiser le MCU s'il est bloqué dans un mauvais état
Watchdog
• Exemple : AVR
Watchdog
• Exemple : Réinitialisation AVR
Si au bout de 1s le wdt n’est
pas réinitialisé le
programme dans le
microcontrôleur redémarre
Watchdog
• Exemple : Réveil périodique sur AVR
Mode Low Energy, sur une période

contrôlée par le WDT

Systèmes Embarqués: Chapitre V Développement Du Logiciel Embarqué

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Systèmes Embarqués: Chapitre V Développement Du Logiciel Embarqué

Transféré par

Droits d'auteur :

Formats disponibles

Systèmes Embarqués

Ce(tte) œuvre est mise à

2 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

4 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

5 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

6 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

7 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

Mémoires dans les microcontrôleurs

8 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

• Configuration des E/S de l’UAL :

9 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

 le circuit extérieur impose le potentiel

 Le potentiel de la broche se retrouve au potentiel de

13 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

14 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

DDRB |= (1<<3); PORTB |= (1<<3);

C-Example 2 - Configure Pin D2 as input with pullup, read pin value:

DDRD &= ~(1<<2); PORTD |= (1<<2);

15 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

16 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

17 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

début Si une interruption doit modifier le

18 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

0000 0001 • un signal arrive

Unité arithmétique et 0000 0100

19 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

Unité de 0000 0001 En fonction de l’interruption, l’UC

Unité arithmétique et 0000 0100

Registres 0101 0010

Unité arithmétique et 0000 0100

Registres 0000 0001

21 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

0000 0001 A la fin du sous-programme le

Unité arithmétique et 0000 0100

22 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

23 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

• Si une seconde interruption intervient

24 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

25 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

se (t ) = s( kTe ) ŝk ŷk ŷ( kTe )

• Assurent la conversion de format entre des données d’E/S

26 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

28 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

29 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

30 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

31 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

• En général, on parcourt le chemin inverse : on part de considérations de

33 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

Capteur 1 Capteur i Capteur n

34 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

35 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

36 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

37 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

38 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

39 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

a) Quelle est la résolution en tension de ce convertisseur ? Q= 2,56V/1023 = 2,5mV

40 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

b) Calculer les valeurs numériques 10 bits

c) Écrire l’algorithme complet capable d'identifier

41 | Cours Systèmes Embarqués, MR SysCoin, Préparé par : Slim Ben Othman

- Horloge oscillateur = 1 MHz,

- ADC prescaler = CK/128,

- Mode de conversion : free running