Arch Circuit Stm32-1

Microcontrôleurs 32 bit : le choix Cortex-M3
.
Les Microcontrôleurs 32 bits : le choix Cortex-M
Par Damergi Emir
1- Microcontrôleurs : les tendances
Un microcontrôleur ou MCU (MicroController Unit) est un sy stème informatique entier co ntenu

dans un circuit intégré unique. Le MCU contient « Figure -1 ». :
 Un noyau processeur ( Processor Core) contenant une Unité Arithmétique et Logique qui
effectue les o pérations + Unité de contrôle qui permet de récupérer le s instructions et les
décode.
 Des mémoires (RAM, Flash).
 Des périphériques de contrôle ( contrôleur d’interruption &, Direct Memory Access Controller
« DMAC »).
 Des périphériques d’ interface (ou d’ entrée/sortie) qui servent à ass urer la communication
avec l’extérieur : Interfaces parallèles, série, Timers, Convertisseurs A/N et N/A, etc..
DMA Interrupt Processor Memory Memory

Controller Controller (RAM)
Core (Flash)
Timer Serial Network ADC
Figure 1 : Architecture simplifiée d’un microcontrôleur
Damergi Emir 1 Version 1.0

Le noyau processeur d’un microcontrôleur est b eaucoup moins complexe que celui d’ un système
informatique ordinaire (Ordinateur), à conso mmation élect rique plus faible (qq milliwatt en
fonctionnement et de l ’ordre du m icrowatt en veille ) et également moins performant : Il supporte
environs une centaine d’instructions (transferts d e données, sauts, opérations logi ques si mples,
décalages, et les opérations arith métiques) et fonctionne à des fr équences relativement basses variant
de quelques dizaines de MHz à quelques centaines. Ceci permet de limiter la consommation en énergie
du circuit.
Ces circuits à prix réduits à grandes quantités (moins de 1$ pour 10000 pi èces) sont d’une gr ande
utilité pour les applications embarquées qui ont plus besoin d’un grand nombre de lignes d’E/S pour la
commande, l’acquisition ou la communication que d’une capacité de traitemen t élevée. Ils per mettent
ainsi la conception de cartes de co mmandes, de petites tailles et avec des rapports prix/qualité
exceptionnels, pour un gr and nom bre de sy stèmes embarqués (Machines à laver, sy stèmes GPS,
climatiseurs, cartes à puce, automates programmables, contrôleurs d’ascenseurs, variateurs de vitesse,
etc..). Ils couvrent le plus large spectre du domaine des applications em barquées avec des ventes qui
ont atteint les $26 billions en 2007.
Même si les µc 8 bits (relativem ent à la largeu r du bus et taille des registres) se sont im posés
longtemps ; l’étendue des domaines d’application des µc, le besoin croissant en capacité de traitement
et en comportement temps réel ont incité les constructeurs à proposer des µc 16 et particulièrement 32
bits beaucoup plus performants.
En effet, l es ventes ( en %) de s microcontrôleurs 32 bits ont énorm ément p rogressé lors de la
dernière décennie et sont passées de moins de 1% en 2000, à 30% en 2006 pour atteindre les 38 % en
2009 « figure 2 » et on prévoit que cette croissance continuera durant les prochaines années [1].
Microcontrôleurs 8 bits
Ventes en %
2000 2006 2009
Figure 2 : Evolution des ventes en % des microcontrôleurs 8, 16 et 32 bits

La m ajorité des fabricants de m icrocontrôleurs opt ent pour l ’intégration d ’un processor core
préconçu, sous forme d’un IP « Intellectual Property », dans leurs circuits et l ui ajoutent les mémoires
et les entrées/sorties nécessaires pour les applications ciblées.
Parmi les processor cores (IP) les plus utilisés dans les microcontrôleurs 32 bit s, on trouve ceux
de la société ARM (Advanced Risc Machines) ; qui grâce à son nouveau processeur Cortex-M, s’est
imposé co mme leader d es fournisseurs de processeu rs 32 bits pour les applications em barquées
« figure- 3 ».
3 ------ ARM ------ PowerPC ------ x86 ------ SuperH ------ MIPS
Ventes en Billions de dollars
0
2007 2008 2009 2010 2011 2012 2013
Figure 3 : Evolution des ventes des cœurs 32 bits pour les applications embarquées
2- ARM et les processeurs CORTEX
La société ARM a été créée en 1990 p ar associa tion (joint-vent ure) de Apple Co mputer, Acorn
Computer Group et VLSI Technolog y. Contrairement aux autres sociétés travaillant dans le domaine
des se mi-conducteurs, AR M ne fabrique pas de s pr ocesseurs et les vend dire ctement, mais elle l es
conçoit et v end leur lic ence sous forme d’IP à des partenaires qui les intègrent dans leurs
microcontrôleurs et processeurs. Aujourd’hui, les partenaires d’ARM vendent annuellement plus que 2
billions de circuits à base de noyaux ARM dont l’architecture et le jeu d’instructions ont évolué depuis
la première version ARM-v1 (deve nue obsolète ainsi que les ar chitectures ARM-v2 et v3) jusqu’ à la
version actuelle ARM-v7, appelée également Cortex « figure 4 ».

Architecture Architecture Architecture Architecture

v4/v4T v5/v5E v6 v7 (Cortex)
v7-A (Cortex-A)
(profil Applications)
v7-R (Cortex-R)
(profil Real-Time)
v7-M (Cortex-M)
(profil
Microcontrôleurs)
ARM7TDMI ARM 926, 946 ARM 1136, Cortex-A8

Exemples 920T, Intel Xscale 1176, 1156T Cortex-R4
Intel StrongARM Cortex-M3
Figure 4 : Evolution des architectures ARM
Contrairement aux architectures préc édentes, Cortex intègre entre autres la gestion des
interruptions et des exceptions ce qui permet une plus grande transparence et souplesse au niveau de la
programmation ainsi qu ’un portage de code plus sim ple. En effe t, ch aque constructeur de
microcontrôleurs basé s su r les génér ations précéden tes ét ait obligé de concev oir sa propre solution
pour la gestion des i nterruptions, ce qui rendait l ’utilisation d’un out il de développement standard
impossible, la programmation moins transparente et évidement le code difficilement portable.
Les cœurs C ortex portent la désignation Cortex- XN, ou X désigne le profil au quel appartient l e
cœur et N son degré de performance qu i varie entre 0 (le moins performant) et 9 (le plus performant).
On distingue 3 profils « figure 5 » propres à l’architecture ARM-v7 ou Cortex et qui sont :
 Le profil A (séries Cortex-A) : destiné pour fair e tourner des applications complexes telles que
les sy stèmes d’exploitation embarqués (Symbian, Linux, Wi ndows CE) nécessitant une pui ssance
de traite ment élevé e et un sy stème d e gestion de mémoire vi rtuelle (MM U). Les proc esseurs
appartenant à ce profil peu vent fonctionner avec des fréquences de 2GHz et avec une perfor mance
de 2,5 DMIPS 1/MHz) et c ontiennent des acc élérateurs SI MD (Single Instruction/ Multi ple Data)
ainsi que la technologie Jazelle per mettant l’exécution rapide de langages interprétés tel que Java.
On les trouve dans des pro duits tels que les télé viseurs numériques haute défini tion, les terminaux
mobiles.
1
Dhrystone MIPS : Performance de traitement du processeur en Millions d’Instructions par Seconde obtenue par
exécution du benchmark Dhrystone

 Le profil R (s éries Cortex-R) : destiné principalement aux applications te mps réel à contraintes
très sévères et exigeant une haute fi abilité et un tem ps de r éponse faible. L es processeur s de ce
profil contiennent également une unité additionnelle pour le calcul en vir gule flottante et sont
utilisés à titr e d’ exemple dans les disq ues durs, les appareils photo num ériques, le do maine d e
l’automobile (systèmes de freinage).
….2000
Cortex-A
ARM/Thumb
fonctionnement (MHz)
Thumb-2
GIC
Fréquence de
MMU
475
Neon (SIMD)
DSP
Cortex-R VFP
Jazelle
375
Thumb/Thumb-2
Cortex-M GIC
13 stages Pipeline
Multi-core (1-4)
MPU
Thumb-2
FP Unit
NVIC
8 stages Pipeline
MPU
6,5 DMIPS/mW
3 stages pipeline
12,5 DMIPS/mW
0,9 à 1,25 DMIPS 1,6 DMIPS 1,6 à 2,5 DMIPS
Figure 5 : Performances et domaines d’applications des profils de l’architecture Cortex
Le profil M (série s Cortex-M) : optim isé p our des applications néces sitant une basse
consommation en énergie, un coût réduit et un com portement déterm iniste pour le traitement des
interruptions. C’est le profil qui est destiné à être intégré dans les microcontrôleurs.
Cette famille de processeurs Cortex-M a fa it converger la majorité des constructeurs de
microcontrôleurs, pour la prem ière fois, vers une architecture co mmune. Déjà 28 sociétés (dont 6
parmi le top 10) ont opté pour un cœur Cortex-M (ST-Microelectronics, Luminary Micro (maintenant
faisant partie de Texas Instruments) NXP, Atmel, Zilog, Samsung, etc…).

Jusqu’à ce jour (fin 2012), ARM a lancé les versions 4 versions C ortex-M : Cortex-M0, M1,
M3 et M4 (Cortex-M1 est dédié à être implémenté sur FPGA et non sur des microcontrôleurs) « Figure -6 ».
Les process eurs Cortex-M0, M3 et M4 sont tous des proces seurs 32 bits , ont la m ême
architecture, mais destinés à des applications différentes:
 Le Cortex-M0 (0,9 DMIPS) est adapté aux applications à trè s faible coût, pas très exigeantes en
performance ( même s’il reste beaucoup plus performant que les processeurs 16 bits) et avec un nom bre
limité d’entrés/sorties.
 Le Cortex-M3 (1,25 DMIPS) vise les applications néces sitant une performance assez élevée tout
en gardant le coût réduit.
 Le Cortex- M4 (1,25 DMIPS + Floating Point + SIMD2) vise les applications de traitement de
signal qui nécessitant une performance très élevée et des calculs en virgule flottante. Il offre des
performances semblables à celles des DSP (Digital Signal Processor).
Figure 6 : Versions des processeurs Cortex-M
Au niveau des instructions, les processeurs Cortex-M assur ent une co mpatibilité ascendante :
toutes les instructions du Cortex-M0 (56 dont la majorité sont codées sur 16 bits) sont é galement
supportés par le Corex-M3 (une centaine). Toutes les instructions du Cortex-M3 sont supportées par le
Cortex-M4 qui ajoute, en plus, les instructions rela tives à l’ unité de calcul en virgule flotta nte et à
l’architecture SIMD2.
A part ça, un programme écrit en ‘C’ peut être exécuté sur n’importe quel processeur (M0, M3
ou M4), m ais évidement avec des performances di fférentes : c’ est le co mpilateur qui se charge
d’adapter le code ‘C’ au processeur cible.
2
SIMD (Single Instrcu tion Multiple Data) : Il s’ag it d’une arch itecture qu i permet d ’exploier l’UAL afi n
d’effectuer p lusieurs o pérations (additions, so ustractions ou multiplications) en même temps, sur de s donnée s
différentes.

3- Pourquoi le choix Cortex-M
Cortex-M, n’est pas un simple ‘Processor core’, mais plutôt un processeur. En effet, en plus du
noyau (UAL + UC), il intègre un certain ensem ble de com posants « Figure -7 »: un contr ôleur
d’interruptions, un Tim er Système, un système de débogage, une unité de protection ainsi qu’un
bus d’interconnexion en matrice permettant l’accès simultané à plusieurs zones mémoires ( puisque
Cortex-M à une architecture Harvard).
Figure -7 : Architecture simplifiée du processeur Cortex-M3 de ARM
L’unanimité des constructeurs pour les processeurs cortex-M est due principalement aux raisons
suivantes :
 portabilité: Tous les microcontrôleurs basés sur le Cortex-M ont, en plus d’ une compatibilité au
niveau des jeux d ’instructions, le même contrôleur d’interruptions et le même Timer pour les OS
temps réel (Sy sTick). Par conséquent, un pr ogramme développé pour un microcontrôleu r d u
fabriquant A peut être p orté sur un au tre du fabriq uant B, surto ut que ARM fournit les mêmes
drivers pour les périphériques intégrés au Cortex-M.
 Coût : En effet, le critère primordial qui incitait les développeurs de systèmes embarqués à opter
pour les MCUs 8 bits était le prix. Avec les Cortex-M, les prix des MCUs 32 bits a
considérablement baissé et sont pratiquement dans le même ordre que les MCUs 8 bits.

 Efficacité én ergétique : Les MCUs, co mme tous les processeurs embarqués et à usage général,
sont connus pour être flexibles au prix d’une c onsommation élevée en énergie de l’or dre de 1 à 3
MIPS/mW. Avec Cortex-M3, o n atteint une efficacité de 12, 5 MIPS/mW « figure- 8 ». En plus, il
supporte des modes basse consommation ainsi qu’une activation sélective des périphériques.
Flexibilité
Consommation
Figure -8 : Efficacité énergétique ( en MIPS/mW ) pour différentes plateformes embarquées
 Performance : Avec une capacité de traitement de 1,2 5 DMIPS et une fréquen ce de

fonctionnement qui peut atteindre la valeur de 275 MHz, les perform ances des Cortex-M
dépassent largement celles des architectures 8 et 16 bits « figure- 9 ».
Figure -9 : Comparaison des performances (DMIPS/MHz) du Cortex-M3
 Utilisation optimale de la mémoire : Grâce à l’utilisation de la t echnologie Thumb-2 qui permet

l’utilisation s imultanée d’i nstructions 16 et 32 bits, une m eilleure densité du code est obt enue
relativement aux autres architectures « figure -10 ».

Figure 10 : Comparaison de la densité du code du Cortex-M3par rapport à d’autres architectures
 Adaptation au temps rèel: Ceci est assuré par l’intégration d’un contrôleur d’interruptions gérant
les priorités et le sauvegarde du contexte matériellement ce q ui perm et d’avoir une ré ponse
déterministe et rapide aux événements externes. En plus, le Cortex-M intègre dans son jeu
d’instructions, quelques unes qui s’exécutent d’une manière atomique.
 Débogage p uissant: Grâce à un m odule de débogage intégré aux pr ocesseurs Cortex-M et qui
permet de fixer un certain nombre de Breakpoints et watchpoints.

Présentation du Cortex-M3
Chapitre 1 :
Par Damergi Emir
1- Introduction
Le noy au du Cortex-M3 est un proces seur RISC (Reduced Instruction Set Architecture) 3 2
bits : Il contient un chemin de données (data path : registres + largeur des bus données et code) 32 bits.
Il se ba se sur un pipeline à 3 étage s (Fetch, Decode et Execute) et possède un e architecture Harvard,
c'est-à-dire qu’il contient deux bus distincts : Data Bus pour le transfert des données et Code Bus pour
les instructions « Figure -1 ». Ceci per met d’accéder en mêm e temps aux i nstructions et aux données,
et par conséq uent une augmentation de la pe rformance puisque l’ accès aux données n’ affecte pas le
pipeline.
Cortex-M3 Processor
Noyau CM3
(Cortex-M3 Core)
et logique (ALU) +
Unité Arithmétique
Unité de recherche
d’instructions
(Fetch unit)
d’interruptions
Système de
décodage
Registres
débogage
Unité de
Contrôleur
(NVIC)
Interface Mémoires
Code Bus Unité de protection Data Bus

mémoire (MPU)
Bus d’Interconnexion (Bus Matrix)
I-Code Bus D-Code Bus System Bus
Figure 1 : Le processeur Coretx-M3

Le nom bre de lignes d’adress es est également de 32 ce qui permet l’ accès à un espace
d’adressage unique de 4 GO (232 octets).
En plus du noyau, le Cortex-M3 comporte quelques périphériques:

 Un contrôleu r d’i nterruptions NVIC (Nested Vector Interrupt Controller) sup portant une e ntrée
non masquable (NMI : Non Maskable Interrupt), 14 sources d’interruptions internes généré es par le
noyau et les périphériques du Cortex- M3 et jusqu’à 240 sources d’ interruptions externes ( le nombre
est personnalisé pour chaque constructeur).
 Un système de débogage qui permet de placer des points d’arrêt « Breakpoints » et d’observation
« Watchpoints » matériels, ainsi que le traçage des instructions.
 Une unité de protection de mém oires (MPU : Memory Protection Unit) qui permet de déterminer
des droits d’ accès des applications à des zones mémoires définies. Cette unité es t optionnelle et n’ est
pas disponible dans tous les processeurs Cortex-M3.
 Un Bus de matrice (AHB BusMatrix: Advanced High Performance Bus) perm ettant de
multiplexer l es bus code et données vers 3 bus de sorties (I-Code, D-Code et Sy stem). Il permet
également d’assurer l’alignement des données (Parag ) ainsi que le ‘bit banding’ (Parag ).
2- Modes opératoires du Cortex-M3
Une application embarquée déployée sur un microcontrôleur ( ou tout système embarquée) est
constituée d’un ensemble de bouts de codes. Ces bouts de codes peuvent être :
- Exécutés suit e au décl enchement d’ une interrup tion (événe ment). Dans c e cas, on parle de
gestionnaire d’interruption (Interrupt Handler) ou de Routine d’interruption ( ISR : Interrupt Service
Routine). Dans le reste du document on utilisera les termes Handler et ISR.
- Exécutés en fonction de l’évolution de l’état du système (code de démarrage dans main( ), tâches
utilisateur en arrière plan, etc..).
Ainsi, et en fonction du t ype de co de exécuté, le Cortex-M3 se trouve dans l ’un de deux
modes :
Mode « Handler » : Quand le processeur exécute des Handlers d’interruptions.
Mode « Thread »: quand le processeur exécute des programmes , autres que les Handlers
(programme principal, tâches utilisateur).
Après le démarrage, le Cortex-M3 exécute main ( ) et est par défaut en mode Thread. Le
passage en mode Handl er s e fait a utomatiquement quand un Handler e st exécuté s uite au

déclenchement d’une i nterruption. A la fin de l’ exécution d ’un Handler, le Cortex-M3 retourne en

mode Thread « Figure -2».
Mode
Handelr
Mode
Thread
Démarrage Interruption Fin Interruption Fin

Handler Handler
Figure -2 : Transitions entre modes « Handler » et « thread »
Le Cortex-M3 peut attrib uer aux appli cations, en f onction de l ’état du bit 1 du registre de
contrôle (control [1]), deux niveaux de privilège:
Niveau « Privileged » si control [ 1] = 0: le programme peut utiliser toutes les instructions et
peut accéder à toutes les ressources du processeur.
Niveau « Unprivileged » si co ntrol [1 ] = 1 : Une a pplication a yant ce niveau a un certai n

nombre de limites : elle n e peut accéder au Timer Sy stem (Sy sTick), au contrôleur d’ interruptions
(NVIC) ni aux registres de contrôle du système. En plus, si le Cortex-M3 intè gre un MPU, l’ accès à
certaines zones mémoires peut être interdit à ces applications.
Ces niveaux de privilège offrent plus de sécu rité et de robustesse. En eff et, quand un
programme « UnPrivileged » se trom pe, il sera dans l’im possibilité de m odifier les registres et les
zones mémoire protégés. Ceci est utilisé par les OS em barqués pour protéger les données OS des
applications utilisateur, et éviter une corruption des données ou même un crash du système.
Quand le Cortex-M3 est en mode Handler , les codes exécutés ont to ujours le nive au
« privileged », indépendamment de la valeur du bit du registre de contrôle.
Quand le Cortex-M3 est en mode Thread , les c odes exécuté s peuvent avoir le niveau
« privileged » ou « unprivileged », en fonction de la valeur du bit 1 du registre de contrôle.
Le tableau suivant récapitule les combinaison « mode cortex /niveau de privilège » possibles.
Control [1] = 0 Control [1] =1
Exécution d’une ISR Mode Handler/Niveau Privilged Non autorisé
Exécution d’un programme

Mode Thread/Niveau Privilged M ode Thread/Niveau UnPrivilged
autre qu’une ISR
Tableau 1 : combinaisons possibles « mode Cortex/Niveau de privilège du code »

Pour les transitions entre ces combinaisons, ils doivent respecter les règles suivantes :
1. Au démarrage du système (après reset), le bit control[1] = 0 et par conséquent toutes les parties de
code ont le ni veau « Privileged » par défaut. Ainsi, o n est dans mode Thread/ Niveau privileged.
(puisque Le Cortex-M3 est en mode Thread après reset).
2. A la suite d’une interruption, le Cortex-M3 passe directement à mode Handler/ Niveau privileged.
A la fin du Handler, il retourne au mode Thread avec le niveau de privilège initial (avant Handler).
Remarque : sauf si le Handler modifie l’état du bit control[1]. Voir règle 4)
3. Un programme ayant le niveau « Unprivileged » n’a pas le droit d’accéder au registre de contrôle
et ne peut en aucun cas changer le niveau de privilège.
4. Un programme ay ant le niveau « Privileged » peut changer le niveau de p rivilège des codes
exécutés en mode Thread, en modifiant l’état du bit control[1].
La figure suivante donne les transitions possibles, tout en respectant les règles citées.
Privileged / Handler Mode

Transition par hardware
Contrôle [1] = 0 Transition par software
Contrôle [1] = 0
2
Retour d’Int 2 Interruption
Interruption
Retour d’Int 1
Contrôle [1] = 1 4
UnPrivileged /
Thread Mode Privileged /
Thread Mode
Non autorisé 3
Figure -3 : Transitions entre les combinaison « modes Cortex/ niveaux de privilège »

3- Registres
Le noyau du Cortex-M3 contient un ensemble de registres divisés en deux groupes :

Les registres à usage général
- R0 – R12 : 12 registres 32 bits à usage général qui peuvent être utilisés pour l’ exécution de
n’importe quelle opération (arithmétiques, logiques, transfert).
1
- R13 : il s ’agit du registre pointeur de pile (Stack Register ). En effet, étant donné que le
Cortex-M3 utilise deux piles (Pile principale et Pile process), il s’agit de deux registres matériellement
distincts, mais superposés :
MSP (Main Stack Pointer) : ce registre MSP est utilisé pour pointer sur la pile principale.
PSP (Process Stack Pionter), ce registre PSP est utilisé pour pointer sur la pile pile de process.
Par défaut, la pile principale est utilisée et par cons équent le pointeur MSP. Pour le choix de la pi le
PSP, il faut passer par registre de contrôle (ci-dessous).
- R14 : il s ’agit du registre de lien ( LR : Link Register) qui permet de stocker l’ adresse de
retour (à placer dans PC) quand une fonction ou un Handler est appelé.
- R15: il s ’agit du registre com pteur programme ( PC : Program Counter) qui indique l’ adresse
de l’instruction à exécuter par le processeur.
L’exemple suivant m ontre le fonctionnement de ces deux registres LR et PC. Considérons le

programme de la « Figure -4 » commençant à partir de l’adresse 0x00002000.
Address Instruction
2 Main ( )
3
1 0x00002000 ….
7
0x00002004 ….
0x00002008 call func1( )….
0x0000200C ….
4 ………
5 func1 ( ) {
0x0000F014 ……..
6
0x0000F018 …….
0x0000F01C }
Figure -4 : Exemple de programme avec saut
1
Une Pile (stack) est une mé moire LIFO (Last In First out) o ccupant une partie d e la RAM et u tilisée po ur
passage de paramètres entre fonctions ou pour sauvegarder temporairement les contenus des registres de l’UAL.

Alors, les contenus des registres LR (R14) et PC (R15) évoluent comme suit « Tableau -2 »:
PC (R15) LR (R14)
1) On commence par exécuter main ( ). PC contient l’adresse
0x00002000 -
0x00002000
2) Après l’exécution d’une instruction, PC est automatiquement
incrémenté de 4 (correspondant à 4 octets = 32 bits = la taille d’une 0x00002004 -
instruction)
3) Même chose que l’étape précédente. 0x00002008 -
4) L’exécution de l’instruction à l’adresse à 0x00002008 provoque un
saut
 PC va pointer sur la destination du saut (0x0000F014) 0x0000F014 0x0000200C
 LR va sauvegarder l’adresse que devrait contenir PC après le retour
de func1 (0x0000200C)
5) Le processeur continue l’exécution de func1. LR reste intact. 0x0000F018 0x0000200C
6) La dernière instruction d’une fonction est une instruction de retour 0x0000F01C 0x0000200C
7) Après l ’instruction de retour, le co ntenu de LR est récupéré dans
PC. Le processeur continue l’ exécution de main ( ) a u point ou il a été 0x0000200C -
interrompu.
Tableau -2 : Evolution des contenus des registres LR et PC
Les registres spéciaux
PSRs (Program Status Registers) : Registre de statut du programme qui contient au nombre de 3
- ASPR (Application PSR): Registre d’état relatif à l’exécution du programme.
- ISPR (Interrupt PSR) : Registre d’état relatif à l’interruption en cours.
- ESPR (Execution PSR) : Registre d’état qui do nne des informations sur l’instruc tion en cours
(mode thumb ou ARM et si elle est atomique).
Ces 3 registres 32 bits peuvent être acc édés séparément ou bien être combinés pour construire
un registre unique 32 bits : xPSR « Figure -4 »
31 30 29 28 27 26 :25 24 23 :20 19 :16 15 :10 9 8 7 6 5 4 :0
N Z C V Q ICI/IT T ICI/IT Exception Number
Figure -4 : Structure des registres d’état combinés ( xPSR)

Chaque champ de ce registre donne une information « Tableau -3» :
Champ Description
N Negative : un 1 indique que le résultat de la dernière instruction est négatif
Z Zero : un 1 indique que le résultat de la dernière instruction est nul.
C Carry : un 1 indique que le résultat de la dernière instruction a généré une retenue (carry)
V Overflow : un 1 indique que le résultat de la dernière instruction a dépassé la taille prévue.
ICI/IT Interrupt-Continuable Instruction : l’instruction en cours ne peut être interrompu.
T Toujours à 1 : exécution des instructions en mode Thumb
Exception
Indique le numéro de l’interruption que le processeur est entrain de servir.
number
Tableau -3 : Champs du registre d’états combiné xPSR
Registres de masque d’interruption : On distingue 3 registres qui sont

- PRIMASK : Registre de 1 bit qui permet, s’il est actif, d’interdire toutes les interruptions
sauf l’interruption non masquables (NMI) et l’exception Hardware Fault.
- FAULTMASK : Reg istre de 1 bit qui per met, s’ il est actif, d’ interdire toutes l es
interruptions à l’exception de l’interruption non masquables (NMI).
- BASEPRI : Registre de n bits (n<=8) dont la valeur indique, si elle est différente de 0, le
niveau de priorité des interruptions permises : uniquement les interruptions ayant un niveau de priorité
strictement s upérieur à ce tte valeur sont autorisées. Si cette val eur est égale à 0, alors toutes les
interruptions sont permises.
Registre de contrôle : Un registre de 2 bits ; le bit 1 i ndique le ni veau de privilège des codes
exécutés en m ode thread (Parag. 2); le bit 0 indique le pointeur à utiliser (MSP or PSP) et par
conséquent la pile.
Bit du registre de contrôle Description

1 : La pile process est utilisée  R13 = PSP
Bit 1 : contrôle [1]
0 : la pile principale est utilisée R13 = MSP*
1 : Niveau « Unprivileged »
Bit 0 : contrôle [0]
0 : Niveau « privileged »
* Au démarrage et après reset, le poniteur MSP (main stack) est utilisé par défaut.
Tableau -4 : Registre de contrôle

4- Gestion de la pile
Le Cortex-M 3 peut utiliser deux piles : pile principale ( Main Stack) pointée par le registre
MSP et pile process ( Process Stack) pointée par le registre PSP « Figure - 5 ». L ’objectif de
l’utilisation de deux piles distinctes est la protection des données critiques « e.g. celles gérées par un
OS » des accès par des applications utilisateur (parag ).
Mais, au démarrage et après un reset, uniquement la pile Main Stack est utilisée.
Adresses
+
(par défaut) MSP
Main Stack
PSP
Process Stack
Mémoire
Application
(code + data)
-
Figure -5 : Pointeurs de piles du Cortex-M3
La taille des données à mettre dans ou à récupérer à partir des piles du Cortex-M3 doit être
obligatoirement de 32 bits (taille datapath). Ainsi, chaque donnée occupe 4 octets et par conséquent 4
adresses.
Pour les deux piles la gestion de la pile est ‘full descending’ :
- A l’initialisation le pointeur de pile pointe sur le haut de la pile (Adresse supérieure +4).
- Pour chaque opération PUSH (empilement) qui co nsiste à sauvega rder une do nnée dans la pile :
le pointeur e st d’abor d in crémenté de 4, ensuite la donnée est écrite dans l’em placement mém oire
pointée par le pointeur.
- Pour chaque opération POP (dépilement) qui consiste à récupére r une donnée à partir de la p ile :
la donnée pointée par le pointeur est lue, ensuite le pointeur est incrémenté.
Exemple : Passage de paramètres par pile
L’exemple suivant montre l’évolution d’une p ile (l’adresse du haut de pile est 0x00002100) :
la fonction main ( ) passe à la fonction sum( ) le s contenus des registr es R0 et R1 par la pile. La
fonction sum récupère l es 2 données à partir de l a pile, calcule la so mme et sauvegarde le résultat
dans la pile. Au retour à main, le résultat est récupéré à partir de la pile.

Main ( ) 0
….
Pile
R0  10 Adresse R0 = 10
Sum { SP 0x00002104 -
0 R1  8 R1 = 8
3 POP R2 0x00002100 -
1 Push R0
0x000020FC -
2 Push R1 4 POP R3 R2 = -
0x000021F8 -
Call sum ( ) R3  R2+R3 0x000021F4 - R3 = -
6 POP R0 5 PUSH R3 0x000021F0 -
…. }
1 2
Pile Pile
Adresse R0 = 10 Adresse R0 = 10
0x00002104 - 0x00002104 -
SP 0x00002100 10
R1 = 8
0x00002100 10
R1 = 8
0x000020FC -
SP 0x000020FC 8
R2 = - R2 = -
0x000021F8 - 0x000021F8 -
0x000021F4 - R3 = - 0x000021F4 - R3 = -
3 4
Pile Pile
0x00002104 -
SP 0x00002104 -
SP 0x00002100 10
R1 = 8
0x00002100 10
R1 = 8
0x000020FC 8 R2 = 8 0x000020FC - R2 = 8
0x000021F8 - 0x000021F8 -
0x000021F4 - R3 = - 0x000021F4 - R3 = 10
5 6
Pile Pile
0x00002104 -
SP 0x00002104 -
SP 0x00002100 18
R1 = 8
0x00002100 18
R1 = 8
0x000020FC - R2 = 8 0x000020FC - R2 = 8
0x000021F8 - 0x000021F8 -
0x000021F4 - R3 = 18 0x000021F4 - R3 = 10
Figure -6 : Evolution de la pile
0) R0 et R1 sont initialisés (10 et 8 ). Etant donné que la pi le co mmence à l’ adresse

0x00002100 (haut de la pile), le pointeur est initialisé à la valeur 0x00002104 (haut de la pile +4).
1) Push R0 : le pointeur SP est décrémenté de 4 (0x00002100), le contenu de R0 est écrit dans
l’adresse pointée par SP.
2) Push R1 : le pointeur SP est décrémenté de 4 (0x000020FC), le contenu de R1 est écrit
dans l’adresse pointée par SP.

3) Pop R2 : le contenu de la pile p ointé par SP est tr ansféré vers R2. Ensuite, SP est
incrémenté de 4 (0x00002100).
4) Push R3 : le contenu de la pile pointé par SP est transféré vers R3. Ensuite, SP est
5) Push R3 : le pointeur SP est décrémenté de 4 (0 x00002100), le contenu de R3 (18=8+10)
est écrit dans l’adresse pointée par SP.
6) Pop R0 : le contenu de la pile p ointé par SP est tr ansféré vers R0. Ensuite, SP est
5- Organisation de la mémoire
Le noyau Cortex-M3 ay ant une architecture Harvard, il possède deux Bus : un bus code pour
récupérer les instructions et un bus data pour récupérer les données.
Les bus possèdent chacu n 32 lignes d’ adresses, par conséquent le noy au Cortex-M3 est
capable d’accéder à un espace d’adressage total de 2 32 octets = 4 GO.
Les 32 lignes d’adresses (ainsi que les registres) permettent d’accéder à une mémoire avec des
mots (taille d’une case de la mémoire) de 32 bits, soit 4 octets.
Puisque l’unité d’adressage est toujours l’octet, chaque mot de la mémoire (32 bits = 4 Octets)
occupe 4 adresse s: le 1 er mot de la mémoire ( mot 0) occupe l’ adresses 0, le 2 ème mot (mot1) occupe
l’adresse 4, etc… « Figure- 7 a) ».
Même si physiquement l’accès à une mémoire ne se faut que par mot (32 bits dans ce ca s), on
peut identifier chaque octet (Parag. 6.1). Dans ce cas, le plan d’adressage est le suivant « figure -7 b) ».
Adresses
Bit :31 …….. 0 31………24 23 …… 16 15 ………8 7 ………..0
0xFFFFFFFC 0xFFFFFFFF 0xFFFFFFFE 0xFFFFFFFD 0xFFFFFFFC
…….
… ………
…. ……..
mot 2 0x00000008
mot 1 0x00000004 0x00000007 0 x00000006 0x00000005 0x00000004
mot 0 0x00000000 0x00000003 0 x00000002 0x00000001 0x00000000
a) b)
Figure -7 : Plan d’adressage d’une mémoire de 4 GO a) par mot de 32 bits - b) par octet

En ce qui concerne l’int erconnexion entre mémoires/périphériques et bus code et data, le

Cortex-M3 intègre une matrice d’interconnexions ( AHB Bus Matrix) qui permet de multiplexer les
bus code et data et de déter miner les zones mémoire pouvant être accédées par le bus Code 2 « Figure-
8 ».
Microcontroller
Cortex-M3 FFFF FFFF

Vendor specific
0,5 GO
E010 0000
CM3 peripherals
(NVIC, Systick,…)
CM3 Core 1 MO
E000 0000
External
Instructions Data Internal Peripheral Device
Bus 1 G0
A000 0000
External
MUX
RAM(EX)
1 GO
6000 0000
Peripheral
MUX
0,5 GO
System Bus 4000 0000
RAM (EX)
0,5 GO
2000 0000
MUX
Code zone
D-code Bus ROM/RAM
(EX) 0,5 GO
0000 0000
MUX
SWD/JTAG
(Debug) I-code Bus
(EX) : peut contenir du code
Bus Matrix exécutable (des instructions)
(with
Bitbanding,
Alignement) Interface pour le charg ement
des programmes
Figure -8 : Bus du Cortex-M3 & Organisation de la mémoire
La matrice en bus permet de multiplexer les bus du noyau :
 Les bus I-code et D-code sont respectivement la continuité des bus Code et Data du noyau.
 Ces bus ne peuvent accéder qu’à la zone inférieure (0x00000000 à 0x20000000 = 0,5 GO) qui
est destinée à contenir du code exécut able du programme ainsi que les données (vari ables
déclarées du programme). Générale ment, les c onstructeurs placent une m émoire Flash dans
cette zone.
2
Le bus DATA peut accéder à la totalité des zones mémoire.

 System bus peut véhiculer, selon les bits de sélection, le bus Code ou Data.
 Ce bus peut accéder pratiquem ent à la totalité de la zone m émoire supérieure ( 0x20000000
à 0xFFFFFFFF ~= 3,5 GO) qui est subdivisée en plusieurs espaces :
- Mémoire RAM interne.
- Zone des périphériques ajoutés par le constructeur du microcontrôleur (convertisseur
A/N, Timer, port Ethernet, etc..).
- Mémoire RAM externe (à connecter au microcontrôleur).
- Zone de périphériques externes qui peuvent être connectés au microcontrôleur.
- Enfin, une zone dédiée au constructeur pour placer son propre Firmware.
Il faut noter, que toutes ces zones peuvent être accédées pour lire ou écrire des données (Data
bus). Mais, u niquement les zones mémoires RAM peuvent conte nir du co de exécutable ( car les seules
accédées par le bus Code. Mais la vitesse de transfert des instructions est infère ure à la zone code).
 Internal Peripheral Bus : c’est un bus interne au process eur Cortex-M3 et permet au noy au
d’accéder aux registres des périphériques internes (NVIC, Systick, Debug, etc..). Ces registres
occupent une zone de 1 MO (0xE0000000 à 0xE0100000).
6- Fonctionnalités intégrées du Bus Matrix : Bitbanding & Data Alignement
En plus du multiplexage des bus, le Bus Matrix intègre également d’autres fonctionnal ités :
Data Alignement, Bit Banding, etc..
6-1 Accès aux données non alignées (Unaligned Data Access)
Etant donné que l’ accès à une mém oire ne se fa it que par mot (32 bits) correspondant à une
case mémoire, les données stockées devr aient être a lignées, c.a.d qu’ une donnée doit être placée dans
une case mémoire 32 bits quelque soit sa taille. La F igure suivante montre un exemple d’accès aligné
aux données dans une mémoire 32 bits.
bit 31…24 23...16 15.. 8 7… 0

Unit16_t u;
u
Uint32_t a ; a
x Espace
Unit8_t x,y,z perdu
y
z
Figure -9 : Accès alignée aux données dans une mémoire 32 bits

On voit bien, qu’une grande partie de la mémoire est perdu. Ce gaspillage n’e st pas perm is
dans des systèmes embarqués ou la taille disponible de la mémoire est limitée.
C’est pourquoi, le Cortex-M3 est équipé d’un Bus matrix qui est capable de gé rer l’accès aux
données de manière non alignées « Figure -10 ».
31…24 23...16 15... 8 7… 0 bit

Unit16_t u; u a
a x y
Uint32_t a ; z Espace
Unit8_t x,y,z gagné
Figure -10 : Accès non alignée aux données dans une mémoire 32 bits
On voit bien que les données sont mises l’une après l’autre sans se préoccuper de les placer au
début d’ une case mémoire. On peut mê me divi ser une donnée (uint32_t a) sur 2 cases mémoires
différentes. Ceci est également vrai pour les instructions qui peuvent être de 16 ou 32 bits (Parag 8).
L’accès est transparent pour le programmeur (ainsi qu’au noyau CM3), c’est le Bus Matrix qui
s’occupe de lire la case (ou les cases) et d’extraire la donnée (ou l’instruction) demandée.
6-2 Bit Banding
Il s’agit d’une technique permettant de lire l’état d’un bit ou de modifier sa valeur en une seule
instruction.
En effet, la façon conventionnelle pour modifier la valeur d’un bit i d’une variable ou une case
mémoire x passe en 3 instructions. L’exemple suivant montre comment mettre à 1 un bit i :
I
x .. … … bi .. b 2 b1 b0 1- Lire x :
1
x  Reg
Reg .. .. bi .. .. b 1 b0
OR 2 2- M asquage et modification du bit i

3 2 i
000 1 000 0 Reg = Reg OR 2 i
x .. … … 1 .. b2 b1 b0 3- Ecriture dans x :
Reg  x
Figure -11 : Modification ‘conventionnelle’ de la valeur d’un bit

Ces lecture et modifications de bits sont fré quentes dans les sy stèmes e mbarqués et surtout
temps réel ; ou les états des tâches et des sémaphores sont représentés par des bits.
Avec cette fa çon, un problè me peut se poser : entre la prem ière instruction et la deuxième ou
bien entre les instructions 2 et 3, un Handler ou une tâche pourrait être lancé e t changer l’ état de la
variable x. Ceci peut causer la corruption des données et un dysfonctionnement du système.
Pour palier à ce problème et exécuter ces instructions d’un façon atomique (sans interruption),
l’idée était soit d’ utiliser un sémaphore pour pr otéger la partie du code ou bi en la désacti vation des
interruptions avant l’exécution des instructions. Dans le deux cas, la solution es t pénalisante en ter me
de performances du système.
Le Cortex-M3 pro pose deux zones de 1MO pouvant être accédées directement bit par bi t :
ces zones sont appelées Bit-Band Region.
L’accès à un bit ne se fait pas directement, mais se fait par accès à une case mémoire ‘alias’ de
32 bits : L’écriture d’une valeur (0 ou 1) dans cette case mémoire provoque directement l’écriture de
la même valeur dans le bit correspondant.
L’ensemble des cases mémoires ‘alias’ correspondants aux bits d ’une zone Bit-Band Region
est appelé zone Bit-Band Alias. On trouve ainsi deux zones Alias de 32 MO chacune (1MO*32).
Les deux zones Bit-Band Region et Bit-Band A lias du Cortex-M 3 sont dispo nibles dans les
zones RAM et Peripheral « Figure 12 ».
0x43FF FFFF
Alias
Peripheral (32 MO)
0,5 GO 0x4200 0000
0x23FF FFFF
0x400F FFFF
Alias Bit-Band Region
RAM
(32 MO) (1 MO) 0x4000 0000
0,5 GO
0x2200 0000
0x200F FFFF
Bit-Band Region
(1 MO)
0x2000 0000
Figure -12 : adresses de bases et taille des zones Bit-Band & Alias

La correspondance entre u n bit de la zone Bit- Band region et le registre correspondant de la

zone Alias se fait comme suit « Figure -13 » :
Le bit 0 du la prem ière case mémoire de la zone Bit- Band region correspond au 1 er mot (mot
0) de la zone Alias (adresse offset = 0), le deuxième bit correspond au 2 ème mot (adresse offset = 4), le
bit 31 correspond au registre 31 (adresse offset = 31*4 =0x7C).
Le bit0 de l a deuxièm e case mémoire de la zone Bit-Band region correspond au regist re
suivant, c.a.d le registre 32 (adresse offset = 32*4 = 0x80) du mot suivant. Et ainsi de suite.
Alias Offset
Mot 0xFFFFF 0x00FF FFFC
……
……
Mot 32 0x0000 0080
Alias Mot 31 0x0000 007C
…… …….
Mot 1 0x0000 0004
Alias Base Mot 0 0x0000 0000
Adress
Bit-Band Offset
b31 b30 …………………………….b3 b2 b1 b0 0x000F FFFC

……………….. ….
Bit-Band ..
…………………… ..
b31 b30 …………………………….b3 b2 b1 b0 0x 0000 0004
Bit-Band Base b31 b30 …………………………….b3 b2 b1 b0 0x 0000 0000
Adress
Figure -13 : Correspondance entre bits de la Bit-Band Region et mots de la zone Alias
Ainsi, cette relation peut être généralisée comme suit :

Le bit i (0 <= i <= 31) de la case mém oire occupant l’adres se Bit- Band_offset
(0<=Bit-Band_Offset <=0xFFFFC) peut être accédé à travers le mot de la zone Bit-Band Alias ayant
l’adresse Alias_Offset : Alias_offset = Bit_Band_Offset * 32 + i*4
Pour avoir l ’adresse absolue du m ot, il suffit d’additionner l’adresse de base de la zone Alias
Alias_Base : Alias_Adress = Alias_Base + Bit_Band_Offset*32 + i*4
Les adresses de base étant « Tableau -5 »:
RAM Peripheral
Bit-Band Base Address 0x2000 0000 0x4000 0000
Alias Base Address 0x2200 0000 0x4200 0000
Tableau -5 : Registre de contrôle

Exemple : Quelle est l’adresse absolue du mot de la zone Alias doit être utilisé pour m odifier
le bit 15 de la case mémoire 0x40000300
L’adresse 0x4000 0300 correspond à une région Bit-Band de l’espace Peripheral. On a donc:
Bit-Band_Base = 0x4000 0000 & Alias_Base = 0x4200 0000
Le bit à mapper occupe l’adresse absolue 0x4000 0300 :

 Qui correspond à un Bit-Band_Offset = 0x4000 0300 - 0x4000 0000 = 0x300.
Ainsi, l’adresse absolue du mot de la zone Alias est :

Alias_Adress = Alias_Base + Bit_Band_Offset*32 + i*4
 Alias_Address = 0x4200 0000 + 0x300 * 32 + 15* 4 = 0x4200 603C

7- Organisation d’un programme dans une mémoire & Séquence de

démarrage du Cortex-M3
Une fois un programme compilé et chargé dans la mémoire d’un système à base du CortexM3,
la mémoire aura la structure suivante « Figure -14 »:
Le premier mot placé à l’offset 0 est occupé par l’ adresse de la pile (Main Stack). Le reste des
premiers 1024 octets sont occupés par les adresses des ISRs : Table des vecteurs d’interruptions.
L’espace suivant la table des v ecteurs d’interruptions est utili sés par les code des ISRs : le
code de l’ISR1 (déclenché par un reset) est placé directement à l’adresse 1024.
Ensuite vient le(s) programme(s) tournant en arrière plan tel que le Main.
Enfin, est pla cée la mémoire pile (Main Stack ). Contrairement aux codes, l’ adresse de début
d’une pile correspond à son adresse supérieure. La taille de la pile étant fixé par le programmeur avant
la compilation
Etant donné que lors de la co mpilation, les taill es des codes et de la pile so nt connues, le
compilateur va initialiser le m ot 0 avec l’adresse de la pile @MStack et l a table avec l es adr esses
correspondantes des ISRs
Memory
Ctrl Adress Offsetc
Reset
@MStack
Adr. Main Stack
Processor
Data
Main
ISR i
@_Main
…
saut
ISR2
ISR 1 = Boot code
(Reset_Handler) 1024 0x0000 0100
@_ISR 255
1020 0x0000 00FF
Table des …….
Vecteurs @_ISRi
d’interruptions 4i
(255 vecteurs) …………….
……………
8 (0x00000008)
Int 1 = Reset @_ISR1 = 0x00000100
4 (0x00000004)
MSP = @MStack
Address base 0 (0x00000000)
Figure -14 : Organisation d’un programme dans une mémoire (Cortex-M3)

Une fois le processeur mis sous tension (reset), il :

1- Récupère le contenu de l’adresse offset 0 (@MStack) et le place dans le registre R13 qui sert de
pointeur sur la pile.
2- Récupère le contenu de l’adresse offset 4, qui corr espond à l’ adresse de l’ ISR1 (@ISR1 =
1024), et le place dans le registre R15 = PC (Program Counter)  PC = 1024.
3- Commence à exécuter le Handler placé à l’adresse 1024 (ISR1 = Reset) et qui correspond à un
code de boot (de démarrage) fourni par la société ARM et qui permet d’initialiser les registres
système et de faire à la fin un saut vers l’adresse @Main.
A ce point, l a séquence de démarrage finit et c’est le programme utilisateur ( Main) qui va

prendre la main pour configurer l’horloge, les interruptions, etc…
8- Instructions Cortex-M3
8-1 Thumb-2 Instruction Set Architecture
L’architecture d’un jeu d’instructions ( ISA : Instruction Set Architecture) d’un processeu r
définit la taille (ou les tailles) des i nstructions ainsi que les formats possibles (la di vision de
l’instruction en cha mps) et les valeur s binaires que peut prendre chaque chaque cha mp et leurs
signification.
La figure suivante est un exe mple d’une inst ruction ARM de 16 bits (Ins truction 1 6 b its
Thumb). Qui permet d’eff ectuer une addition du contenu du registre R1 et d ’un une valeur immédiate
sur 8 bits :
00110 001 00001010 ADD R1, R1 #10

Opcode Opérande 1&2 Opérande 3
ADD Registre R1 Valeur R1  R1 + 10
Figure -15 : Exemple d’instruction Thumb 16 bits
Cette instruction contient 3 champs :

- Opcode (Operation Code) : le code op ératoire qui indique l’opération à réaliser (soustraction ,
multiplication, addition, etc…). Avec 5 bits, on peut réaliser 32 types d’opérations.
- Deux Opérandes : La pre mière est un e référ ence à un re gistre (avec 3 bits, on peut référencer
jusqu’à 8 registres : de R0 à R7). La deuxième est une valeur sur 8 bits.
Même si ce format présente un avantage quant à la taille, il ne permet d’utiliser que 8 registres
du processeur, et uniquement deux opérandes : puisque le regi stre R1 joue le rôle de source et
destination.

Pour contourner ces limites, des instructions 32 bits ont été introduites. L’instruction
ADD R8, R3, # 200 (R8  R3 + 200)
permet d’utiliser tous les registres, deux registres différents comme source et destination et enfin une
valeur immédiate sur 12 bits. Le format de l’instruction est comme suit :
32 …. 28 27 …. 26 25 24… 21 20 19 …16 15…12 11 0

COND 00 I 0100 S 0011 1000 110010000
Maj or Minor Opé rande 1 Registre Opérande 2
Opcode Opcode R3 Destination Valeur
R8
ADD
Figure -16 : Exemple d’instruction 32 bits (Cortex-M)
Dans ce cas, le format est un peu plus complexe :

- Le code opératoire est d ivisé sur deux cham ps : Major Opcode qui déte rmine le ty pe de
manipulations à exécuter (transfert, opérations ar ithmétiques, opérations logi ques, …) et Minor
Code qui détermine l’opération même. (ADD  Major Code = 00 et Minor Code = 0100).
- 2 opérandes : un registre (jusqu’à 16) et une valeur immédiate sur 12 bits.
- Un registre destination (jusqu’à 16 possibles).
Pour les autres champs :

- COND : permet de spécifier une condit ion (plusieurs sont disponibles) qui, si elle est vérifiée,
autorise le processeur à effectuer l’addition. Sinon le processeur va passer à l’instruction suivante sans
exécuter l’addition. La condition est toujours relative à l’instruction précédente.
Exemple : CMP R8, 0 // Comparer le contenu de R8 et 0
ADDNE R8, R3, #400 // Si R8 différent de 0 (NE = Not Equal)
L’uti lisation du champ COND per met d’ exécuter la co mparaison et l’ opération en un seul
cycle, contrairement aux autres processeurs (tel que X86) qui utilisent des instructions différentes pour
les comparaisons et les opérations.
Il faut noter q ue le processeur est informé du résultat de l’opération précédente par l e biais du
registre d’état xPSR (Parag. 3 – Tableau -3).
- S (Set Flag Status) : C’est un bit qui indique si l’instruction doit mettre à jour ou non le registre
d’états. Au niveau de la syntaxe, il faut ajouter un S à l’instruction :
ADDS : Le processeur effectue une addition et ensuite met à jour le registre d’ état. Pour les
modifications faites après une opération (voir parag 8.2)
ADD : Le processeur effectue une addition sans modifier le contenu du registre d’état. Po

Le fait d’util iser des instructions 16 et 32 bits conjointement n’est pas nouv eau pour les
processeurs ARM. Mais, pour les anciennes architectures (v4, v5) il était indispensable de basculer
d’un m ode 16 bits à un mode 32 bits et vice versa par soft (u ne instructio n de comm utation). Ceci
cause une baisse des performances du processeur.
Pour l’ architecture v7 (Cortex), les instructions ARM 32 bits ont été délaissé es, et de
nouvelles instructions Thumb 32 bits ont été introduites. Ces instructions ont été choisies de telle sorte
que le processeur, en analy sant les 16 prem iers bits, reconnaisse auto matiquement s’il s’agit d’une
instruction 16 bits ou 32 bits. Ainsi, le processeur n’est plus obligé de basculer d’un mode à l’autre.
L’ensemble des instructions 16 bits T humb et 32 bits Thum b forment : le jeu d’instructi on
Thumb-2. Cortex-M n’utilise qu’une partie des instructions Thumb 32 bits.
D’après AR M, Le jeu d’ instructions Thumb-2 perm et d’optimiser l’utilisation de l’espace
mémoire san s dégrader le s perfor mances puisqu’on n’ est plus obligé de basculer entre modes de
fonctionnement « figure 17». Des benchmarks réalisés donnent une performance de 1,2 DMIPS/MHz,
c'est-à-dire le Cortex-M3 e xécute, en moy enne, une instruction en moins d’un cycle horloge (1/1,2 =
0,833 cycle) .
Figure 17 : performance et densité du code pour différents jeux d’instructions ARM

8-2 Instructions Assembleur Cortex-M
Les instructions ARM possèdent la syntaxe suivante

Operation operand1 , operand2, [operand3] //[ optional]
Destination , source(s)
Exemples: ADD R1, R1, #10 ; ADD R8, R3, #200
C’est le compilateur qui doit ensuite décider : si l’instruction peut être codée sur 16 bits, alors
il va choisir un format 16 bits, sinon il va devoir utiliser un format 32 bits.
Mais, il est possible d’i mposer au com pilateur d e choisir un format préci s en utilisant les
suffixes W (Wide : 32 bits) et N (Narrow : 16 bits). Dans ce cas, le com pilateur va essay er de coder
l’instruction au for mat choisi. En cas d’impossibilité, il génère u ne erreur. C es suffixes sont utilisés
comme suit :
ADD .W (coder l’addition sur 32 bits)
ADD .N (coder l’addition sur 16 bits)
Le processeur Cortex ayant une architecture RISC, toutes les opérations de traitements portent
sur des registres ou des valeurs i mmédiates. Uniquement les opérations de transfert peuvent accéd er à
la mémoire.
On présentera quelques instructions des différents types de traitements.
Instructions de transfert
Instruction Description
MOV Rd, #valeur Rd  valeur
MOV Rd, Rn Rd  Rn
LDRB Rd, [Rn, #offset] Lire un byte de la case mémoire d’adresse Rn+offset
LDRH Rd, [Rn, #offset] Lire 16 bits (Half Word) de la case mémoire d’adresse Rn+offset
LDR Rd, [Rn, #offset] Lire un mode de 32 bits de la case mémoire d’adresse Rn+offset
STRB Rd, [Rn, #offset] Ecrire le byte poids faible de Rd dans la case mémoire d’adresse Rn+offset
STRH Rd, [Rn, #offset] Ecrire 16 bits poids faible de Rd dans la case mémoire d’adresse Rn+offset
STR Rd, [Rn, #offset] Ecrire le contenu de Rd dans la case mémoire d’adresse Rn+offset
Push Rs Transférer le contenu de Rs vers la case mémoire de la pile (@R13 -4)
Pop Rd Transférer le contenu de la case mémoire de la pile (@R13) vers Rd.
Tableau -6 : Instructions de transfert

Instructions arithmétiques
Instruction Description Exemples

ADD Rd, Rn, Rm Rd  Rn + Rm
ADD Addition ADD Rd, Rd, Rn Rd  Rd + Rn
ADD Rd, #valeur Rd  Rd + valeur
Rd  Rn + Rm + Carry (Carry étant un bi t
du registre d ’état dont l a v aleur dépend de
Addition with Carry
ADC ADC Rd, Rn, Rm l’opération précédente : (1 : si l’opération
(avec retenue)
précédente a généré une retenue, 0 sinon).
ADC Rd, Rd, #valeur Rd  Rd + valeur + carry
SUB Rd, Rn, Rm Rd  Rn – Rm
SUB Soustraction
SUB Rd, Rn, #valeur Rd  Rn - valeur
Multiplication MUL Rd, Rd, Rn Rd  Rd * Rn
MUL 16 bits (résultat sur
MUL Rd, Rn, RM Rd  Rn * Rm
32 bits)
Multiplication 32 {Rd1,Rd2} Rn*Rm : les 32 bits poids fort

UMULL Rd1, Rd2,
UMULL bits non signée du résultat sont stockés dans Rd2 et les 32
Rn, Rm
(résultat sur 64 bits) bits poids faible dans Rd1.
SMULL Même que UMULL , mais pour une multiplication signée (S : signed).
Tableau -7 : Instructions arithmétiques
Instructions logiques

AND Rd, Rd, Rm Rd  Rd & Rm
AND Et logique bit par bit ADD Rd, Rn, #valeur Rd  Rn & valeur
ADD Rd, Rn, Rm Rd  Rn & Rm
ORR OU logique bit par bit Même exemples
ORN Non ou bit par bit Même exemples

EOR XOR bit par bit Même exemples
BIC Rd, Rd, Rn Rd  Rd & (~ Rm)

Bits Clear : Mise à 0 de
BIC Rd  Rn & (~valeur)
bits BIC Rd, Rn, #valeur
~ étant l’inverse bit par bit
Tableau -8 : Instructions logiques

Instructions conditionnelles & Registre d’état
Une grande partie des opér ations (instructions présentées) peuvent être exécutées d’une façon
conditionnelle. Dans ce cas, la syntaxe de l’instruction devient :
Operation [COND] operand1 , operand2, [operand3] // [ optional]
 L’opération n’est exécutée que si la condition COND est vérifiée. La condition COND est
relative au résultat de l’instruction précédente qui est souvent (mais pas toujours) une comparaison :

Comparaison de deux CMP Rd, Rn
CMP registres ou d’un
CMP Rd, #valeur
registre et une valeur
Tableau -9 : Instruction de comparaison
et elle est mémorisée dans un ou plusieurs bits du registre d’état « Figure -18 ».
31 30 29 28 27 26 :25 24 23 :20 19 :16 15 :10 9 8 7 6 5 4 :0
N Z C V
Figure -18 : Bits du registre d’état mémorisant l’état de la dernière opération
Ces bits sont mis à jour après l’exécution de chaque instruction en fonction du résultat obtenu.
Le tableau suivant donne quelques exemples d’instructions et leurs effets sur les bits du registre d’état.
Instruction Résultat Bits du registre d’état modifié

=0 Z=1
ADDS* ,
Dépasse 32 bits C=1
SUBS*,
<0 N = 1
MULS*, …
>0 N = 0
A=B Z=1
Cmp A,B A<B N=1
=A>B N 0
Tableau -10 : Effets des instructions sur les bits d’état
* l es i nstructions 32 bits Thum b-2 ne m ettent pas à jo ur aut omatiquement l es bi ts du re gistre d ’état. Il faut
obligatoirement ajouter le suffixe S (State) , sinon les bits ne seront pas mis à jour.

En ce qui concerne les conditions COND, 16 sont dispo nibles. On présente ci-dessous
quelques unes.
COND Description Bits d’état

EQ Equal (égal = =) Z = 1
NE Not Equal (différents) Z = 0
LS Lower or Same (<=) C = 0 ou
= Z 1
GE Greater or Equal (>=) N = V
LT Less Than (<) N et V différents
GT Greater Than (>) Z = 0, N = V
LE Less or Equal (<=) Z = 1, N et V différents.
Tableau -10 : Conditions possibles
L’exemple suivant m ontre l’utilisa tion des instructions conditionnell es. Le code ‘C’équivalent est
donné.
Code ‘C’ Code Assembleur
If (x = = 0) cmp R0, #0
{
x = y+1 ; ADDEQ R0, R1, #1
}
else
{ ADDNE R1, R0, #1
y = x +1 ;
}
// En supposant que R0 contient x et R1 y
Instructions de saut
Ces instructions permettent de faire un saut ve rs une adresse, ou bien vers une fonction. Le
saut peut être inconditionnel (Tableau -11).
B Branch : faire un saut vers une adresse (un Label ou étiquette dans un programme)
Branch with Link : faire un saut et sauvegarder l’adresse de retour dans le registre LR (R14).
BL
Cette instruction est utilisée pour faire appel à une fonction
Tableau -11 : Instruction de saut conditionnel

Ou bien conditionnel, c.a.d que le saut ne sera effectué que si la condition spécifiée est remplie.
B [COND] Branch si COND vraie. COND peut être l’une des expressions du « Tableau -10 »
Tableau -12 : Instruction de saut inconditionnel
Thumb-2 offre également une instruction qui combine le saut et la co mparaison pour gagner
en nombre d’instructions et en vitesse d’exécution « Tableau -13 ».
CBZ Compare & Branch if Zero : faire une comparaison et faire un saut si égale à 0
CBNZ Compare & Branch if Not Zero : faire une comparaison et faire un saut si différent de 0.
Tableau -13 : Instruction de saut et comparaison combinées
Le programme suivant montre l’utilisation des in structions de saut. Le programme permet de

faire appel à une fonction (10 fois), Un code équivalent en ‘C’ est également donné.
Code ‘C’ Code Assembleur
i = 10; MOV R1, #10 ; // Initialiser R1 avec le nombre d’appels (10)

while (i != 0 ) Boucle: CBZ R1 , Bouclefin ; //Saut vers Bouclefin (Fin itérations) si R1 = 0
{ BL func1 ; // Faire appel à la fonction Func1
func1(); SUB R1, #1 ; // R1  R-1
} B Boucle // Faire un saut vers le label Boucle
Bouclefin: ……
Ainsi l’appel à la fonction func1 est exécuté 10 fois. Au niveau d’un programme assem bleur,
on ne peut utiliser les adr esses pour faire des sauts (on ne les connaît pas), mais plutôt des label s
(étiquettes). C’est ensuite au compilateur et à l’éditeur de lien de les remplacer par les adresses.

Chapitre 2 Entrées Sorties du STM32 : GPIO
Chapitre 2
Entrées Sorties GPIO du STM32 :
Présentation & Programmation par accès aux registres
Par Damergi Emir
1. Introduction
Pour la commande, l’acquisition o u la communication, les microcontrôleurs disposent de pins

(broches) permettant de v éhiculer les signaux élect riques du m icrocontrôleur v ers l’extérieur (Sortie
ou Output) et de l ’extérieur vers le m icrocontrôleur (Entrée ou Input) : on pa rle d’Entrées-sorties à
usage général (GPIO : General Purpose Inputs Outupts).
Ces entrées- sorties (IO) so nt regroupées en ports de 16 IO. On peut trouver jus qu’à 7 ports
dans un m icrocontrôleur STM32 (no tés GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, GPIOF et
GPIOG), soit jusqu’à 112 IO « figure -1 ».
.
Jusqu’à 7 ports - jusqu’à 112 IO
16 IO (pins) par port
Port Port Port

Enable Enable
GPIOA GPIO…. GPIO…
AFIO Enable
(Pin Remapping if Enabled)
Pin (broche) Default connexion

Peripherals
IO Cell (USART, Timer, ADC, SPI, etc..) Pin Remapping
(Cellule E/S) (Multiplexage)
Figure 1- Structure du périphérique GPIO
Damergi Emir 2017

Chapitre Entrées Sorties du STM32 : GPIO
Chaque port GPIO possèd e son propre signal d’horl oge et contient des registres de contrôle
qui déterminent le mode de fonction nement des pins ( Parag. 2) ainsi que des r egistres permettant de
lire l’état binaire des pins en entrée et d’imposer l’état des pins en sortie.
Ces pins sont égale ment reliés aux différe nts périphériques du microcontrôleur (USART,
Timer, ..) à t ravers l’ AFIO (Auxiliary Function Input Output). L’AFIO permet de multiplexer les
connexions entre pins et périphériques. Il offre ainsi une flexibilité au niveau du choix du pin à utiliser
pour véhiculer un signal donné. Quand l’AFIO est désac tivé, les connexions par défaut entre pins et
périphériques sont établies. Une fois l’AFIO activé, il est possible de remapper (m ultiplexer) les pins
(voir Chapitre AFIO).
2. Architecture d’un port GPIO & modes de fonctionnement des IO
Chaque port GPIO est constitué de :

 16 cellules identiques « Figure-2 » consistant chacune en une circuiterie électronique conne ctée à
un pin externe et pouvant être configurée afin de déterminer le sens (Entrée ou sortie) ain si que
les caractéristiques électriques du pin. Il est à noter q ue chaque pin d’un port peut être con figuré
en entré ou sortie indépendamment des autres pins du même port.
Figure -2- Structure d’un Port GPIO (Une seule cellule est représentée parmi les 16)
Damergi Emir 2017

Les IO du STM32 sont de type Five Volt Tolerant (FT), c'est-à-dire qu’ils peuvent supporter
une tension d’entrée de 5V sans dommage ou dysfonctionnement.
Des r egistres occupant des adres ses de la zone BitBanding et pouvant être accédés co mme
mots de 32 bits :
 Un registre d’ entrées (Input Data Register : IDR) de 32 bits. Les 16 bits poi ds faible étan t
utilisés pour la lecture des valeurs logiques issues des 16 pins du port.
 Un registre de sorties (Output Data Register : ODR) de 32 bits. Les 16 bits poids faible étant
utilisés pour imposer les valeurs logiques au niveau des 16 pins du port.
 Un registres de Mise à 1 ( Bit Set Reset Register : BSRR) et un registre de remise à 0 et (Bit
Reset Register : BRR). Par le biais de ces registr es, il est possible de changer l’ état d’un ou
plusieurs bits du registre ODR, et par conséquent les sorties GPI Os, en en un seul cycle : on
parle d’accès atomique [voir paragraphe ].
 2 registres de configurati on ( Control Register High /Low : CRH/CRL) perm ettant de
déterminer le sens, le mode de fonctionnement et la fréquence de commutation des GPIOs. A
cette fin, 4 bits sont utilisés pour chaque IO, et donc 64 bits (4*16) pour la totalité des 16 IOs
d’un GPIO. D’où la nécessité d’utiliser 2 registres de 32 bits.
Les différentes configurations possibles en fonction des valeurs des 4 bits sont données dans le
tableau1. A l’initialisation, tous les IO sont configurés en ‘Input Floating’.
Configurations Bit3 Bit2 Bit1 Bit0 Speed

(Mhz)
Entrée Analogique vers Pour les IO en
Anlog Input 00
le convertisseur A/N 00 entrée, la vitesse
Input Floating 01 (par est déterminée par
Entrées
Entrées vers Registre

IDR & défaut l’extérieur et non
Input Pull-Up 10
vers périphériques après pas par le STM32
Input Pull-down 11
(Alternate Functions) reset) (toujours 00)
Output 01 10 Mhz
00 10 2 Mhz
Sorties à partir du Push-Pull
11 50 Mhz
registre ODR Output 01 10 Mhz
01 10 2 Mhz
Open-Drain
Sorties
11 50 Mhz
Alternate Function 01 10 Mhz
10 10 2 Mhz
Sorties à partir des push-pull
11 50 Mhz
périphériques Alternate Function 01 10 Mhz
(Alternate Functions) 11 10 2 Mhz
open drain
11 50 Mhz
Tableau 1 : Configurations possibles des Entrées-sorties du STM32
Damergi Emir 2017

 Un registre de verrouillage de la confi guration ( Configuration Locking R egister) utilisé

pour i nterdire la m odification d u conten u des registres de configur ation (CRH et CRL) sauf
après un reset. Ceci protège contre les manipulations inv olontaires et les perturbations
électromagnétiques.
3. Accès atomique aux registres
Pour la lecture du conten u des registres d’en trée IDR des ports GPIO, il est possible de lire
l’état d’un bit unique en une seule instruction (1 cycle) en utilisant le mécanisme du Bitbanding.
Pour l’écriture dans les registres de sortie ODR, même si ce s registres font partie de la zone
BitBanding, le microcontrôleur STM32 offre un mécanisme plus performant pour la mise à jour de la
valeur d’un ou plusieurs bits en un seul cy cle. Ceci est assuré par l’utilisation des registres B SRR et
BRR.
Supposons que le registre ODR contient la donnée suivante (0x8F0B)
b31 b16 b15 ……… …… b0
1 0 0 0 1 1 1 1 0 0 0 0 1 0 1 1
 Et qu’on veut mettre à 1 les valeurs des bits b14, b13 et b2 qui sont à 0. Dans ce cas, il suffit d’écrire
dans le registre BSRR les bits correspondants ( b 14, b 13 et b 2 ) à 1 in diquant qu’on veut mettre à 1
les bits du registre ODR :
Au départ le registre ODR contient avec la valeur (0x8F0B) et BSRR avec 0x0000 :
b31 b16 b15 ……… …… b2 b1 b0
BSRR 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
ODR  0x8F0B
ODR 1 0 0 0 1 1 1 1 0 0 0 0 1 0 1 1
Après l’exécution de l’instruction permettant de mettre b14, b13 et b2 de BSRR à 1
b31 b16 b15 ……… …… b2 b1 b0

BSRR  0x6004 BSRR 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0
ODR 1 1 1 0 1 1 1 1 0 0 0 0 1 1 1 1
 On trouve que les bits correspondants dans ODR ont été également mis à 1, et ceci en u n
cycle (Une instruction) uniquement. Ceci aurait pris 3 cycles (3 bits) avec la technique Bitbanding.
Damergi Emir 2017

 De même, si on veut mettre des bits à 0 (exemple : les bits b0, b1 et b15), c’est le registre de reset
BRR qu’on doit utiliser en mettant à 1 les bits correspondants :
b31 b16 b15 ……… …… b2 b1 b0
BRR  0x8003 BRR 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
ODR 0 1 1 0 1 1 1 1 0 0 0 0 1 1 0 0
4. Exemple de programmation des GPIO
Prenons le cas ou on doit faire clignoter deux Leds connectées au pin3 et 4 du port GPIOA
(figure suivante)
Pour arriver à assurer ce fonctionnement, il faut :

Connaître les adresses et le format des différents registres du port GPIOA à uti liser ainsi que
le registre d’activation des horloges des périphériques connectés au bus APB2 [RM0008 Reference
manual]
Registre CRL CRH ODR BSRR BRR RCC_APB2ENR

Adresse 4001 0800 4001 0804 4001 080C 4001 0810 4001 0814 40021018
(Hex)
Tableau 2 : Registres du port GPIOC et leurs adresses
Pour les registres ODR, BSRR et BRR, ce sont les bits ayant les positions 3 et 4 dans chaq ue
registre qui agit directement sur PA3 et PA4.
Pour les registres de configuration qui ont la structure présentée ci-dessous, il s’agit des 4 bits
12..15 du registre CRL qui vo nt permettre de config urer le foncti onnement de PA3 et les 4 bits du
suivants du registre CRL 16..19 pour PA4.
Tableau 3 : Registres CRH et CRL
Damergi Emir 2017

Pour l’activation de l’horloge du port GPIOA, c’est le bit 2 du registre RCC_APB2ENR (voir
figure ci-dessous) qui doit être mis à 1.
Figure 3- Registre RCC_APB2ENR
 Déterminer la séquence de m anipulations à fa ire au niveau des registres pour assurer le

fonctionnement désiré :
Activer l’horloge du Bit 2 du RCC_APB2ENR RCC_APB2ENR=

port GPIOA =1 0…..0000100 = 0x0004
Configurer les pins 3

bits 12..15 CRL = 0001 CRL=0x 0001 1000
et 4 du GPIOA en
bits 16..19 CRL = 0001
sortie push-pull
Mettre PA3 et 4 à 1 Bit 3 et 4 de BSRR * BSRR =

(Allumer) =1 00..00000011000 = 0X0018
Delay Delay Delay
Mettre PA3 et 4 à 0 Bit 3 et 4 de BRR* BRR =

(Eteindre) =1 00..00000011000 =0X0018
* : On aurait pu utiliser le registre ODR, mais on a utilisé les registres BSRR et BRR pour m ontrer l’accès atomique à un bit
sans changer les valeurs des autres bits de ODR.
Damergi Emir 2017

Maintenant, il faut coder l’algorithme présenté par l’organigramme ci-dessus en C :
#define RCC_APB2ENR (uint32_t*) 0x40021018 Déclarer de s pointeurs s ur les

registres (c ases mémoires) 32
#define CRL (uint32_t*) 0x40010800 bits et spécifier leurs adresses
#define BSRR (uint32_t*) 0x40010810 (Exemple : CRL est un
pointeur sur un registre 32 bits
#define BRR (uint32_t*) 0x40010814 ayant l’adresse 40010800 Hex)
int i ;
main ( )
{
*RCC_APB2ENR = (uint32_t) 0x0004;
*CRL = 0x00011000; Ecrire d es do nnées 32 bits dan s
*BSRR = (uint32_t) 0x0018; les registres pointés par (ayant
les adresses ) les variables
for(i=0xFFFFFF; i != 0; i--); // Delay déclarées ci-dessus.
*BRR = (uint32_t) 0x0018;
}
En analysant le code assembleur généré, on trouve pour la première instruction C :
// Charger la valeur 0x40010810 dans R1

// Charger la valeur 0x0300 dans R0
// Sauvegarder dans le registre (RCC_APB2ENR) ayant l’adresse
// 0x40011010 (R1+0x0010) la valeur de R0 = 0x0300
Donc, l’instruction C ne prend que 3 c ycles (3 instructions asse mbleur) et l’ opération d’accès
en écriture des deux bits 8 et 9 (STR r0, [r1, #0x10]) ne prend qu’un cy cle (une instruction). L’accès
se fait donc d’une façon atomique.
Certes, cette approche est optimale au niveau de la taille du code généré, mais il faut connaître
un grand nom bre de détails (adres ses des registre s, leur structure, etc.…); ce qui est pénible et
demande un long temps de développement.
Pour accélérer le développement, ST offre une « Firmware Library » contenant l’ensemble de
drivers permettant un acc ès plus si mple et tr ansparent aux périph ériques du microcontrôleur STM32.
Les paragraphes suivants détailleront l a structure générale de cette librairie ainsi que la façon de
l’utiliser.
Damergi Emir 2017

Damergi Emir 2017

Chapitre 3 ST Firmware Library : Présentation & Application
Chapitre 3
ST Firmware Library: Présentation &
Application à la programmation des GPIOs
Par Damergi Emir
1. Introduction
Pour facilit er l’uti lisation des fonc tionnalités offertes par les périphériques des
microcontrôleurs STM32 et accélérer le développem ent des applications, ST fournit La librairie
« STM32Yxxx_StdPeriph_Driver 1» permettant un accès tr ansparent à la partie matérielle du circuit
(périphériques, contrôleur d’interruptions, ..).
Cette librairi e est cens ée respecter le standard de programmat ion appelé CMSIS (Cortex
Microcontroller Software Interface Standard). CMSIS a été déf ini par ARM avec un ensemble de
fabricants de circuits intégrés et de développeurs de co mpilateurs visant à faciliter le portage et la
réutilisation des applicati ons écrites en langage ‘C’ pour les microcontrôleurs se basant sur un coeur
Cortex-M. Néanmoins, la portabilité des programmes, écrits en ‘C’, entre les microcontrôleurs à bas e
du Cortex-M est loin d’être assurée.
2. Présentation de la « Firmware Library » de ST
La librairie F irmware respectant le st andard CMSIS est une colle ction de fichiers source en
langage c (.c) ou en assembleur (.s) et de fichiers entête (.h) qui jouent rôle d’une couche intermédiaire
entre l’application utilisateur et le Hardware. Sa structure est présentée dans la figure suivante.
1
Yxxx indiquant la famille du STM32 (L1xx pour la famille L1, F10xx pour la famille F1, F2xx pour la
famille F2 et F4xx pour la famille F4).
Damergi Emir 2017

Application
User
main.c, stm32Yxxx_conf.h, stm32Yxxx_it. c + . h , …
OS
(Firmware Library)
Device Periph. Functions (ST)

stm32Yxxx_ppp.c ,+ .h
CMSIS
Initialisation Core Peripheral

file
misc.c, + .h Peripheral Register functions (ARM)
Startup_
definitions(ST) coreCM3.c ,.h;
stm32Yxxx.s
System_stm32Yxxx.c ,+ .h Stm32Yxxx.h
Hardware
(MCU)
Cortex Interrupt System Other Peripherals

CPU Controller Timer (GPIO, ADC, Timers, …)
Figure 1 -
Comme partie des fonctionnalités CMSIS, ARM fournit la couche logicielle suivante
disponible pour divers compilateurs :
 Couche d’a ccès aux périphériqu es noyau (Core Peripheral Functions ) : contient les
définitions, les adres ses et les fonctions d’ accès aux différents registres du CPU e t des
périphériques du no yau (core peripherals) conte nus dans Cortex même : le contrôleur
d’interruptions NVIC, l e timer sy stème Systick, le bus matrix, etc. Ces définitions et fonctions se
trouvent au niveau des fichiers core_M3.c et core_M3.h.
Le fabriquant du microcontrôleur fournit :
 Le fichier de démarrage startup_stm32Yxxx .s, écrit en assembleur et qui permet de:

- Initialiser les registres du CPU (Program Counter et Stack Pointer).
- Installer La table des vecteurs d’interruptions.
- Faire un saut vers main.c et donner la main à l’application utilsateur.
 Couche d’accès aux péri phériques hors noyau (Device Peripheral Functions): permettant une
manipulation transparente des périphériques (port parallèle, série, Conversion A/N et N/A, Timer,
etc..).
Damergi Emir 2017

On trouve ai nsi les fichiers ay ant le f ormat stm 32Yxxx_ppp.c et .h Chaque fichier étant
relatif à l’un des p ériphériques du m icrocontrôleur (ppp étant remplacée par l’ab réviation du
périphérique). La liste suivante pr ésente le s princ ipaux périphé riques de la f amille des
microcontrôleurs STM32
Nom de fichier Périphérique

stm32Yxxx_adc Convertisseur Analogique/Numérique
stm32Yxxx_bkp Sauvegarde de données
stm32Yxxx_can Bus CAN
stm32Yxxx_crc Calcul des codes de détection d’erreurs
stm32Yxxx_dac Convertisseur Analogique/Numérique
stm32Yxxx_dma Accès direct à la mémoire
stm32Yxxx_exti Interruptions externes
stm32Yxxx_gpio Entrées/sorties parallèles
stm32Yxxx_iwdg Chien de garde
stm32Yxxx_pwr Gestion du mode d’alimentation
stm32Yxxx_rcc Contrôle du reset et de la distribution du signal d’horloge
stm32Yxxx_rtc Horloge temps réel
stm32Yxxx_tim Les Timers (compteurs).
stm32Yxxx_usart L’interface de communication série synchrone et asynchrone
A ces fichiers, s’ajoute :

- misc.c et .h contenant les fonctions ha ut niveau pour accéd er au contrôleur d’interruptions et
au timer système (SysTick).
- system_stm32Yxxx.c et .h permettant de configurer l’ horloge sy stème (fr équences d e
fonctionnement des différents bus et périphériques).
Les définitions des registres et des adresse s des périphériques ( Peripheral Regis ter
definitions) se trouvent dans le fichier stm32Yxxx.h.
En ce qui concerne l’application utilisateur, on trouve au moins les fichiers

- main.c qui contient le code source. Mais on peut évid ement trouver d’autres fichiers code
source « .c » et entête « .h ».
- stm32Yxxx_conf.h qui c ontient la lis te des fichiers de la couche « Device Peripheral
Functions » à inclure (voir ci-après).
- stm32fYxxx_it.c et .h contenant les gestionnaires d’interruptions.
Damergi Emir 2017

3. Utilisation de la Firmware Library de ST
Avant de commencer la programmation, il est indispensable de commencer par configurer

certains paramètres au niveau des différents fichiers , tels que :
 la fréquence du signal d’horloge externe appliqué à l’entrée OSc du microcontrôleur,
 le type de microcontrôleur à utiliser (High, medium, low ou connectivity) qui permet de
déterminer les tailles des différentes zones mémoire (Flash, Sdram).
 Les divers périphériques à utiliser
Pour une application n’utilisant pas le mécanisme d’interruptions, les premières parties du
code élémentaires nécessaires et communes à toute application sont :
 La définition des variables (structures) relatives aux périphériques.
 Activation des signaux d’horloges attaquant les périphériques.
 La détermination des valeurs des différentes propriétés des périphériques.
 L’initialisation des périphériques avec les valeurs déterminées.
Ces différentes parties faisant généralement partie du fichier main.c. (voir diagramme suivant)
Damergi Emir 2017

system_stm32f10x.c
/* #define SYSCLK_FREQ_HSE HSE_Value */

Décommenter l’option /* #define SYSCLK_FREQ_24MHz 24000000 */
Identifier la correspondante /* #define SYSCLK_FREQ_36MHz 36000000 */
fréquence horloge à /* #define SYSCLK_FREQ_48MHz 48000000 */
l’entrée OSC du /* #define SYSCLK_FREQ_56MHz 56000000 */
microcontrôleur
#define SYSCLK_FREQ_72MHz
72000000
Déterminer les stm32f10x_conf.h

périphériques PPP Décommenter les
à activer dans périphériques à activer /* #include "stm32f10x_adc.h" */
l’application /* #include "stm32f10x_bkp.h" */
#include "stm32f10x_PPP1.h"
/* #include "stm32f10x_can.h" */
/* #include "stm32f10x_crc.h" */
#include "stm32f10x_PPPi.h"
Déclarer les
variables relatives
aux périphériques Main.c
activés
#include "stm32Yxxx.h"
/* private variables --------*/
PPP1_InitTypeDef PPP1_InitStructure
………………………………………..
PPPi_InitTypeDef PPPi_InitStructure
Activer le signal
……
d’horloge
……
int main (void)
{
Pour chaque périphérique
Déterminer les RCC_APBxPeriphClockCmd

propriétés de ses (RCC_APBxPeriph_PPPi, Enable)
différents
membres
PPPi_InitStructure.membre1 = propriété
………………………………………..
PPPi_InitStructure.membren = propriété
Initialiser le
périphérique
PPPi_Init (&PPPi_InitStructure)
Damergi Emir 2017

Il est à noter que pour l ’activation du si gnal horloge, x (dans APB xPeriph_ppp) peut prendre
les valeurs 1 ou 2 (relativement aux bus APB1 et AP B2) et que l’activation des signaux d ’horloge des
périphériques connectés au même bus peut être faite en une seule ligne :
RCC_APBxPeriphClockCmd (RCC_APBxPeriph_PPP1 |…|…|…| RCC_APBxPeriph_PPPn
,Enable)
En ce qui concerne l’initialisation, il est possible de l’appliquer à une partie du périphérique et

non pas au périphérique entier. A titre d’ exemple le périphérique d’ entrées/sorties (GPIO : General
Purpose Inp ut Output) peut contenir j usqu’à 7 p orts (GPIOA, GPIOB, ….GPIOG) qui peuvent être
initialisés indépendamment l’un des autres. Dans ce cas, il faut spéci fier dans l’ instruction
d’initialisation le ou les ports du périphérique GPIO à initialiser :
GPIO_Init (GPIOA, &PPPi_InitStructure)
4. Programmation basée sur la Firmware Library : application au GPIO
On se concentre dans cette partie sur le périphérique GPIO et principalement sur les fonctions
Setbits( ) et Resetbits( ) qui permettent respectivement de mettre à 1 un ens emble de bits passés en
paramètres ou de les remettre à 0.
Pour la confi guration et l ’utilisation de s f onctionnalités des GPIOs en utilisant la librairie

Firmware de ST, au moins 9 fichier s (code source .c et entête .h) sont néces saires (Figure
suivante) pour assurer l’interfaçage entre l’application utilisateur et le périphérique GPIO.
Application (code développé par l’utilisateur)
startup_stm32Yxxx. s stm32Yxxx_conf.h
stm32f10x_gpio.c stm32f10x_rcc.c
+. h +. h
System_stm32Yxxx. c
+. h
stm32f10x.h
Hardware (UAL, CPU Registers, Memory, GPIO, System Clock, Peripherals..)
On se concentre dans ce q ui suit sur le Firmware développé p our la fam ille F1. Même si les
autres versions (L1, F2 et F4) présentent quelques différences, le principe reste le même.
A) Le fichier startup_stm32F10x.s, est un fichier écrit en assem bleur et dévelo ppé par
ARM, per met d’ initialiser les registres du processeu r Cortex après le dém arrage, les zones mém oire
Damergi Emir 2017

ainsi que les fréquences de fonctionne ment des h orloges internes du m icrocontrôleur. Ce fichier
accède directement au Hardware ou fait appel aux fonctions de system_stm32f10x.
B) Les fichiers system_stm32f10x.c et .h. Ils contiennent des fonctions permettant

l’initialisation et la configuration des fréquences de fonctionnement des horloges du système.
C) Le fichier stm32f10x_conf.h contenant une suite d’instructions d’inclusion (#include)

des fichiers entête (headers) des périphériques utilisés par l’application :
/* #include "stm32f10x_adc.h" */
/* #include "stm32f10x_bkp.h" */
/* #include "stm32f10x_can.h" */
/* #include "stm32f10x_cec.h" */ Il faut décommenter les fichiers e ntête
/*#include "stm32f10x_exti.h"*/ relatifs aux périphériques à inclure dans le projet.
#include "stm32f10x_gpio.h" Dans notre cas, on d oit i nclure
/* #include "stm32f10x_i2c.h" */ stm32f10x_gpio.h.
/* #include "stm32f10x_iwdg.h" */
stm32f10x_rcc.h est relatif au périphérique
/* #include "stm32f10x_pwr.h" */
RCC (Reset & Clo ck C ontrol) qu i doit être
#include "stm32f10x_rcc.h"
/* #include "stm32f10x_rtc.h" */ toujours in clus p uisqu’il p ermet d ’activer les
/* #include "stm32f10x_sdio.h" */ autres périphériques en utilisant des fonctions du
/* #include "stm32f10x_spi.h" */ ficher stm32f10x_rcc.c
/* #include "stm32f10x_tim.h" */
/* #include "stm32f10x_usart.h" */
/* #include "stm32f10x_wwdg.h" */
/*#include "misc.h" */
D) Le fichier stm32f10x.h contient :

 le memory map : plages d’adresses des périphériques
Les adres ses de déb ut de

#define PERIPH_BASE ((uint32_t) 0x40000000)
chacun des GPIOs.
#define APB2PERIPH_BASE (PERIPH_BASE + 0x10000)
(Page 42 – RM0008.pdf)
#define GPIOA_BASE (APB2PERIPH_BASE + 0x0800)
#define GPIOB_BASE (APB2PERIPH_BASE + 0x0C00)
.............................
#define GPIOE_BASE (APB2PERIPH_BASE + 0x1800)
#define GPIOF_BASE (APB2PERIPH_BASE + 0x1C00)
#define GPIOG_BASE (APB2PERIPH_BASE + 0x2000)
Damergi Emir 2017

 Description physique des structures des périphériques : les registres dans l’ordre et leurs tailles
typedef struct
{
__IO uint32_t CRL;
La structure d’un GPIO : les registres dans l’ordre et leurs
__IO uint32_t CRH;
tailles. Ainsi
__IO uint32_t IDR;
 CRL est un re gistre en écriture et lecture (IO) de
__IO uint32_t ODR;
taille 32 bits et occupant l’adresse de base
__IO uint32_t BSRR;
 CRH occ upe l ’adresse de b ase +4 ( 32 bi ts = 4
__IO uint32_t BRR;
__IO uint32_t LCKR; octets). Et ainsi de suite.
}
GPIO_TypeDef;
Déclaration de pointeurs sur les structures

GPIO_TypeDef commençant à partir de l’adresse
#define GPIOA ((GPIO_TypeDef *) GPIOA_BASE) GPIOx_BASE.
#define GPIOB ((GPIO_TypeDef *) GPIOB_BASE) Ainsi pour GPIOF qui pointe sur la zone mémoire
#define GPIOC ((GPIO_TypeDef *) GPIOC_BASE) (contenant une structure GP IO) 0 x40011C00, o n
a:
#define GPIOD ((GPIO_TypeDef *) GPIOD_BASE)
#define GPIOE ((GPIO_TypeDef *) GPIOE_BASE) GPIOF - >CRL : perm et d’accéder à l’a dresse
#define GPIOF ((GPIO_TypeDef *) GPIOF_BASE) 0x40011C00.
#define GPIOG ((GPIO_TypeDef *) GPIOG_BASE) GPIOF - >CRH : perm et d’accéder à l’a dresse
0x40011C04.
E) Pour le fichier stm32f10x_gpio.h, il contient :
1- Des stru ctures (enreg istrements : typ es

complexes co nstruits par union de t ypes sim ples)
typedef struct
{ permettant une description logique de données…
uint16_t GPIO_Pin; On t rouve, par e xemple, l et ype
GPIOSpeed_TypeDef GPIO_Speed;
GPIO_InitTypeDef qui d écrit les données de
GPIOMode_TypeDef GPIO_Mode;
} configuration d uG PIO ( GPIO_Speed &
GPIO_InitTypeDef; GPIO_Mode) ai nsi que les pi ns a uxquels o n
l’applique (GPIO_Pin).
Damergi Emir 2017

typedef enum
{ GPIO_Speed_10MHz =0x01,
GPIO_Speed_2MHz = 0x02,
GPIO_Speed_50MHz = 0x03
} GPIOSpeed_TypeDef;
2- Des co llections d e valeurs po uvant être
attribuées aux éléments des structures (typedef enum).
typedef enum Ainsi, GPIOMode_TypeDef énum ère les
{ GPIO_Mode_AIN = 0x0, valeurs p ossibles qu ’on peut at tribuer au x modes de
GPIO_Mode_IN_FLOATING = 0x04,
GPIO_Mode_IPD = 0x28, configuration GPIO_mode.
GPIO_Mode_IPU = 0x48,
GPIO_Mode_Out_OD = 0x14,
GPIO_Mode_Out_PP = 0x10,
GPIO_Mode_AF_OD = 0x1C,
GPIO_Mode_AF_PP = 0x18
} GPIOMode_TypeDef;
#define GPIO_Pin_0 ((uint16_t)0x0001) // 0000000000000001

#define GPIO_Pin_5 ((uint16_t)0x0020)
#define GPIO_Pin_8 ((uint16_t)0x0100) 3- D éfinitions de valeurs possibles relatives
#define GPIO_Pin_9 ((uint16_t)0x0200) à chacun des 16 pins.
#define GPIO_Pin_10 ((uint16_t)0x0400) Ces val eurs sero nt pa ssées com me
paramètres aux fo nctions du Firmware pour indiquer
le(s) pin(s) concerné(s) par l’action.
#define GPIO_Pin_14 ((uint16_t)0x4000) Pour i ndiquer pl usieurs pins (i , j, . .), o n
#define GPIO_Pin_15 ((uint16_t)0x8000) utilise l’opérateur ou ( | ) :
#define GPIO_Pin_All ((uint16_t)0xFFFF) fct (.., GPIO_Pin_i | GPIO_Pin_j | .. | .. | ..)
Damergi Emir 2017

F) Pour le fichier stm32f10x_gpio.c, il contient le code sour ce des fonctions permettant

d’exploiter le périphérique (configuration, opérations d’entrées, sorties, etc..).
Pour chaque fonction, on t rouve le code de la fonction précédé par des co mmentaires. On se
contente de présenter la fonction GPIO_SetBits ( ),
#include "stm32f10x_gpio.h"
………………..
………………. Ces commentaires respec tent un format
standard qui s era ex ploité p ar l a sui te par un
/* @brief Sets the selected data port bits. outil permettant de générer automatiquement un
* @param GPIOx: where x can be (A..G) to select the GPIO.
fichier d’aide relatif aux fonctions du Firmware.
* @param GPIO_Pin: specifies the port bits to be written.
On a :
* can be any combination of GPIO_Pin_x where x can be (0..15).
@brief : une description de la fonction
* @retval None */
@param : Pour chacun des paramètres passés à
la fo nction, une i ndication s ur l es valeurs
possibles à utiliser.
@retval : une description des valeurs de retour.
void GPIO_SetBits (GPIO_TypeDef* GPIOx , uint16_t GPIO_Pin)

{
GPIOx->BSRR = GPIO_Pin; Cette fonct ion pe rmet de mettre à 1 un
}
ensemble d e bits (j usqu’à 16 : GPIO_Pin ) du
GPIOx (x pouvant être A, B, …G).
Ceci est fait p ar écritu re d ans le
registre BSRR.
Damergi Emir 2017

Finalement, pour développer une application permettant d’allumer deux Leds connectées aux
pins 3 et 4 du GPIOA (exemple du chapitre précédent), le code source sera le suivant :
/* --------Includes -------------------*/
#include "stm32f10x.h"
/*----------------- Declaration of the GPIO structure (for configuration) ---------------*/
GPIO_InitTypeDef GPIO_InitStructure;
int main(void)
{
/*---------- Enable the GPIOA Clock. This function is included in stm32f10x_rcc.c------------ */
RCC_APB2PeriphClockCmd (RCC_APB2Periph_GPIOA, ENABLE);
/*-------------- Configure the pins 3 and 4 of the GPIOA -----------------*/

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;
GPIO_Init (GPIOA , &GPIO_InitStructure); // The function GPIO_Init permits the configuration of
//the indicated pins (3 & 4) of the GPIOA with the selected
//paramters (speed & mode)
/*--------------Set On the two Leds--------------- -*/

GPIO_SetBits (GPIOA, GPIO_Pin_3|GPIO_Pin_4)
The call of the function GPIO_SetBits ( ) with the actual parameters:
GPIOA->BSRR = GPIO_Pin_3 | GPIO_Pin_4;

= 0x0008 | 0x0010;
= 0000000000001000 | 0000000000010000
= 0000000000011000
Bits 3 and 4 of the BSRR Register are set
Damergi Emir 2017

Cortex-M3 : Gestion des interruptions
Chapitre 5
Par Damergi Emir
1. Introduction
La gestion des interruptions, pour les processeurs Cortex-M3, est assurée par le contrôleur
d’interruptions NVIC (Nested Vector Interupt Controller). Le NVIC est étroitement couplé au no yau
du processeur et intègre lui-même un Timer système Systick « Figure -1 ».
Le fait d’intégrer le NVIC au noyau CM3 permet, d’une part, d’améliorer les performances du
traitement des interruptions en a ccélérant la co mmunication entre le contrôleur et le noy au. D’ autre
part, les codes développés ainsi que les sy stèmes d’ exploitation temps réel peuvent être facilement
portés entre microcontrôleurs à base d u processeur Cortex-M3, puisque la stru cture des reg istres du
NVIC (et du Systick) ainsi que leurs adresses et la même pour tous.
Cortex-M3
Système de débogage
NMI
Contrôleur
d’interruptions Processor Core
(NVIC)
Périphériques (Registers + UAL +
Decode + Fetch units)
SysTick
Up to 240 Interrupts Interface Mémoires
Up to 14 Exceptions
MPU
Bus d’Interconnexion (Bus Matrix)
Figure 1 : Entrées du contrôleur NVIC

Le NVIC peut avoir jusqu’à 255 entrées pour les requêtes d’interruptions:
 Une entrée NMI (Non Maskable Interrupt) : Cette interrup tion, contrairement aux autres, ne peut
être maquée par soft. Pour la majorité des µc, cette entrée est reliée au chien de garde (Watchdog).
 Jusqu’à 14 e ntrées pour l es exceptions (interruptions synchrone s) générées p ar les co mposants
internes du process eur Cortex-M3 (exem ples : UAL suite à un O verFlow, Bus suite à un a ccès
erroné, Systick, etc..).
 Jusqu’à 240 entrées pour des interruptions externes génér ées par les périphériques du
microcontrôleur (série, Ethernet, ADC, etc..).
Chaque interruption est identifiée par numéro i, qui correspond à l’entrée au niveau du NVIC,
et per met par conséquent de déter miner l’ adresse contenant l’ adresse du Han dler dans la table des
vecteurs d’in terruptions : pour les exceptions, ce num éro est figé. Mais, pour les inte rruptions
externes, l’attribution du numéro dépend du constructeur du µc.
A chaque interruption, est associ é un niveau de priorité de -3 à 255 (-3 étant la priorité
maximale). Ce niveau de priorité est configurable, sauf pour les trois premières.
Le tableau suivant donne les paramètres des exceptions ainsi qu’une description de chacune.
Type Niveau de priorité Adresse Description

Nr
d’exception par défaut
Reset 0x04 Déclenchée quand un signal de reset est
1 -3 (max, figé)
détecté.
NMI 0x08 l’entrée Non Masquable Interrupt qui est
2 -2 (figé)
généralement connectée au WatchDog.
Hard Fault 0x0C Erreur de matériel pour lequel aucune
3 -1 (figé)
routine n’a été prévue
MemManage 0 0x10 Déclenchée en cas d’une tentative d’accès à
4
Fault une zone mémoire non autorisée.
Bus Fault 1 0x14 Générée quand l’interface du bus AHB
5
(problème d’accès).
Usage Fault 2 0x18 Déclenchée par une erreur au niveau d’un
6
programme (exple : division par 0).
7-10 R éservé
SVCall 3 0x2C Dans le cas d’un appel à un service
11
système.
Debug 0x30 Déclenchée quand un point de break (ou
4
12 Monitor watch) est atteint ou bien quand le
débogage est activé.
13 R éservé
14 PendSV 5 0x38 Instruction qui peut être appelé.
15 SYSTICK 6 0x3C Relative au Timer interne SYSTICK
16… Int # 0 7 0x40 Il s’agit d’événements déclenchés par les
…. ……………. ……… …… autres périphériques externes ajoutés par le
255 Int # 239 247 fabricant du microcontrôleur.
Tableau 1 : Exceptions du Cortex-M3

2. Déroulement des interruptions
Les étapes de déroulem ent d’une interr uption sont communes à tous les systèm es
(processeur + contrôle ur d’interruptions). Quand une requête d’ interruption autorisée est
déclenchée par un périphérique, le contrôleur force l e processeur à la s ervir et les étapes suivantes se
succèdent :
 Sauvegarde d’un certain nombre de registres (généralement Program Counter et le registre d’état)
dans la pile, et parallèl ement, il récupè re l’ adresse de la routine relative à l’ interruption (phase
PUSH).
 Exécution du Handler associé à l’interruption.
 Une fois l’exécution de la routine est term inée, les contenus des regi stres sauvegardés sont
récupérés à partir de la pile (phase POP).
Le Cortex-M3 respecte ces étapes. Mais grâce à son architecture (Harvard), et à celle du NVIC
qui est en plus couplé au noyau, des améliorations sont à noter :
 La sauvegarde et la récupération d’un grand nombre de registres pendant les phases PUSH et POP.
Ces opératio ns se font d’une façon com plètement automatique (matéri elle) sans intervention de
l’utilisateur qui n’est plus obligé de gérer les registres au niveau des Handler « Figure -2 ».
 La sauvegarde des registre s se fait parallèle ment à la récupération de l’ adresse du Handler
(architecture Harvard). Ce qui écourte considérablement le te mps des phases PUSH et PO P à 12
cycles « Figure -2 ».
 Possibilité d’interrompre l’exécution des instructions multi cycles (load et store), ce qui am éliore
le temps de latence.
IRQ i
PUSH Routine i POP
12 cycles 12 cycles
Sauvegarde des registres : Restaurer les registres :

R0-R3 ; R12
R15 (Program Counter)
R14 (Link register)
PSR (Registre d’état)
Figure 2 : Déroulement d’une interruption (Cortex-M3)

2-1 Enchaînement des interruptions
Quand une interruption i se déclench e alors que le proces seur est entrain de servir un e
interruption j de plus hau te priorité, alors l’i nterruption i est mise en atte nte jusqu’ à ce que le
processeur termine l’exécution du Hanler i.
Les autre s pr ocesseurs (tel que ARM7, x86), effectuent une phase POP à la fin de chaque
Handler, avant de commencer un no uveau cy cle pour l ’interruption j (P USH, Handler, POP)
« Figure :- 3 ».
Niveau de priorité
IRQ j
IRQ i
Instant possible de IRQ i
PUSH 1 ISR j POP 1 PUSH 2 ISR i POP 2
Figure- 3 : Enchaînement de deux interruptions (ARM7)
Tout compte fait, les données r écupérées lors de la p hase POP1 sont les mêmes qui vont êtr e
sauvegardés lors de la phase PUSH 2. Par conséque nt, cette méthode d’enchaînement d’interruptions
cause une perte de temps sans aucun intérêt.
 Tail Chainig
Le Cortex-M3 évite cette perte de temps en utilisant une technique qui élimine les deux phases
PUSH et POP inutiles et les re mplace par une phase unique appelé « TC : Tail Chaining » qui ne
dure que 6 c ycles. Durant cette phase, uniquem ent une récupéra tion de l’ adresse du Han dler i est
effectuée. La pile ainsi que les registres étant intouchés « Figure -4 ».
- Niveau de priorité +
IRQ j
IRQ i
Instant possible
de IRQ i
PUSH ISR j T.C ISR i POP

6
cycles
Figure -4 : Enchaînement d’interruptions par utilisation de la technique Tail Chaining (Cortex-M3)

 Preemption (Préemption)
Dans la figure 4, la phase Tail Chaining s’eff ectue quand l’interruption se décl enche avant l a
fin du Handler en cours (ISR j).
Et si l’ interruption se déclench e après la fin de l’ exécution de H andler et pendant le c ycle
POP « Figure -5 » ?
Dans ce cas de figure, le Co rtex-M3 prévoit la technique « Preemption » qui arrête
immédiatement le cy cle POP. En fait, étant donn ée que le cy cle POP ne fait que restaurer les
données de l a pile ver s l es r egistres sans les écra ser, alors son arrêt ne cau se aucune perte de
données. Une fois le c ycle POP arrêté, un c ycle TC permet la récupération de l ’adresse du Handler
à exécuter « Figure -5 ».
Cette technique est utilisée indépendamment des niveaux de priorité des deux interruptions.
IRQ j
IRQ i
Instant possible de IRQ i
PUSH ISR j POP T.C ISR i POP
1 à 12 6
cycles cycles
7 à 18 cycles
Figure - 5 : Enchaînement d’interruptions par utilisation de la technique Preemption (Cortex-M3)
2-1 Interruptions Imbriqués (Nested Interrupts)
Quand une requête d’interr uption se déclenche alors que le proces seur est entrain d’exécuter
un Handler d ’une i nterruption m oins prioritair e, alors le Handler est suspendu pour servir
l’interruption plus priorit aire. Ensuite, le pro cesseur continue l’exécution du Handler suspendu
« Figure -6 ». On parle d’interruptions imbriqués (Nested Interupts).
IRQ j
IRQ i
PUSH ISR i PUSH ISRj POP ISR i POP
Figure 6 : Interruptions imbriquées

Ce co mportement n’est pas spécifique au Cort ex-M3, on le trouve dans tous les sy stèmes.
Mais les nouveautés introduites au niveau du Cortex-M 3, c ’est dans le cas o u l ’interruption j pl us
prioritaire se déclenche pendant le cycle PUSH déclenché par l’interruption i.
La plupart des processeurs (ARM7, x86) traitent la nouvelle interruption j indépendamment du
moment de son déclenchement et de la même façon décrite dans la figure 6: Le cy cle PUSH en cours
se poursuit jusqu’à sa fin, ensuite un nouveau cycle PUSH est lancé « Figure -7 ».
IRQ j
Instant possible de IRQ j
IRQ i
ARM7 PUSH PUSH ISR j POP ISR i POP
Figure 7 : Déclenchement d’une interruption prioritaire pendant un cycle PUSH ( ARM7)
On voit bien que les deux phases PU SH succe ssives ne font que sauvegarder les mêmes
données dans la pile. Un seul cycle PUSH serait suffisant.
 Late Arrival (Arrivée tardive)
Dans ce cas, ou l’interruption prioritaire arrive en retard par rapp ort à la moins prioritaire, l e
Cortex-M3 prévoit la technique « Late Arrival » : Il co mmence l’exécution du Handler de
l’interruption j (prioritaire), directement après la fin d’un cycle PUSH « Figure -8 ».
En fait, au moment du déclenchement d’une interruption i, le CM3 lance la phase PUSH. A sa

fin, il teste si d’ autres interruptions de priorité supérieure ont eu lieu. Si c ’est le cas, Il co mmence par
traiter la routine de l’interruption de plus haute priorité.
IRQ j
Instant possible de IRQ j
IRQ i
PUSH ISR j T.C ISR i POP
Figure 8 : Technique Late Arrival (Cortex-M3)
3. Programmation du NVIC (Voir Chapitre ).

Cortex-M3 (STM32 –F1) : Structure du NVIC & Programmation des interruptions
Chapitre
Cortex-M3 (STM32 – F1) : Structure du NVIC &
Programmation des Interruptions
Par Damergi Emir
1. Introduction
Avant de présenter la stru cture du NVI C, rappelons que le déclenche ment d’une interruption
relative à un périphérique donné, nécessite « Figure -1 »:
- L’autorisation de l’i nterruption au ni veau du NVIC. Pour chacune des e ntrées
d’interruptions, un bit est dédié à cette fonction. C ’est également au niveau du NVIC que le niveau de
priorité est attribué à chaque interruption.
- La programmation du Pé riphérique en auto risant l ’envoi de req uêtes d’interr uptions
IRQ à la suite d’un éventement dépendant de la fonction assurée par le périphérique (récept ion d’une
donnée pour le port série, conversion d’un échantillon pour le DAC, etc…).
Cortex-M3
NVIC
Peripheral Proc.
Priority Core
IRQ Enable INT Enable
INT condition IRQ
Set
(Event) EVENT FLAG Set INT
clear INT PEND
clear
Figure 1 : Conditions de déclenchement d’une interruption
Dans ce chapitre, on ne présentera que la structure du NVIC ainsi que sa programmation. Pour
les périphériques (DAC, TIMER, etc..), consulter les chapitres correspondants.

2. Registres du NVIC (Famille F1 du STM32)
 Contrôle des interruptions

Même si le NVIC est capable de gérer jusqu’ à 256 interrupti ons, il est rare de trouver d es
systèmes ayant tant de sources d’ interruptions. Ainsi, les entreprises développant les microcontrôleurs
peuvent opte r pour un nombre d’interruptions in férieur à 256 afin d’opti miser l’utilisation des
ressources matérielles (nombre de registres & logique de contrôle).
Pour la fam ille F1 des microcontrôleurs STM32, ST -Microelectronics a opté pour un NVIC
avec juste 68 entrées d’interruptions (0 à 67).
Ainsi, 3 regi stres de 32 b its (2*32 + 4 bits d u 3 ème registre) sont utilisés pour chacune des
fonctionnalités contrôlant l ’interruption (autorisation, activation, remise à 0, etc..). Le tableau suivant
donne la liste des registres et leurs fonctions.
INT Enable INT Disable Set-Pending Clear-Pending

0 – 31 ISER0 ICER0 ISPR0 ICPR0
Interrupt
Number
32 – 63 ISER1 ICER1 ISPR1 ICPR1

64 - 67 ISER2 ICER2 ISPR2 ICPR2
Tableau -1 : Registres du NVIC pour le contrôle des interruptions
ISERx : Interrupt Set Enable Register (32 bits) : chaque bit de ce regist re per met d’ autoriser
l’interruption correspondante quand il est mis à 1.
ICERx : Interrupt Clear Enable Register (32 bits): chaque bit de ce regist re permet d’interdire
l’interruption correspondante quand il est mis à 1.
ISPRx : Interrupt Set Pedning Register (32 bits) : La mise à 1 d’un bit de ce registre active
(déclenche) une interruption (m et l’interruption en état pending). Généralement, ce bit n’ est pas m is
par software, mais par un périphérique « Figure -1 ».
ICPRx : Interrupt Clear Pedning Register (32 bits) : La mise à 1 d’ un bit de ce registre met
l’interruption en état ‘ not pending’. Ce bit est mis automatiquement à 1 par le matériel (lo gique de
contrôle du NVIC) après avoir commencé l’exécution du Handler associé à l’interruption. Mais, il peut
être également accédé par soft.

 Niveaux de Priorités des interruptions
ARM classe les interruptions en groupes :

- Chaque groupe ayant un niveau de priorité (Preemption Priority).
- Chaque interruption à son propre niveau de priorité au sein du groupe (SubPriority).
Le tableau suivant donne un exemple de 4 groupes de 4 interruptions. Une valeur inférieure de

la priorité indiquant que l’interruption est plus prioritaire.
Preemption Priority SubPriority Interrupt Priority

(priorité du Groupe) (priorité de l’interruption) level
0 maximal
1
0
2
3
0
1
1
2
3
0
1
2
2
3
0
1
3
2
3 minimal
Tableau -2 : Niveaux de priorités des interruptions
Quand deux interruptions demandent d’être s ervies, alors le proces seur commence par la plus
prioritaire.
Mais, si une interruption i est entrain d’ être servie et qu’une autre j est dé clenchée, alo rs
l’interruption i en cours n ’est préem pté (suspendue) que si l’i nterruption j a un ni veau d e priorité
‘Preemption Prirority’ supérieur.
Donc, une interruption ne peut préempter (suspendre) une autr e d u même groupe de priorité
« Preemption Priority », même si son niveau de priorité ‘subpriority’ est supérieur.
Il faut préciser que si deux interrupti ons ont les mêmes ‘Preem ption Priority’ et ‘SubPriority’
alors c’est celle ayant le numéro (entrée au niveau du NVIC) le plus élevé qui est prioritaire.

La configurat ion des nive aux de priorité est effectuée à travers les registres I PR (Interrupt
Priority Register). ARM a prévu 8 bits pour chaque interruption et par conséquent jusqu’à 256 niveaux
possibles.
La famille F1 de STM32 n’utilise que 4 bits pe rmettant ainsi jusqu’à 16 ni veaux de priorit é.
L’interprétation de la valeur des 4 bi ts dépend d u cham p PRIGROUP « bits 10..8 de Application
Interrupt and Reset Control Register : AIRCR ».
AIRCR
…. … … 10 : 9 : 8 … … bit
PRIGROUP
Ces bits déterminent le nombre de bits, parmi les 4, utilisés pour la Preemption Priority et pour
la SubPriority. Et par conséquent, le nombre de groupes et de niveaux d’interruptions par groupe.
Preemption Priority SubPriority

Nbr de bits
PRIGROUP Nbr de bits Groupes de priorité Nombre de niveaux d’interruptions
111 0 1 groupe : 0 4 16 niveaux : 0 à 15
110 1 2 groupes : 0 ,1 3 8 niveaux : 0 à 7
101 2 4 groupes : 0 à 3 2 4 niveaux : 0 à 3
100 3 8 groupes : 0 à 7 1 2 niveaux: 0 à 1
011* 4 16 groupes : 0 à 15 0 1 niveau : 0
* Configuration par défaut

Tableau -3 : Configuration des groupes de priorités
La fonction de la Firmware Library permettant de configurer les groupes de priorités :
NVIC_PriorityGroupConfig ( uint_32t NVIC_PriorityGroup )
NVIC_PriorityGroup étant une valeur 32 bits, et peut être l’un des paramètres suivants :
NVIC_PriorityGroup_0 : pour PRIGROUP = 111


 Offset de la table des vecteurs d’interruptions
Par défaut, la table des vecteurs d’interruptions est logée à l’adresse 0x00. Cette table contient
les adresses des ISRs (Interrupt Service Routine ou Handler) associées aux interruptions.
Le Cortex-M3, suit le même principe mais les vecteurs d’interruptions commencent à partir de
l’adresse 0x04 (ISR1). L’adresse 0x00 étant utilisée pour sauvegarder la valeur d’initialisation du MSP
(Main Stack pointer) « Figure -2 ».
En plus, il est possible de reloger la table à une autre partie de la mémoire. L’ adresse à
laquelle la table devrait être relog ée, doit être placée dans le registre VTOR (Vector Table Offset
Register) « Figure -2 ».
L’offset des vecteurs d’interruptions (emplacement des adresses des ISRs) res te le même par
rapport à l’ adresse de base VTOR : Ainsi, l’adresse du Handler rel ative à l’ interruption i ( @ISRi) se
trouve à l’adresse VTOR + 4*i « Figure -2 ».
Memory
c
Main Prog
@_Prog
ISR i @_ISRi
…
…
Offset
Adresse
ISR1
Table des Vecteur s @_ISR1
d’interruption
……. …
@_ISRi 4i VTOR + 4*i
……………. ……
…………… …..
8 (0x00000008) VTOR + 8
Base Address = @_ISR1 4 (0x00000004) VTOR + 4
VTOR Register @_MSP 0 (0x00000000) VTOR
Figure 2 : Relogement de la table des vecteurs d’interruptions.

3. Configuration des interruptions (niveau NVIC)
Comme pour tous les périphériques, la Fi rmware Library de ST offre la structure

NVIC_InitTypeDef permettant de manipuler les interruptions. Il s’agit principalement d’attribuer un
niveau de priorité à l’interruption et de l’autoriser. L’uti lisation de cette structure est beaucoup plus
simple à utiliser que l’accès direct aux registres.
typedef struct {
uint8_t NVIC_IRQChannel : Il s’agit d’une valeur sur 8 bits qui identifie le numéro de l’interruption
à configurer. Ces numéros sont figés matériellement. La liste des sources de requêtes d’interruptions ainsi
que leurs numéros pour la famille F1 est donnée à la fin du chapitre « tableau -4 »
Remarque : Consulter le document d’aide de la librairie ST pour trouver les valeurs.
uint8_t NVIC_IRQChannelPreemptionPriority : C’est une valeur sur 8 bits indiquant le groupe de

priorité auquel appartient l’interruption à configurer « voir tableau 3 ».
uint8_t NVIC_IRQChannelSubPriority : C’est une valeur sur 8 bits indiquant le niveau de priorité
attribué à l’interruption au sein du groupe « voir tableau 3 ».
NVIC_IRQChannelCmd : peut prendre la v aleur ENABLE ( 1) pour autoriser l’ interruption o u bien

DISABLE (0) pour interdire son déclenchement.
} NVIC_InitTypeDef ;
La fonction de la FWL permettant de configurer le NVIC avec les param ètres définis au
niveau de la structure NVIC est : NVIC_Init ( & NVIC_InitStruct )
// &NVIC_InitStruct étant un pointeur sur la structure NVIC_InitTypeDef.
L’exemple suivant m ontre l’utilisati on de cette structure pour la configuration de

l’interruption associée à la mémoire Flash (on suppose une configuration par défaut de PRIGROUP).
NVIC_InitTypeDef NVIC_InitStruct ; // Déclarartion d’une structure de type NVIC_InitTypeDef
NVIC_InitStruct .NVIC_IRQChannel = FLASH_IRQn; // L’identifiant de l’interruption générée par le Flash.

NVIC_InitStruct. NVIC_IRQChannelPreemptionPriority = 15; // Le groupe ayant la priorité la plus basse.
NVIC_InitStruct. NVIC_IRQChannelSubPriority = 0; // un seul niveau d’interruption est disponible (0).
NVIC_InitStruct. NVIC_IRQChannelCmd = ENABLE; // autoriser l’interruption.
NVIC_Init (&NVIC_InitStruct); // Initialiser le NVIC avec les nouveaux paramètres

4. Gestionnaires d’interruptions (Interrupt Handler)
 Identification des Handlers
Une fois une interruption se déclenche, le Handler associé est exécuté. L’ adresse du Handler
étant récupérée à partir de la table des vecteurs d’interruptions.
Le Handler lui-même, n’est qu’une fo nction écr ite en C, donc comment est il possible de
déterminer que la fonction X correspond au Handler de l’interruption i.
Pour déterminer la fonction correspondant à un Handler, ARM et ST fournissent un fichier de
démarrage (startup file) dé crit la structure de la ta ble des vecteurs d ’interruptions. Cette table fixe un
nom pour chaque Handler d’interruption «Figure -3».
Startup file Memory

__Vectors ISR i
…..
…
DCD __initial_sp NMI_Handler ( ) Offset
DCD Reset_Handler //ISR1
DCD NMI_Handler //ISR2 Reset_Handler( )
DCD .........
DCD ......... …….
…
DCD .........
@_ISR i 4i
…. …………….
DCD OTG_FS_IRQHandler …. ……………
@_ISR 2 0x00000008
@_ISR1 0x00000004
__Vectors_End @_MSP 0x00000000 Base Address =
VTOR Register
Figure 3: Correspondance entre la table des vecteurs d’interruption et le fichier de démarrage
Ainsi, l’utilisateur n’a que de choisir le nom correct de la fonctio n pour qu’elle soit identifiée
comme étant un Handler, et que son adresse soit st ockée dans l a table des v ecteurs d’ interruptions.
Cette tâche est assurée par les outils de compilation (Keil, IAR, gcc, etc..).
Une liste compète des noms standard des Handler est donnée dans le tableau 4 du parag 5.
Si par exem ple, on veut associer un Handler à l’ interruption relative à la mé moire Flash, le nom du
Handler soit porter le nom FLASH_IRQHandler :
void FLASH_IRQHandler ( )
{ …….. // Code à exécuter
…….. }

 Remise à 0 des bits d’état (FLAG bit)
La génération d ’une i nterruption se fait après le dé clenchement d’un événement au niveau

d’un périphérique. Ceci en traîne la mise à 1 du bit d ’état (FLAG) qui à son tou r met le pending bit
correspondant du NVIC à 1 « Figure -4 ».
Peripheral
NVIC
IRQ Enable
INT condition IRQ

(Event)
Set PENDING INT
EVENT FLAG BIT
clear
Figure 4: Génération d’une interruption après un événement
Une fois l’interruption commenc e à être ser vie, le pendin g bit (NVIC) est rem is à 0
automatiquement par Hardware. Mais, le bit d’état reste à 1, ce qui provoque un déclenchement d’une
nouvelle interruption, même si aucun événement ne s’est déclenché (voir chapitre ).
Ainsi, c’est au niveau du Handler que le bit d’état doit être remis à 0. Dans la FWL de ST, des
fonctions permettent de remettre à 0 ces bits. Ces fonctions possèdent la syntaxe :
periph_ClearITPendingBit ( bit d’état )
Même si la fonction p orte le no m ClearITPendingB it ( ), c’ est le bit d’ état (FLAG) qui est
remis à 0 et non pas le pending bit du NVIC.
void ………_IRQHandler ( )
{ …….. // Code à exécuter

Periph_ClearITPendingBit ( )
………
}
Remarque : pour l’effet de la position (début, milieu ou fin du Handler) de la fonction

Periph_ClearPendingBit ( ), voir chapitre .

 Gestion des interruptions globales
Etant donné que le nombre d’entrées d’interruptions, au niveau du NVIC est li mité (68 pour le
STM32 –F1), plusieurs événem ents d’un périphériqu e peuvent se partager la même interruption. On
parle d’une interruption globale.
Ceci est réalisé en appliquant une opé ration de OU logique aux bits d’états des différents
événements « Figure -5 ». Il suffit que l’un des événements se déclenche pour activer la requête IRQ.
Peripheral
IRQ Enable
INT condition NVIC

Set
(Event 1) EVENT FLAG 1
INT condition IRQ

(Event i)
Set
OR
PENDING INT
EVENT FLAG i BIT
INT condition
Set
(Event N) EVENT FLAG N
Figure 5: Interruption globale
Une fois l’ interruption déclenchée, il fa ut commencer au niveau du Handler pa r tester l es bits

d’état des interfaces de périphériques pour déterm iner l’événement à traiter. Ainsi la structure du
Handler aura la structure suivante :
void ………_IRQHandler ( )
{
If ( periph _GetITStatus ( …..FLAG 1 ) )
{ .......
periph_ClearITPendingBit (…..)
}
……………
……………..
If ( periph_GetITStatus ( …..FLAG N) )
{ .......
periph_ClearITPendingBit (……)
}
}

5. Annexe : Valeurs du paramètre NVIC_IRQChannel &
Noms standard des Handlers
Le tableau suivant « tableau - 4 » do nne la liste des valeur s à attribuer aux paramètres
NVIC_IRQChannel ainsi que les n oms des Handlers à utiliser. Ces int erruptions ne sont pas
disponibles pour toutes les références du STM32 –F1.
Paramètre NVIC_IRQChannel Nom du Handler

R eset_Handler
NonMaskableInt_IRQn = -14, NMI_Handler
MemoryManagement_IRQn = -12, MemManage_Handler
BusFault_IRQn = -11, BusFault_Handler
UsageFault_IRQn = -10, UsageFault_Handler
SVCall_IRQn = -5, SVC_Handler
DebugMonitor_IRQn = -4, DebugMon_Handler
PendSV_IRQn = -2, PendSV_Handler
SysTick_IRQn = -1, SysTick_Handler
WWDG_IRQn = 0, WWDG_IRQHandler
PVD_IRQn = 1, PVD_IRQHandler
TAMPER_IRQn = 2, TAMPER_IRQHandler
RTC_IRQn = 3, RTC_IRQHandler
FLASH_IRQn = 4, FLASH_IRQHandler
RCC_IRQn = 5, RCC_IRQHandler
EXTI0_IRQn = 6, EXTI0_IRQHandler
DMA1_Channel1_IRQn = 11, DMA1_Channel1_IRQHandler
ADC1_2_IRQn = 18, ADC1_2_IRQHandler
CAN1_TX_IRQn = 19, CAN1_TX_IRQHandler
CAN1_RX0_IRQn = 20, CAN1_RX0_IRQHandler

CAN1_SCE_IRQn = 22, CAN1_SCE_IRQHandler

EXTI9_5_IRQn = 23, EXTI9_5_IRQHandler
TIM1_BRK_IRQn = 24, TIM1_BRK_IRQHandler
TIM1_UP_IRQn = 25, TIM1_UP_IRQHandler
TIM1_TRG_COM_IRQn = 26, TIM1_TRG_COM_IRQHandler
TIM1_CC_IRQn = 27, TIM1_CC_IRQHandler
TIM2_IRQn = 28, TIM2_IRQHandler
I2C1_EV_IRQn = 31, I2C1_EV_IRQHandler
I2C1_ER_IRQn = 32, I2C1_ER_IRQHandler
I2C2_EV_IRQn = 33, I2C2_EV_IRQHandler
I2C2_ER_IRQn = 34, I2C2_ER_IRQHandler
SPI1_IRQn = 35, SPI1_IRQHandler
USART1_IRQn = 37, USART1_IRQHandler
EXTI15_10_IRQn = 40, EXTI15_10_IRQHandler
RTCAlarm_IRQn = 41, RTCAlarm_IRQHandler
OTG_FS_WKUP_IRQn = 42, OTG_FS_WKUP_IRQHandler
UART4_IRQn = 52, UART4_IRQHandler
UART5_IRQn = 53, UART5_IRQHandler
ETH_IRQn = 61, ETH_IRQHandler
ETH_WKUP_IRQn = 62, ETH_WKUP_IRQHandler
CAN2_TX_IRQn = 63, CAN2_TX_IRQHandler
CAN2_SCE_IRQn = 66, CAN2_SCE_IRQHandler
OTG_FS_IRQn = 67 OTG_FS_IRQHandler
Tableau - 4 : Valeurs de NVIC_IRQChannel et noms des Handlers


Chapitre 6 Le Bloc EXTI
Chapitre 6
Le Bloc EXTI :
Contrôleur d’Interruptions Externes et d’ Evènements
Par Damergi Emir
1. Introduction
Comme déjà cité dans le chapitre précédent, le contr ôleur d ’interruptions NVIC peut traiter
jusqu’à 256 sources d’ interruption. 20 parm i ces s ources d’ interruptions sont les sorties du bloc ou
contrôleur EXTI (EXTernal Interrupt/event Controller): on parle de lignes EXTI.
Le contrôleur EXTI lui-même ayant 20 entrées (voir figure ci-dessous):

 16 lignes EXTI (EXTI 0…… EXTI 15) venant des blocs GPIOs (GPIOA par défaut) et remappées
par le bloc AFIO (voir chapitre 3).
 4 lignes EXTI provenant d’autres sources :
EXTI 16 : Détecteur du voltage de l’Alimentation (PVD : Power Voltage Detector)
EXTI 17 : L’horloge temps réel (RTC : Real Time Clock)
EXTI 18 : L’USB.
EXTI 19 : Le module Ethernet.
To Interrupt
Controller
4
(NVIC)
Or EXTI
From AFIO/GPIO
Events 16 (default : GPIOA)
Generation
Emir Damergi 2017

2. Le contrôleur EXTI
Le contrôleur EXTI perme t de configurer ces lignes de telle sorte à générer, en fonction du
changement de leur niveau logique:
- des demandes d’interruptions au NVIC.
- ou bien des événements : impulsion sur un IO.
Il permet de déterminer quelles lignes doivent être utilisées pour générer des i nterruptions (ou
événements) ainsi que les conditions devant les décl encher. Ce module est toujours actif et il consiste
en un ensemble de registres 20 bi ts (1 bit pour chaque ligne EXTI) et de la logique combinatoire (voir
figure ci-dessous).
Le contrôleur EXTI contient des registres communs au deux modes de fonctionnement (A) :
 Rising trigger selection register (EXTI_RTSR) : L’écriture d’un ‘1’ dans un bit i, configure
le « Edge Detect Circuit » pour générer un ‘1’ en cas de détection d’ un front montant sur la
ligne correspondante EXTIi.
 Falling trigger selection register (EXTI_FTSR) : L’écriture d’un ‘1’dans un b it i, configure
le « Edge Detect Circuit » pour générer un ‘1’ en cas de détection d’un front descendant sur la
ligne correspondante EXTIi.
Il est possible d’utiliser les deux conditions, citées ci-dessus, en même temps : un front
montant ou descendant génère un ‘1’.
 Software interrupt event register (EXTI_SWIER) : Un ‘1’ dans un bit de ce registre permet
de simuler une activité sur la ligne correspondante, mêm e si le s conditions de déclenchement
ne sont pas valides (aucun changement du niveau de la ligne correspondante).
Emir Damergi 2017

2-1 Génération des interruptions (B)
Pour la partie du contrôleu r, responsable du f onctionnement en mode interruption, 2 registres

sont utilisés (B):
 Interrupt mask register (EXTI_IMR ) : Un bit mis à 0 masque et désactive l’interruption de la
ligne correspondante. Un ‘1’ permet de l’autoriser.
 Pending register (EXTI_PR) : Si les conditions de déclenchement d’une int erruption sont
vraies (front montant, /ou descendant), alors le bit correspondant à la ligne, dans ce registre est
mis à 1. Si l ’interruption n’est pas masquée, alors la valeur de ce bit (1) va directement
attaquer le contrôleur d ’interruption pour qu ’il se charge de la traiter en exécutant le
gestionnaire associé.
Tant que ce bit est 1, le N VIC va considérer qu’une interruption s’est déclenchée et qu’ il doit
la traiter. Il est donc nécessaire de remettre le bit à 0, une fois le gestionnaire exécuté pour
éviter de l’exécuter une deuxième fois.
2-2 Génération des événements (C)
Pour la partie responsable de la génération des événements (C), il s’agit d’un registre :
 Event mask register (EXTI_EMR) : Un bit m is à 0 masque et désactive la génération
d’événements de la ligne correspondante. Un ‘1’ permet de l’autoriser et d’exciter par
conséquent le «Pulse Generator» qui génère une impulsion sur un pin IO.
Remarque : Ce p in IO, qu i do it être co nfiguré en so rtie AF, est d éterminé p ar le co ntenu du

registre Event Control Register (AFIO_EVCR) qui fait partie du bloc AFIO.
Deux fonctions du fichier stm32f10x_gpio.c permettent de manipuler ce registre :
void GPIO_EventOutputCmd (FunctionalState NewState)
NewState : pouvant pre ndre l es val eurs: ENAB LE (a ctivation de l a sort ie d ’impulsion) o u b ien
DISABLE.
void GPIO_EventOutputConfig ( uint8_t GPIO_PortSource, uint8_t GPIO_PinSource )
Cette fonction permet de sélectionner le pin à utiliser pour la génération de l’impulsion, avec
GPIO_PortSource : pouvant prendre l’une des valeura GPIO_PortSourcex (x= A, B, C, D ou E).
GPIO_PinSouce : pouvant prendre l’une des valeurs GPIO_PinSourcex (x=0, 1,2,…..14, ou 15)
Emir Damergi 2017

2-3 Programmation des EXTI
Pour la programmation des lignes EXTI, la librairie ST offre la structure

typedef struct {
uint32_t EXTI_Line;
EXTIMode_TypeDef EXTI_Mode;
EXTITrigger_TypeDef EXTI_Trigger;
FunctionalState EXTI_LineCmd;
} EXTI_InitTypeDef;
EXTI_LINE: Specifies the EXTI lines to be enabled or disabled. This parameter can be one ore
any combination (Logic OR) of EXTI_Lines:
#define EXTI_Line0 ((uint32_t)0x00001) //0000 0000 0000 0000 0001

…………… ………… ………….
………… ………… …
EXTI_Mode: Specifies the mode for the EXTI lines. This par ameter can be a value of
EXTIMode_TypeDef:
typedef enum
{
EXTI_Mode_Interrupt = 0x00, //Configurer les lignes EXTI en mode interruption
EXTI_Mode_Event = 0x04 //Configurer les lignes EXTI en mode événement
} EXTIMode_TypeDef;
EXTI_Trigger : Specifies the trigger signal active ed ge for the EXTI lines. This
parameter can be a value of EXTIMode_TypeDef:
typedef enum
{
EXTI_Trigger_Rising = 0x08, // Décelenchemet sur front montant
EXTI_Trigger_Falling = 0x0C, // Décelenchemet sur front descendant
EXTI_Trigger_Rising_Falling = 0x10 // Décelenchemet sur front montant ou descendant
} EXTITrigger_TypeDef;
EXTI_LineCmd : Specifies the new state of t he selected EXTI lines. Th is parameter can
be set either to ENABLE or DISABLE.
Emir Damergi 2017

Le fichier stm32f10x_exti.c contient plusieurs fonctions, on cite quelques unes :
 void EXTI_Init (EXTI_InitTypeDef *EXTI_InitStruct)

// Initializes the EXTI peripheral according to the specified parameters in the EXTI_InitStruct.
 void EXTI_ClearITPendingBit (uint32_t EXTI_Line)
// Clears the EXTIs line pending bits.
 void EXTI_GenerateSWInterrupt (uint32_t EXTI_Line)
// Generates a Software interrupt.
Exemple1 : Le code suivant permet de configurer les lignes EXTI 0 & 4 en mode interruption
avec déclenc hement sur front montant, EXTI6 sur front descendant (On n’i ndiquera pas l e code
permettant la configuration des IOs et des signaux d’horloge):
// Déclarer une variable de type structure EXTI

EXTI_InitTypeDef EXTI_InitStructure;
// Configurer les lignes EXTI 0 et 4 en mode interruption sur front montant

EXTI_InitStructure.EXTI_Line = EXTI_Line0 | EXTI_Line4; // EXTI0 & EXTI4
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init ( &EXTI_InitStructure); // Initialiser la structure (registres) relative au module EXTI
// Configurer la lignes EXTI 6 en mode interruption sur front descendant

EXTI_InitStructure.EXTI_Line = EXTI_Line6;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
EXTI_Init ( &EXTI_InitStructure); // Initialiser la structure.
Remarque : On n’est pas obligé de déclarer les paramètres EXTI_Mode et EXTI_LineCmd une deuxième fois
puisqu’ils ont déjà les valeurs adéquates.
Emir Damergi 2017

Exemple2 : Le code suivant permet de configurer les lignes EXTI 1 et 7 en mode évenement avec
déclenchement sur front montant, avec génération d’une im pulsion sur le pi n PB7 ( On n’indiquera
pas le code permettant la configuration des IOs et des signaux d’horloge):
// Déclarer une variable de type structure EXTI

EXTI_InitTypeDef EXTI_InitStructure;
// Configurer le pin PB7 comme pin de sortie de l’impulsion à générer

GPIO_EventOutputConfi g ( GPIO_PortSourceB, GPIO_PinSource7 );
// Activer la sortie d’évenements

GPIO_EventOutputCmd (ENABLE) ;
// Configurer les lignes EXTI 0 et 4 en mode événement sur front montant

EXTI_InitStructure.EXTI_Line = EXTI_Line1 | EXTI_Line7; // EXTI1& EXTI7
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Event;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init ( &EXTI_InitStructure); // Initialiser la structure (registres) relative au module EXTI
Emir Damergi 2017

Chapitre 7 Transfert DMA
Chapitre
Transfert de données : Le contrôleur DMA
Par Damergi Emir
1. Introduction
Dans l es systèmes à proc esseurs, la c ommunication avec l’ extérieur se fait à traver s des
périphériques (d’ interfaces) d’ entrées/sorties intégrés « I/O Peripherals, (USART pour l a
communication série, l’ADC pour l’acquisition des signaux analogiques, etc..). On se trouve ainsi dans
la nécessité de faire des transferts fréquents de données (Figure 1):
1- D’un périphérique vers la mémoire ‘de données’ pour être traitées par le processeur
2- D’un périphé rique vers u n autre ( exemple : convertir un signal analogiq ue avec l’ADC et
transférer le résultat de la conversion vers l’interface de co mmunication série (USART) pour
l’envoyer à un autre système.
3- De la mémoire ‘de données’ vers un périphérique (exemple : le contenu d’une trame à envoyer
sur liaison réseau Ethernet).
4- D’une m émoire à une mé moire (la mémoire s ource peut être elle- même la mémoire
destination).
Mémoire Mémoire Periph Periph Periph

Code Data
Code
Processeur USART Ethernet ADC
Bus
(Instructions) 4 (Données)
3
1
Bridge
Data bus Peripheral Bus 2
Figure – 1 :
Emir Damergi 2017

Chapitre 7 Transfert DMA
2. Transfert par processeur
Dans le cas de figure, ou le processeur est le seul responsable de toutes les tâches, il doit
interrompre le traitement en cours pour effectuer le transfert qui s’exécute en plusieurs cycles. Prenons
l’exemple du transfert des données se t rouvant dans la mémoire vers le périphérique réseau pour être
encapsulées dans une trame Ethernet et transmises. (Figure 2) :
Mémoire Mémoire Periph Periph Periph

Code Processeur Data
Code
(Registres) USART Réseau ADC
(Instructions)
Bus Données
(Données)
2 1
Bridge
Data bus Periphera Bus
Figure -2 :
Pour assurer ce transfert, le processeur doit :

 Arrêter le traitement en cours et sauvegarder le contexte.
 Exécuter d’une façon répétitive, une séquence de lectures et écritures des données:
For 1 Taille données :
1- Transférer donnée (i) vers un registre interne de processeur
2- Transférer contenu registre du processeur vers le périph Réseau.
 Récupérer le contexte et continuer le traitement interrompu.
Ceci di minue considérable ment le s perf ormances du processeur qui doit à chaque transfer t
interrompre le traitement, surtout que les opérations de transfert sont très fréquentes et que les te mps
d’accès à la mémoire et aux registres des périphériqu es sont très i mportants (100 nsec) relat ivement à
la fréquence de fonctionnement du processeur (moins d’une nsec à qq nsec).
Pour re médier à cett e dét érioration des perfor mances du traite ment, la solution proposée a
consisté à déléguer la fon ction de tran sfert à un pé riphérique de contrôle déd ié à cette tâche : Le
contrôleur DMA (Direct Memory Access).
3. Le contrôleur DMA
Le contrôleur DMA, considéré comme étant un périphérique par le processeur, est lui-m ême
un processeur à usage unique (SPP : Single Purpose Processor) dont la tâche est l’accès séquentiel en
lecture et écriture aux mémoires de données et aux registres des périphériques.
Emir Damergi 2017

Chapitre Transfert DMA
Un contrôleur DMA est capable de gérer un certain nom bre de canaux. Un canal ét ant une
connexion configurable entre deux périphériques caractérisés par les paramètres suivants :
- Les signaux pouvant déclencher le transfert : généralement, ils sont issus de l ’un des
périphériques. (Un transfert peut être également lancé par soft)
- Les adresses source et destination du transfert.
- La taille des données à transférer.
Ainsi, le contrôleur DMA devrait ainsi disposer:
- Pour chaque canal, d’un ensemble de registres pour la sauvegarde des adresses source,
destination, taille des données ainsi que l’état du transfert en cours.
- D’un bus (lignes d’adresses, de données et de contrôl e) pour l’accès aux mémoires de
données et aux registres des périphériques.
- Des signaux de requête ( Req : Request) issus des périphériques susc eptibles de
demander un transfert et de notificatio n ( Ack : Acknowledgm ent) vers ces mêmes
périphériques pour notifier la réception de la requête.
- Des registres de configur ation po ur d éterminer les canaux actifs, leurs niveaux de
priorité, etc….
- Des registre(s) (Buffer) pour stocker tem porairement les donné es à transférer de la
source vers la destination. Il peut s’agit d’un simple registre ou bien d ’une mémoire
FIFO dont la taille peut aller de quelques à quelques dizaines de Kilooctets.
- D’une logique d’ arbitrage pour déterminer le canal ay ant droit à l’ accès au bus si
plusieurs canaux demandent un transfert en même temps.
DMA
Channel N
Signaux de requ ête Channel. Signaux de notification
(Req) d e tra nsfert issus Channel. (Ack) vers les
des péri phériques p our périphériques dem andant
Channel 1
demander un transfert. un transfert
@source
@destination
Taille
Etat transfert
Buffer
Reg Config Arbitrage

Bus
Figure -3 :
Emir Damergi 2017

Ainsi, pour une architecture Harvard, la st ructure du s ystème devient comme présenté ci-
dessous (Figure 4) : le processeur n’ est plus le seul ayant accès a u bus ‘données’ , il y’a également le
contrôleur D MA qui peut accéder à n’ importe quell e zone mé moire ou registre périphérique du bus
‘données’ : on parle de maître « Master ». La mémoire et le s périphériques étant appelé s esclaves
« Slaves ».
Transfert Requests to DMA
Code Code Processor DMA Memory

Memory Bus (Master) (Master) (Slave)
USART ADC Ethernet
(Slave) (Slave) (Slave)
Arbitration
Bridge
Data Bus Peripheral Bus
Figure – 4 :
Il faut noter que dans ce c as, ou plusieurs maîtres accèdent au bus, une technique d’ arbitrage
doit être utilisée pour gérer l’accès. Généralement, les bus actuels utilisés dans les systèmes embarqués
(tel que le bus AHB utilisé dans les microcontrôleurs STM32), i ntègrent cette technique d’a rbitrage
qui peut consister en une si mple gestion de nivea ux de priorités ou en un m ultiplexage temporel plus
évolué (round robin).
4. Programmation & Phases d’un transfert DMA
Pour qu’un transfert DM A puisse s’ effectuer, il faut co mmencer p ar programmer le DMA C

ainsi que le(s) périphériques impliqué(s) dans le transfert.
 Configurer un canal de transfert DM A, en Configuration DMA & periph par le proc.

initialisant ses registr es avec les adr esses Code
Bus
source, destination et taille des données.
DMA (Chan i)
 Configurer le périphérique de telle sorte qu’il @src
Processeur
génère des dem andes de transfert ( Request) Mémoire
@dest
pour des événem ents précis ( exemple : la Taille
Periph
réception d’une trame Ethernet).
Bridge
Data Bus (with Arbitration) Peripheral Bus

Ceci est fait par le processeur durant
l’initialisation, donc une seule fois. Figure - 5 :
Emir Damergi 2017

Toute opérati on de transfert met en jeu un certain nom bre de signaux ( voir figure 5) q ui
devraient assurer la synch ronisation des actions des différents composants du système impliqués dans
l’opération de transfert.
DREQ (Data REQuest)
DMA
Controller DACK (Data ACKnowledgment)
Peripheral
HRQ (Hold Request) HLDA (Hold Acknowledgment)
Bus
Arbiter
Figure – 6 :
Cet échange de signaux respecte un ordre chronologi que précis (voir ci-dessous). Une fois, le
DMAC et le(s) périphérique(s) configu ré(s), l’opération de transfert co mmence automatiquement dés
le déclenchement de l’événement attendu.
DREQ (Periph) 1 5
2
HREQ (DMAC)
3 7
HLDA (Bus Arbiter)
6
DMAC Bus Access
8
4
DACK (DMAC)
Figure – 7 ;
1) Le périphérique commence par demander au contrôleur DMA un transfert de do nnées

en activant le signal DREQ.
2) Le DMA, après avoir détecté l’ activation de DREQ, demande au contrôleur de bus
(Bus Arbiter) l’autorisation d’accès en activant le signal HREQ. Dans certains systèmes, le contrôleur
de bus peut être le processeur même, c’ est le cas du PC. Dans d’ autres, il s’ agit d’ un contrôleur
indépendant (bus AHB).
3) Le contrôleur de bus active le signal HLDA pour in former le contrôleur DMA que le
bus est libre pour le transfert
Emir Damergi 2017

4) Le contrôleur DMA accède alors au bus pour co mmencer le tran sfert et informe en
même temps le périphérique en activant le signal DACK.
5) Le périphérique désactive la demande de requête DREQ.
6) Le contrôleur DMA continue le transfert jusqu’à ce que
7) Le contrôleur de bus désac tive le signa HLDA pour l’inf ormer que le bus n’est plus
libre. Alors le contrôleur DMA désactive la demande d’accès HREQ.
8) Le contrôleur DMA libère le bus et désactive l e signal DACK pour notifier au
périphérique que le transfert s’est terminé. Ainsi, le périphérique peut demander d’autres transferts.
Selon la duré e de la phase d’ accès bus (6) et par conséquent le nom bre d’ unités de données
transférées, on distingue deux modes de transfert :
 Block mode : Dans ce mode, le DMA occupe le bus jusqu’à transférer tout un bloc de données. Le
processeur reste dans ce cas bloqué (Figure 8).
 Single Mode : dans ce mode, le contrôleur DMA ne peut alors transférer qu’un e unique unit é de
données. Pour l’ unité suivante, le périp hérique doit soumettre une nouvelle demande de r equête.
Dans ce cas, la bande passante du bus est partagée entre DMAC et processeur. Ce mode est appelé
également « bus stealing ».
i : 1 Taille { Code
1- Read data from: Mémoire (@src) Bus
DMA
2- Write data to : Périph (@dest) (Chan i)
3- @src++, @dest++ } Processeur
3
Mémoire
Ethernet
Remarque : dans le mode single, i=1 (pas de
1
étape 3) 2
Bridge
Data Bus (with Arbitration) Peripheral Bus
Figure -8 :
5. Contrôleur DMA à usage général / à usage spécifique
Le contrôleur DMA qu’on vient de décrire permet d’effectuer des transferts de n’importe quel
périphérique (ou zone mém oire) ve rs n ’importe quelle zone mémoire (ou périphérique). Ce type de
contrôleurs DMA est dit à usage général (General Purpose) : GP-DMA.
Ces contrôleurs doivent accéder deux fois au bus pour effectuer un transfert : une fois pour la
lecture à partir de la source et une deuxième fois pour l ’écriture dans la destination. Ceci est très
Emir Damergi 2017

pénalisant au niveau de la bande passante du bu s surtout pour l es périphériques de co mmunication

(Ethernet, USB, ..) qui transportent des flux ayant des débits l’ordre de dizaine de Mbits.
L’idée était d’util iser un DMA intégré à ces pé riphériques et dont le buffer (la mémoire dans
laquelle il stocke les données) n’ est autre que la mémoire du périphérique même. Ainsi l’ utilisation de
ce DMA permet d’effectuer le transfert en un seul accès bus et par conséquent de diviser le nombre et
la taille des transferts par 2 : Au lieu de transférer les données d’une mémoire vers le DMA et ensuite
du DMA vers le périphérique ou i nversement, uniquement le prem ier transfert est réalisé puisque le
DMA accède directement au buffer du périphérique (F igure 9) : on parle de D MA à us age spécifique
(Single Purpose DMA) SP-DMA.
DMA DMA
Mémoire (Chan i) Periph. Mémoire (Chan i) Periph.
DMA
intégré
a b
Figure -9 : Transfert entre mémoire et périphérique Ethernet
a) avec GPDMA (2 transferts) b) avec DMA dédié intégré (1 transfert)
6. Architecture & performances d’accès DMA
On voit bien que parallèle ment au tra nsfert des données de la mé moire au périphérique, le
processeur peut continuer à accéder à la mémoire ‘code’ par le bus ‘code’ et exécuter le programme.
Toutefois, le processeur peut avoir besoi n de données se trouvant dans la mémoire ‘données’
et doit par conséquent accéder au bus ‘données’ pa rallèlement au DMA. Dans ce cas, c’est la
technique d’arbitrage, intégrée au bus ‘données’, qui doit gérer ce conflit.
Il se peut donc, que le processeur doive attendr e quelques cy cles, mais même dans ce cas le
l’apport du DMA et le gain en performances reste toujours assez important.
Pour le cas traité, on a supposé une architecture Harvard (ce qui est le cas de la majorité des
processeurs embarqués), ou le processeur dispose d’un bus pour l’accès à la zone code et un autre bus
pour l’accès au données.
Emir Damergi 2017

On peut se demander, si l’ utilisation d’un DMA peut avoir le même int érêt dans une
architecture Von Neuman, ou un seul bus est utilisé pour l’accès au code et aux données ?
Il est clair que le conflit d’ accès au bus entre pr ocesseur et DMA devrai t se poser pl us
fréquemment que dans le cas d’une architecture Harvard, mais même dans ce cas une amélioration des
performances peut être atteinte.
En effet, les processeurs disposent généralement d’une mémoire cache qui contient une copie
d’une partie du code à ex écuter et des données à tra iter et il est ainsi possible pour le processeur de
continuer à exécuter le co de disponible dans la mémoire cache pendant que le DMA accède au bus et
effectue le transfert.
Et même, dans le cas ou, le code à exécuter n’est pas disponible dans la mémoire cache, ou
bien le processeur ne dispose pas d’ une mémoire cache, alors le processeur devrait arrêter l’exécution,
mais sans êt re obligé d’ effectuer les opérations pé nalisantes de sauvegarde et de récupération de
contexte (voir paragraphe 2). Au moins ça de gagné.
Emir Damergi 2017

Chapitre 8 Le Contrôleur DMA
Chapitre 8
Contrôleurs DMA à usage général (GP-DMA) dans les
microcontrôleurs STM32 (Famille F1)
Par Damergi Emir
1. Introduction
Comme tous les systèmes à processeurs, les m icrocontrôleurs STM32 (fa mille F1) sont dotés
de contrôleurs DMAs :
 1 GP-DMA pour les low density et medium density devices.
 2 GP-DMA pour les High density devices.
 4 po ur les connectivity line devices : 2GP-DMA et 2 contrôle urs DMA dédiés (SP-DM A)
respectivement aux transferts vers et depuis les périphériques de communication Ethernet et USB.
Ces Contrôleurs DMA se partagent avec le Cortex-M3 un bus e n m atrice (multi AHB bus
matrix) et pe rmettent diffé rentes co mbinaisons de transfert entre mémoires et périphériques ( Figure
1).
1
Bus masters
Transfer
GP GP Ethernet USB Requests
Cortex-M3 DMA DMA DMA DMA From Periphs
System 1 2 To DMAs
Instructions Bus
Data Bus
APB1
Peripherals
AHB
Periph. APB2
Peripherals
Embedded SRAM
System SRAM (2K) Bus slaves
D Data only
Flash
I Instructions only
Data + Instructions
Figure -1 :
On voit bien que le processeur cortex-M3 peut accéder aux instructions dans les mé moires
Flash, SRAM système (system SRAM) et la SRAM embarquée (embedded SRAM).
Pour les données, elles p euvent se trouver dans les différentes mém oires cit ées ainsi qu’au
niveau des périphériques et peuvent être accédées aussi bien par le processeur que par les 2 DMAs.
Grâce à l’ architecture en matrice du bus, il est possible d’ effectuer plusieurs transfert s

simultanés. Ainsi on peut avoir, par exemple, parallèlement:
 Un accès du Cortex-M3 à la mémoire Flash pour récupérer des instructions (Inst bus).
 Un accès du DMA1 à la mémoire Flash pour transférer des données vers la mémoire SRAM
embarquée.
 Un accè s du DMA2 à la mé moire SRAM systè me pour transférer des données vers l es
périphériques.
Donc en bien choisissant les em placements de sto ckage des données, les maîtres et les
esclaves i mpliqués dans les transf erts, on peut éviter au maximum les conflits d’ accès à une même
ressource et par conséquent atteindre des performances optimales.
2. Les DMA à usage général du STM32
Les 2 GP-DMA sont :
 DMA 1 : disponible dans toutes les versions de la famille F1 et il est capable de gérer jusqu’à
2
7 canaux possédant des ni veaux de priorités matérielles fixes (Fixed hardware priority) par défaut
(Figure 3) qui peuvent être reconfigurés par soft.
Les périphériques pou vant émettre une requête de transfert a ux différents canaux sont
nombreux (Figure 3), mais un instant donné un seul périphérique par canal est autorisé à émettre
une requête. Le transfert ne peut commencer si le signal de requête et le canal sont actifs
Pour effectuer un transfert d’une mémoire à un autre, c’est le signal MEM2MEM qui doit être
activé, et ceci ne peut se faire que par programmation «soft » (Figure 3). Dans ce cas le tr ansfert
sera lancé directement si le canal est actif.
 DMA 2 : disponible dans toutes les versions de la famille F1 à l’exception des « low density
devices» qui ne contiennent que le DMA1. Le DM A 2 a les mêmes propriétés que le DMA 1
et est capable de gérer jusqu’à 5 canaux (Figure 4).
Figure -3 : Liste des requêtes des canaux du DMA1
3
Chapitre Le Contrôleur DMA
Figure -4 : Liste des requêtes des canaux du DMA2
3. Registres des canaux des GP-DMA
En plus des registres (2 par DMA) permettant d e gérer les interruptions (paragraphe 5),
Chaque Canal contient 4 Registres (Figure 5):
 DMA_CCRx 1(DMA Channel x Configuration Register) : C’est un registre 32 bi ts, m ais

uniquement 15 bits sont utilisés pour activer et configurer le canal (paramètres du transfert).
 DMA_CPARx (DMA Channel x Peripheral Address Register) : c’est un registre 32 bits qui
contient l’ adresse d’ un registre d’ un périphérique ( ou d’un emplacement mémoire si on
effectue un transfert mémoire à mémoire) représentant l’adresse source ou bien destination du
transfert en fonction du sens du transfert déterminé par le registre DMA-CCRx
 DMA_CMARx (DMA Channel x Memory Address Register) : c’est un regi stre 32 bits q ui
contient l’ adresse d’ un e mplacement mémoire ( ou d’un registre d’un périphérique si on
effectue un transfert de périphérique à périphérique) représ entant l’ adresse so urce ou bien
destination du transfert. Ceci dépend du sens du transfert qui peut être déterm iné par le
registre DMA-CCRx.
 DMA_CNDTRx (DMA Channel x Number of Data Register) : c’ est un registre 32 bits,

uniquement les 16 bits poids faible sont utilisés pour indiquer le nombre d’unités de données à
1
x dénotant le numéro du canal, donc de 1 à 7 pour le DMA1 et de 1 à 5 pour le DMA2
4
transférer, donc un m aximum de 65535 unités. L’ unité pouvant ê tre 8, 16 o u 32 bits et est
déterminée également par le registre DMA_CCRx.
DMA (Channel x)
DMA_CMARx DMA_CPARx
DMA_CNDTRx
Enable
Data
size
Mémoire Periph.
DMA_CRRx
Transfer Direction
Bridge
Figure -5 :
4. Registres & configuration des canaux GP-DMA
Dans cette p artie, on présentera parallè lement les re gistres des D MA et la signification de
leurs contenus ainsi que structures et fonctions de la librairie Firmware ST permettant de les manipuler
d’une façon transparente. Ceci per met de choisir e ntre une progra mmation par acc ès dir ecte aux
registres ou bien en utilisant la librairie ST.
Ci-dessous, une corre spondance entre les différents paramètres d e la structure
DMA_InitTypeDef relative au DMA ( faisant partie de la librairie Firmaware ST) et le contenu des
registres présentés précédemment. On présentera ensuite la signification des paramètres.
typedef struct {
Registre DMA_CPAR_x
uint32_t DMA_PeripheralBaseAddr; 31………….0 Bit // voir parag3 (DMA_CPARx)
Registre DMA_CMAR_x
uint32_t DMA_MemoryBaseAddr; 31………….0 Bit // voir parag3 (DMA_CMARx)
Registre DMA_CNDTRx
31….......…16 15.…..…….0 Bit
Toujours à 0
uint32_t DMA__BufferSize; // voir parag3 (DMA_CNDTRx)
5
Registre DMA_CCRx
1 1 1 1 1
31…….15 9 8 7 65 4 321 0 bit
4 3 2 1 0
Interrupts
ENABLE
ENABLE
Not used
Channel
MSIZE
PSIZE
Pririty
MINC
mem2
CIRC
PINC
Level
mem
DIR
// Voir
parag 5
uint32_t DMA_M2M;
uint32_t DMA_Priority;
uint32_t DMA_MemoryDataSize;
uint32_t DMA_PeripheralDataSize;
uint32_t DMA_MemoryInc;
uint32_t DMA_PeripheralInc;
uint32_t DMA_Mode;
uint32_t DMA_DIR;
} DMA_InitTypeDef;
Pour la configuration du DMA au niveau du code C (après activation de l’horloge) :

1- On commence par déclarer une structure de type DMA_InitTypeDef
DMA_InitTypeDef DMA_InitStructure ;
2- Il est toujours conseillé de réinitialiser le périphérique
DMA_Deinit (DMAy_Channelx, &DMA_InitStructure) ;
3- On initialise le canal x du DMA y avec les paramètres en invoquant la fonction
DMA_Init (DMAy_Channelx, &DMA_InitStructure) ;
4- On active le canal par mise à 1 du bit ENABLE (Un 0 désactive le DMA)
DMA_Cmd (DMAy_Channelx, ENABLE); // pour désactiver, on utilise pour le 2ème paramètre
// la valeur DISABLE
6
Pour chacun des para mètres, on prése nte ci-dessou s la significa tion ainsi que les val eurs
possibles qu’il peut prendre.
Propriété Bit (s) Signification
(Firmware Library) DMA_CCRx
La valeur permet de déterminer si le transfert doit être
DMA_M2M Bit 14
effectué entre 2 mémoires ou non
Transfert entre 2 mémoires. Dans ce cas la propriété

DMA_PeripheralBaseAddr qui pre nd l a val eur d u
registre DMA_CPARx représente l’a dresse d’une
zone mémoire.
DMA_M2M_Enable 1 Mem. DMA (Channel x)
DMA_CMARx
DMA_CPARx
Transfert ent re un périphérique et une z one mémoire

DMA_M2M_Disable 0
ou bien entre deux périphériques.
Le Ni veau de pri orité at tribué par p rogrammation au
canal. Si deux canaux ont le même niveau de priorité,
DMA_Priority Bits 13, 12 alors c’est la «Fix ed Hardware Priority » (voir Parag
2) qui détermine le canal le plus prioritaire. 4 niveaux
sont possibles :
DMA_Priority_VeryHigh 1 1 Très haute priorité

DMA_Priority_High 1 0 Haute priorité
DMA_Priority_Medium 0 1 Priorité moyenne
DMA_Priority_Low 0 0 Priorité faible
La taille d’une unité de données de la zone pointée par
DMA_MemoryDataSize 2 Bits 11, 10
le registre DMA_CMARx. Elle peut être :
DMA_MemoryDataSize_Byte 00 1 byte (8 bits)
DMA_MemoryDataSize_HalfWord 01 dem i mot (16 bits)

DMA_MemoryDataSize_Word 10 1 mot (32 bits)
La taille d’une unité de données de la zone pointée par
DMA_PeripheralDataSize 2 Bits 9, 8
le registre DMA_CPARx. Elle peut être :
DMA_PeripheralDataSize_Byte 00 1 byte (8 bits)

DMA_PeripheralDataSize_HalfWord 0 1 demi mot (16 bits)
DMA_PeripheralDataSize_Word 10 1 mot (32 bits)
2
Si les tailles des zones source et destination sont différentes, consulter Paragraphe 6
7
Indique si les adresses de la zone pointée par

DMA_MemoryBaseAddr =DMA_CMARx doivent
DMA_MemoryInc Bit 7
être automatiquement incrémentées après chaque
transfert.
Incrémentation automatique de l’adresse.
Dans ce cas, si DMA_MemoryBaseAddr = X
et DMA__BufferSize = Y.
Alors le DMA commence pa r un transfert d epuis ou
DMA_MemoryInc_Enable 1
vers l’ad resse X, ensuite incrémente l’adresse aprè s
chaque tra nsfert X+1, X+2,….X+Y. Donc, jusqu’à
transférer la to talité d es do nnées du Buffer.
Parallèlement DMA__BufferSize est décrémenté.
Aucune in crémentation. C’est g énéralement le cas
DMA_MemoryInc_Disable 0 quand on lit à p artir d ’une adresse u nique
(DMA__BufferSize = 1).
Même propriété que « DMA_MemoryInc », mais

DMA_PeripheralInc Bit 6
pour la zone pointée par DMA_PeripheralBaseAddr
DMA_PeripheralInc_Enable 1 Incrémentation automatique.
DMA_PeripheralInc_Disable 0 Pas d’incrémentation.
DMA_Mode Bit5 Indique si le mode buffer circulaire est utilisé.
Le mode circulaire est utilisé. Dans ce mode, une fois

la dernière donnée est transférée (l’adresse X+Y),
alors l’adresse sera automatiquement réinitialisée à X
DMA_Mode_Circular 1
et DMA__BufferSize à Y.
Rq: Ce mode ne peut être utilisé dans un transfert de
mémoire à mémoire (pour DMA_M2M = 1).
Mode normal : aucune réinitialisation de l’adresse

DMA_Mode_Normal 0 après un cycle de transfert de la totalité du buffer (Y
unités de données). DMA__BufferSize sera à 0.
DMA_DIR Bit 4 Indique la direction du transfert.
Zone p ointée par DMA_PeripheralBaseAddr est la
DMA_DIR_PeripheralDST 1
destination.
Zone p ointée par DMA_PeripheralBaseAddr est la
DMA_DIR_PeripheralSRC 0
source.
Remarques :
- Le changement d’une propriété (donc l’accès à un registre) ne peut se faire que si le canal est désactivé.
8
5. Les interruptions relatives au transfert DMA
Chaque canal DMA peut être configuré pour générer une in terruption po ur un ou un e
combinaison des 3 événements suivants:
 Transfer Error (TE) : Une erreur de t ransfert s’est produite. Ca peut être à cause d’un accès
à une zone mémoire ré servée, ou un problème d’accè s au bus , etc… En c as d’ erreur de
transfert, le canal sera automatiquement désactivé par hardware.
 Half Transfer (HT) : La moitié des données a été transférée (DMA__BufferSize/2 unités).
 Transfer Complete (TC) : La totalité des données a été transférée (DMA__BufferSize unités).
L’ activation de ces sources d’interruptions se fait par la mise à 1 des bits correspondants (Bits
3,2 et 1) dans le registre de configuration DMA_CCRx, un 0 pour les désactiver :
……4 32 10 bit
TEIE HTIE TCIE
Bit 1 TCIE : Transfer Complete Interrupt Enable

Bit 2 HTIE : Half Transfer Interrupt Enable
Bit 3 TEIE : Transfer Error Interrupt Enable
Au niveau de la librairie Firmware ST, la fonction permettant d’accéder à ces bits est :
void DMA_ITConfig (param1, param2, param3)

param1 étant le canal à configurer a yant la sy ntaxe DMAy_Channelx (y : Nr DMA et x du
canal).
param2 spécifie les sources d’ interruptions à active r ou à désactiver et peut être l’une ou une
combinaison (ou logique : | ) des valeurs suivantes : DMA_IT_TC, DMA_IT_HT et DMA_IT_TE.
param3 prend la valeur ENABLED pour activer les sources d’ interruptions et DISABLED pour
les désactiver.
Exemple : pour activer les sources r elatives au transfer co mplete et half transfer et
désactiver la source relative au transfer error du canal 5 du DMA2:
DMA_ITConfig (DMA2_Channel5, DMA_IT_TC | DMA_IT_HT, ENABLE);

DMA_ITConfig (DMA2_Channel5, DMA_IT_TE, DISABLE);
En plus de ces bits, deux registres par DM A sont utilisés pour la gestion des so urces
d’interruptions :
9
1- Le registre DMA_ISR (DMA Interrupt Status Register) qui contient l’état des sources
d’interruptions (IF : Interrupt Flag) de to us les can aux du DMA (4 bits pour chaque canal) et ne peut
être accédé qu’en lecture :
Figure - 6 : Registre DMA_ISR

Pour chaque canal x (x=1..7 pour DMA1 et x = 1..5 pour DMA2) :
 TEIFx, HT IFx et TC IFx chacun indiquant respective ment les états des évé nements (Tra nsfer
Error, Half Transfer et Transfer Complete). 1 si l’événement est a eu lieu, 0 sinon.
 GIFx (Global Interrupt Flag) est m is à 1 si une ou plusieurs des 3 sources d’interruptions sont
actives.
Toutes les sources d’ interruptions par canal ont une unique entré e au niveau du contrôleur
d’interruptions NVIC et sont connectées au NIVIC comme suit (Figure 7)
DMA_ISR Register DMA_CCRx NVIC Register

(Channel x) Register
DMAy Channelx
Interrupt Enable
bit
OR
OR & INT
& & (NVIC)
Figure – 7 : Déclenchement des Interruptions relatives au DMA
Donc, pour qu’une interruption relative à un canal x donné se déclenche, il faut que :
 Le canal DMA soit activé (bit EN du registre DMA_CCRx).
 Au moins, une parmi les sources d’interruptions autorisées (bits TEIE, HTIE, TCIE du registre
DMA_CCRx), se déclenche.
 L’interruption relative au canal so it autorisée au niveau du NVIC. Ceci se fait par mise à 1 du
bit correspondant dans le r egistre de masquage du NVIC (ou bien en passant par la structure
NVIC_InitStructure avec NVIC_IRQChannel = DMAy_Channelx_IRQn y : le nr du DMA ;
x : le nr du canal) « voir chapitre »
10
Par conséquent, lors du déclenche ment d’ une interruption relative à un canal x, on ne peut
déterminer di rectement la source de l’ événement a ctif puisque toutes les 3 activent la même lign e
d’interruption au niveau du NVIC. Il faut donc commencer par consulter le registre DMA_ISR pour
déterminer connaître quelle source parmi celles autorisées a déclenché l’interruption.
Pour la lecture de l’ état d’une source d’interruption d’un canal x, soit on accède directe ment
au bit (le registre fait partie de la zone Bit Banding), ou bien on peut utiliser une fonction de la STM32
Firmware Library :
DMA_GetITStatus ( uint32_t DMA_IT )
Qui retourne vrai si le bit est à 1, faux sinon.

Pour le paramètre DMA_IT, il s’agit du bit à lire. La syntaxe utilisée est la suivante
DMAy_IT_ABx: y étant le numéro du DMA, x le numéro du canal
AB le Type de l’événement qui peut être (GL : Global, TC : Transfer Complete,
HT : Half Transfer et TE : Transfer Error).
Une fois l’interruption servie, il faut rem ettre à 0 la source d’interruption da ns le registre
DMA_ISR. Mais, étant d onné que ce registre ne peut être accéd é qu’en lecture, l’opération d’écriture
se fait par le biais d’un autre registre (voir paragraphe suivant).
2- Le registre DMA_IFCR ( DMA Inte rrupt Flag Clear Register) qui a exactement la même
structure que le registre DMA_ISR (Figure 8). La mise à 1 d’un b it du registre DMA_IFCR a comme
effet de remettre à 0 le bit correspondant dans le registre DMA_ISR.
Figure -8 : Registre DMA_IFCR

La m ise à 1 d’un bit peut se faire par accès di rect ou en utilisa nt la fonction du Firm ware
Library :
DMA_ClearITPendingBit (uint32_t DMA_IT )
Cette fonction n ’a pas de valeur de ret our et elle prend comme para mètre D MA_IT comme
pour la fonction DMA_GetITStatus ( ).
En ce qui co ncerne le gestionnaire d’interruptions, relatif au canal x du DM A y et à ajouter
au niveau du fichier stm32f10x_it.c, il doit porter le nom : DMAy_ChannelxIRQHandler ( )
11

Arch Circuit Stm32-1

Transféré par

Informations du document

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

Arch Circuit Stm32-1

Transféré par

Droits d'auteur :

Formats disponibles

Microcontrôleurs 32 bit : le choix Cortex-M3

Par Damergi Emir

1- Microcontrôleurs : les tendances

Un microcontrôleur ou MCU (MicroController Unit) est un sy stème informatique entier co ntenu

DMA Interrupt Processor Memory Memory

Timer Serial Network ADC

Figure 1 : Architecture simplifiée d’un microcontrôleur

Damergi Emir 1 Version 1.0

2000 2006 2009

Figure 2 : Evolution des ventes en % des microcontrôleurs 8, 16 et 32 bits

Damergi Emir 2 Version 1.0

2- ARM et les processeurs CORTEX

Damergi Emir 3 Version 1.0

Architecture Architecture Architecture Architecture

ARM7TDMI ARM 926, 946 ARM 1136, Cortex-A8

Figure 4 : Evolution des architectures ARM

Damergi Emir 4 Version 1.0

0,9 à 1,25 DMIPS 1,6 DMIPS 1,6 à 2,5 DMIPS

Figure 5 : Performances et domaines d’applications des profils de l’architecture Cortex

Damergi Emir 5 Version 1.0

Figure 6 : Versions des processeurs Cortex-M

Damergi Emir 6 Version 1.0

3- Pourquoi le choix Cortex-M

Figure -7 : Architecture simplifiée du processeur Cortex-M3 de ARM

Damergi Emir 7 Version 1.0

Figure -8 : Efficacité énergétique ( en MIPS/mW ) pour différentes plateformes embarquées

 Performance : Avec une capacité de traitement de 1,2 5 DMIPS et une fréquen ce de

Figure -9 : Comparaison des performances (DMIPS/MHz) du Cortex-M3

 Utilisation optimale de la mémoire : Grâce à l’utilisation de la t echnologie Thumb-2 qui permet

Damergi Emir 8 Version 1.0

Figure 10 : Comparaison de la densité du code du Cortex-M3par rapport à d’autres architectures

Damergi Emir 9 Version 1.0

Par Damergi Emir

Code Bus Unité de protection Data Bus

Bus d’Interconnexion (Bus Matrix)

I-Code Bus D-Code Bus System Bus

Figure 1 : Le processeur Coretx-M3

Damergi Emir 1 Version 1.0

En plus du noyau, le Cortex-M3 comporte quelques périphériques:

2- Modes opératoires du Cortex-M3

Damergi Emir 2 Version 1.0

déclenchement d’une i nterruption. A la fin de l’ exécution d ’un Handler, le Cortex-M3 retourne en

Démarrage Interruption Fin Interruption Fin

Figure -2 : Transitions entre modes « Handler » et « thread »

Niveau « Unprivileged » si co ntrol [1 ] = 1 : Une a pplication a yant ce niveau a un certai n

Control [1] = 0 Control [1] =1

Exécution d’une ISR Mode Handler/Niveau Privilged Non autorisé

Exécution d’un programme

Tableau 1 : combinaisons possibles « mode Cortex/Niveau de privilège du code »

Damergi Emir 3 Version 1.0

Privileged / Handler Mode

Contrôle [1] = 0 Transition par software

Figure -3 : Transitions entre les combinaison « modes Cortex/ niveaux de privilège »

Damergi Emir 4 Version 1.0

Le noyau du Cortex-M3 contient un ensemble de registres divisés en deux groupes :

L’exemple suivant m ontre le fonctionnement de ces deux registres LR et PC. Considérons le

Figure -4 : Exemple de programme avec saut

Damergi Emir 5 Version 1.0

Tableau -2 : Evolution des contenus des registres LR et PC

Les registres spéciaux

31 30 29 28 27 26 :25 24 23 :20 19 :16 15 :10 9 8 7 6 5 4 :0

N Z C V Q ICI/IT T ICI/IT Exception Number

Figure -4 : Structure des registres d’état combinés ( xPSR)

Damergi Emir 6 Version 1.0