Cours 3

Gestion du temps
CHIRAZ TRABELSI
[email protected]
SYS3046-Microcontrôleurs : périphériques et applications – 3A-S2

Implémentation de l’horloge
• Le fonctionnement d’un microcontrôleur /microprocesseur est cadencé par une horloge
• Il y a différentes façons pour implémenter une horloge
1) Un cristal (quartz)
• Soumis à un champ électrique, le quartz vibre avec une fréquence stable et permet de générer un
signal électrique périodique
• Ce signal périodique peut servir d’horloge pour un microcontrôleur/microprocesseur
La carte STM32L053R8 contient deux quartz externes
• Un quartz haute fréquence (HSE: High-Speed External) de 8MHz
• Un quartz basse fréquence (LSE: Low-Speed External) de 32.768KHz
2
1) Un cristal (quartz)
• Taux d’erreur dans un quartz
• Exemple: 20ppm (parts per million) +/- 20 impulsions par million = 0.002%
• Erreur pour une fréquence de 8MHz ≈ 10 min/an
3
2) Un oscillateur RC
C’est un oscillateur utilisé généralement comme horloge interne pour les microcontrôleurs et contient
essentiellement, des condensateurs, résistances et amplificateurs
La carte STM32l053 a des oscillateurs internes

• HSI16: (High-Speed Internal) avec une fréquence de 16MHz
• MSI (MultiSpeed Internal) avec des fréquences variables de 65 kHz à 4.2 MHz
• HSI48: (High-Speed Internal) avec une fréquence de 48MHz (utilisée pour l’USB)
• LSI (LowSpeed Internal) avec une fréquence de 37 kHz
4
2) Un oscillateur RC
• Taux d’erreur pour HSI16=1%

• Erreur ≈ 18.2625 jours/an (f=16MHz)
 Si on a besoin d’une précision dans le temps, il faut privilégier l’utilisation d’un quartz comme source
d’horloge, mais il ne faut pas oublier qu’un quartz consomme plus d’espace.
5
3) Le PLL (phase locked loop)

C’est un montage permettant de multiplier/diviser la fréquence d’horloge en entrée pour en générer une
autre
• Pour la carte STM32l053, le PLL peut alimenter:

• L’horloge du système (32MHz au maximum)
• L’USB (48MHz)
• Le générateur de nombres aléatoires (48MHz)
6
• Il y a 4 sources différentes pour l’horloge du système

• HSI16: (high-speed internal) horloge interne avec une fréquence de 16MHz
• HSE: (high-speed external) horloge externe haute-vitesse
• MSI (multispeed internal) horloge interne multi-vitesses
• Horloge PLL
7
Configuration de l’horloge
• Pour avoir une fréquence de 16MHz, deux possibilités:
1) Activer HSI16
2) Utiliser le PLL à partir de HSE
8
L’arbre de l’horloge (Clock Tree)
• Les horloges des bus de communication

• Le microcontrôleur permet d’activer selon les
besoins les horloges des composants pour minimiser
la consommation d’énergie
• Les horloges de chaque bus sont gérées par un
registre du RCC (Reset and Clock Control)
• Le bus système
• Le bus AHB: Advanced High performance bus c
• Le bus APB1: Advanced Peripheral Bus1
• Le bus APB2: Advanced Peripheral Bus2
• Les ports GPIO
Exemple: Si on veut activer l’horloge pour le timer TIM2, il

faut l’activer dans le registre du RCC qui gère le bus APB1,
pour le timer TIM21 ça sera sur le registre qui gère le bus
9
APB2 SYS3046-Microcontrôleurs : périphériques et applications – 3A-S2
L’arbre de l’horloge (Clock Tree)
• Les horloges des bus de communication

• On peut appliquer des diviseurs de fréquence (Prescalers) pour avoir des fréquences inférieures aux
fréquences de bases
10
• Résumé
• Deux implémentations
• Quartz externe: plus précis
• Oscillateur interne: moins précis
• La carte STM32L0 fournit des quartz/oscillateurs hautes et basses fréquences
• Si on veut que la fréquence de l’horloge du système soit différente de celle du quartz/oscillateur  il

faut passer par le PLL (phase locked loop)
• Si on veut qu’un composant (Timer, convertisseur, etc.) ait une fréquence d’horloge inférieure à celle
du système, il faut passer par un prescaler
• On peut activer à la main les horloges des différents composants du système à travers le module RCC
(Reset and Clock Control) pour réduire la consommation d’énergie. Chaque bus du système (GPIO,
AHB, APB1, APB2, …) a un registre auprès du RCC qui permet d’activer l’horloge pour les
composants qui y sont connectés.
11
Implémenter des temps d’attente
• Il y a deux façons pour implémenter des temps d’attente
• Utiliser des temporisateurs logiciels: des boucles

• Cette solution n’est pas optimisée en termes de consommation d’énergie
• Elle pourrait être utile si tous les timers matériels du système sont occupés à faire d’autres
temporisations ou si on ne peut pas accéder à un temporisateur matériel à un moment donné
• Utiliser des temporisateurs matériels: des timers matériels (des compteurs matériels) qui peuvent
s’incrémenter sans l’intervention du processeur
12
Implémentation logicielle du temps d’attente
• Version en langage C
void delay_ms(uint32_t nb_ms){ • Pour déterminer le nombre d’itérations nécessaires

uint i,j; dans la boucle interne, on peut choisir une valeur
for(i=0;i<nb_ms;i++) quelconque, pour la modifier par la suite en fonction
for(j=0;j<1000;j++); du code machine généré par le compilateur
}
int main(void) • En analysant le code assembleur après compilation,
{ on se rend compte qu’une itération dans la boucle
//configuration de la fréquence à 16MHz
….. interne prend 16 cycles  pour avoir une attente
d’1ms il faut répéter la boucle 1000 fois (pour une
//configuration de la led LD2 fréquence de 16MHz), c’est pour cette raison on a
RCC->IOPENR|=RCC_IOPENR_GPIOAEN;
GPIOA->MODER&=~(0b11<<(5*2));
pu approximer et choisir de répéter la boucle 1000
GPIOA->MODER|=(0b01<<(5*2)); fois
while(1){ • Attention cette méthode peut ne pas marcher si vous

GPIOA->ODR |=(1<<5);
delay_ms(1000); activez l’optimisation pour le compilateur
GPIOA->ODR &=~(1<<5);
delay_ms(1000); • Dans ce cas le compilateur va optimiser les boucles
}}
qui ne font rien et donc les supprimer
13
• Version en langage C
• Solution: déclarer la variable j comme volatile,
void delay_ms(uint32_t nb_ms){ cela permet de dire au compilateur que la variable
uint32_t I; j peut être accessible à tout moment par un
volatile uint32_t j; Le nombre
for(i=0;i<nb_ms;i++) d’instructions machines système externe (système d’exploitation,
for(j=0;j<1230;j++); qui implémentent une interruption, etc.) ce qui l’empêche de l’optimiser
}
itération change si vous
int main(void) activez l’optimisation
{
……
//configuration de la led LD2

GPIOA->MODER&=~(0b11<<(5*2));
GPIOA->MODER|=(0b01<<(5*2));
while(1){
delay_ms(1000);
GPIOA->ODR &=~(1<<5);
delay_ms(1000);
}}
14
• Version en assembleur
void delay_ms(uint32_t nb_ms); .global delay_ms
.syntax unified
int main(void) .data
{ n: .word 5333
…… .text
delay_ms:
//configuration de la led LD2 push {lr}
GPIOA->MODER&=~(0b11<<(5*2)); boucle1:
GPIOA->MODER|=(0b01<<(5*2)); //charger la valeur de n (5333) dans le registre r1
ldr r2, =n
while(1){ ldr r1,[r2]
GPIOA->ODR |=(1<<5); boucle2:
delay_ms(1000); subs r1,#1
GPIOA->ODR &=~(1<<5); bne boucle2
delay_ms(1000); //decrementer la valeur de r0 (nombre de ms)
}} subs r0,#1
bne boucle1
La boucle interne boucle 2 prend
pop {pc}
3 cycles d’horloge
 Il faut la répéter 5333 fois pour
implémenter 1ms avec une
fréquence de 16MHz 15
Les temporisateurs matériels (Timers)
• Dans les librairies LL, il y a une fonction déjà existante qui s’appelle LL_mdelay(). Elle permet de faire un
délai en ms et elle utilise un timer matériel:
#include "stm32l053xx.h"
#include "stm32l0xx_ll_utils.h“ /*c’est le fichier qui contient la definition de LL_mDelay()*/
int main(void)
{
….
LL_Init1msTick(16000000);/*cet appel permet de calculer, à partir de la fréquence d’horloge passée

en paramètre, combien de ticks d’horloge sont nécessaires pour faire 1ms*/

…..
//faire clignoter la led

while(1){
LL_mDelay(1000);
GPIOA->ODR &=~(1<<5);
LL_mDelay(1000);
}
}
16
• La fonction LL_mdelay() utilise le timer du système Systick

• Un timer est un module matériel qui contient un compteur/décompteur
• Le Systick compte à rebours à partir de la valeur qu’il a dans son registre LOAD (24 bits au
maximum)
• Quand il atteint la valeur 0, il met à jour un flag dans son registre d’état CTRL et se remet de nouveau
à décompter à partir de la valeur qui est dans son registre LOAD
• Exercice: Pour une fréquence de 16MHz, quelle serait la valeur du registre LOAD pour faire 1ms quand
le compteur atteint 0? 17
• Pour une fréquence de 16MHz,

Quelle serait la valeur du registre
LOAD pour faire 1ms quand le
compteur atteint 0?
F=16MHz  pour faire 1ms il faut

faire 16000 cycles d’horloge, pour
cela il faut charger dans le registre
LOAD du timer la valeur 16000-
1=15999
18
• Pour cette raison, la fonction LL_Init1msTick charge dans le register LOAD du compteur la valeur de la
fréquence/1000-1
void LL_Init1msTick(uint32_t HCLKFrequency)
{
/* Use frequency provided in argument */
LL_InitTick(HCLKFrequency, 1000U);
}
__STATIC_INLINE void LL_InitTick(uint32_t HCLKFrequency,

uint32_t Ticks)
{
/* Configure the SysTick to have interrupt in 1ms time base*/
/* set reload register */
SysTick->LOAD = (uint32_t)((HCLKFrequency / Ticks) - 1UL);
/* Load the SysTick Counter Value */
SysTick->VAL = 0UL;
Source: STM32L0 Series Cortex®-M0+ programming manual
/* Enable the Systick Timer */
SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk |
SysTick_CTRL_ENABLE_Msk;}
19
• La fonction LL_mDelay()
void LL_mDelay(uint32_t Delay)

{
…… • A chaque fois que le compteur atteint 0, le flag
COUNTFLAG se met à 1 (le compteur vient de
while (Delay) faire 1ms)
{
if ((SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk) != 0U)
{ • La lecture du registre CTRL permet de remettre
Delay--; ce flag à 0
}
}
} • Le compteur du nombre de ms peut être alors
décrémenté
20
• Autre que le timer du système (Systick), le microcontrôleur contient les timers TIM2, TIM21, TIM 22,
TIM6 et TIM7
Source: STM32L053C6 STM32L053C8 STM32L053R6 STM32L053R8 -- Ultra-low-power 32-bit MCU

Arm®-based Cortex®-M0+
• A la différence de Systick qui contient un registre de recharge de

24bits, les autres timers sont sur 16-bits et sont donc capables de
compter jusqu’à 65536
• TIM2, TIM21 et TIM22 sont capables de fonctionner en mode

PWM, ce n’est pas le cas pour TIM6 et TIM7
• TIM6 et TIM7 sont essentiellement utilisés avec le convertisseur

DAC 21
• Deux principales configurations à faire pour un timer:
1) Direction: compteur/décompteur
2) La valeur de recharge (auto-reload)
22
• Deux principales configurations à faire pour un timer:
1) Direction: compteur/décompteur
Source : RM0367 Reference manual -- Ultra-low-power STM32L0x3 advanced ARM®-based 32-bit MCUs
23
• Deux principales configurations à faire pour un timer: Source : RM0367 Reference manual -- Ultra-low-power STM32L0x3 advanced ARM®-based 32-bit MCUs
2) La valeur de recharge (auto-reload)
En mode décomptage En mode comptage

24
• Deux façons pour détecter le débordement d’un timer
1) Le bit UIF du registre SR

• Il se met à 1 s’il y a débordement ou si la valeur du
compteur a été réinitialisée
• Il est remis à 0 par le logiciel
25
• Deux façons pour détecter le débordement d’un timer
2) Si le timer est configuré pour fonctionner une seule fois

et s’arrêter après (OPM=1 dans le registre CR1), s’il y a
débordement il se désactive automatiquement, il faut le
réactiver (CEN=1 dans le registre CR1)
26
• Implémentation d’un temps d’attente en ms en utilisant le timer TIM22

int main(void)
• 1ère méthode avec le flag UIF {
void delay_ms(uint32_t nb_ms) //configuration de la fréquence à
{ 16MHz
….
//lancement du timer
TIM22->CR1|=TIM_CR1_CEN_Msk; /*activation de l'horloge pour le
while(nb_ms){ timer22 (sur le bus APB2)*/
if (TIM22->SR & TIM_SR_UIF) { // si le bit UIF=1 RCC->APB2ENR |= RCC_APB2ENR_TIM22EN;
TIM22->SR = TIM22->SR & ~TIM_SR_UIF_Msk; /*remettre UIF à 0*/
nb_ms--; //configuration du timer en décompteur
}} TIM22->CR1|=TIM_CR1_DIR_Msk;
//désactivation du timer //chargement de la valeur d'auto-

TIM22->CR1&=~TIM_CR1_CEN_Msk; reload
TIM22->ARR=15999;
}
……
while(1){
delay_ms(1000);
GPIOA->ODR &=~(1<<5);
delay_ms(1000);
}}
27
• Implémentation d’un temps d’attente en ms en utilisant le timer TIM22

• 2ème méthode avec le mode One-pulse /*activation de l'horloge pour le
timer22 (sur le bus APB2)*/
void delay_ms(uint32_t nb_ms)
RCC->APB2ENR |= RCC_APB2ENR_TIM22EN;
{
//configuration du timer en décompteur
TIM22->CR1|=TIM_CR1_DIR_Msk;
TIM22->CR1|=TIM_CR1_CEN_Msk;
//configuration en one-pulse
while(nb_ms){
TIM22->CR1|=TIM_CR1_OPM_Msk;
if ((TIM22->CR1 & TIM_CR1_CEN)==0) {/*si le CEN=0 (le timer s’est
désactivé)*/
//chargement de la valeur d'auto-
TIM22->CR1|=TIM_CR1_CEN_Msk;//réactiver le timer
reload
nb_ms--;
TIM22->ARR=15999;
}
}
…..
//désactivation du timer
TIM22->CR1&=~TIM_CR1_CEN_Msk;
while(1){
}
delay_ms(1000);
int main(void)
GPIOA->ODR &=~(1<<5);
{
delay_ms(1000);
}}
….
28
• Implémentation d’un temps d’attente en secondes en utilisant le timer TIM22
• Pour une fréquence de 16MHz, 1s demanderait 16000000 ticks d’horloge, ce nombre étant trop grand
pour être chargé dans le registre ARR (limité à 16 bits)
 La solution et d’utiliser un diviseur de fréquence pour le Timer (Prescaler)
29
• Implémentation d’un temps d’attente en secondes en utilisant le timer TIM22
• Pour avoir 1s comme période pour un cycle de comptage (fréquence=1Hz), il faut diviser la fréquence
d’horloge principale par 16 000 000
• Ce diviseur peut être réparti entre le registre ARR et le registre PSC

• fréquence désirée= fréquence (horloge) / [(PSC+1) x (ARR+1)]
• Exemple: PSC=999 et ARR=15999  l’horloge du timer est 16MHz/1000= 16KHz  un cycle de

comptage=(15999+1)/16KHz= 1s
30
• Implémentation d’un temps d’attente en secondes en utilisant le timer TIM22 (Utilisation de Prescaler)
void delay_s(uint32_t nb_s) /*activation de l'horloge pour le timer22 (sur le bus
{ APB2)*/
TIM22->CR1|=TIM_CR1_CEN_Msk; //configuration du timer en décompteur
while(nb_s){
if (TIM22->SR & TIM_SR_UIF) { // Scrutation de UIF //chargement de la valeur d'auto-reload
TIM22->SR = TIM22->SR & ~TIM_SR_UIF_Msk; TIM22->ARR=15999;
nb_s--; //chargement de la valeur du prescaler

}} TIM22->PSC=999;
//désactivation du timer //configuration de la led LD2

TIM22->CR1&=~TIM_CR1_CEN_Msk; ….
}
while(1){
int main(void) GPIOA->ODR |=(1<<5);
{ delay_s(1);
//configuration de la fréquence à 16MHz GPIOA->ODR &=~(1<<5);
…. delay_s(1);
}}
31
• Utilisation des interruptions

• Comment ça marche?
• Au moment du débordement, le timer informe le microcontrôleur qu’il y a eu un
évènement, le microcontrôleur interrompt ce qu’il était en train de faire pour gérer le code
lié à l’interruption
• Avantages:
• Si on veut implémenter une tâche synchronisée par un timer (exemple clignotement d’une led)
et faire d’autres tâches en parallèle, le mieux c’est de gérer le timer par interruption
• Exemples:
• Deux leds qui clignotent selon deux rythmes différents avec d’autres tâches en parallèle
• Un Timer de Timeout pour un jeu
32

• Pour gérer les interruptions, le microcontrôleur dispose d’un gestionnaire d’interruption (le NVIC:
Nested vectored interrupt controller) dont le rôle est d’associer à chaque interruption sa fonction de
traitement.
• Chaque interruption a son vecteur d’interruption (une adresse de l’instruction à exécuter si
l’interruption en question se produit)
Exemple: Si on appuie sur le bouton

Reset, c’est le code à l’adresse
0x0000 0004 qui sera exécuté
Source : RM0367 Reference manual -- Ultra-low-power STM32L0x3 advanced ARM®-based 32-bit MCUs 33
En plus des 16 interruptions de base du

microcontrôleur (en gris),
Il y a 39 autres canaux d’interruption gérés par le
NVIC (Nested vectored interrupt controller )
C’est le module NVIC qui permet de gérer des

interruptions provenant des boutons, des
timers, des communications série, etc.
Exemple de vecteurs d’interruption pour les

timers
• Pour les projets sous STM32CubeIDE, les vecteurs d’interruptions sont disponibles dans le fichier
startup/startup_stm32l053r8tx.s
Exemple: pour une interruption générée par le timer

g_pfnVectors:
.word _estack TIM22, c’est la routine void TIM22_IRQHandler(void)
.word Reset_Handler qui sera utilisée
……….
.word SysTick_Handler
……….
.word EXTI0_1_IRQHandler /* EXTI Line 0 and 1 */
.word EXTI2_3_IRQHandler /* EXTI Line 2 and 3 */
.word EXTI4_15_IRQHandler /* EXTI Line 4 to 15 */
…………
.word TIM2_IRQHandler /* TIM2 */
.word 0 /* Reserved */
.word TIM6_DAC_IRQHandler /* TIM6 and DAC */
…………
35

• Ce qu’il faut faire:
1) Activer l’interruption pour le timer
Il faut mettre à 1 le bit UIE du registre DIER du timer
2) Activer l’interruption pour le contrôleur NVIC
NVIC_EnableIRQ(TIM22_IRQn);
36

• Ce qu’il faut faire:
3) Ecrire le code lié à l’interruption
void TIM22_IRQHandler(void) {
……..
TIM22->SR = TIM22->SR & ~TIM_SR_UIF_Msk; //Il ne faut pas oublier d’écraser le flag de l’interruption
}
Remarque: le flag UIF se

met à 1 à chaque
débordement que ce soit
l’interruption du timer est
activée ou pas. La
différence est que si
l’interruption est activée,
quand UIF se met à 1,
l’interruption se déclenche.
Exemple: Gestion du timer par interruption pour faire clignoter une led
void TIM22_IRQHandler(){ //activation de l'interruption sur le

TIM22->SR = TIM22->SR & ~TIM_SR_UIF_Msk; timer
GPIOA->ODR ^=(1<<5); TIM22->DIER|=TIM_DIER_UIE_Msk;
}
//activation de l'interruption dans le
int main(void) contrôleur NVIC
{ NVIC_EnableIRQ(TIM22_IRQn);
…. //configuration de la led LD2
…..
/*activation de l'horloge pour le timer22 (sur
le bus APB2)*/ //lancement du timer
RCC->APB2ENR |= RCC_APB2ENR_TIM22EN; TIM22->CR1|=TIM_CR1_CEN_Msk;
while(1){
TIM22->CR1|=TIM_CR1_DIR_Msk; }
}
//chargement de la valeur d'auto-reload
TIM22->ARR=15999;
//chargement de la valeur du prescaler

TIM22->PSC=999;
38
• L’attente non-bloquante
• Pour faire des tâches en parallèle
• Par exemple: si on a une tâche périodique T1 qui se déclenche toutes les n1 secondes à
gérer par un timer et qu’en parallèle on veut faire d’autres tâches
• 1ère méthode: sans interruption

• Exécuter T1
• On lance le timer pour compter n1 secondes
• Dans la boucle infinie du main, on fait les autres tâches et avant de boucler on attend le
débordement du timer
• Si les autres tâches dans la boucle infinie du main demandent moins de temps que n1
secondes  aucun problème
• Sinon, la période de la tâche T1 sera affectée
• 2ème méthode: avec les interruptions

• Cette méthode permet de respecter la périodicité des tâches
39
• Par exemple: si on a une tâche périodique T1 à gérer par un timer et qu’en parallèle on veut
faire d’autres tâches
• 1ère méthode: sans interruption while(1){
/****Exécution de T1:inverser la led toutes les
int main(void) secondes****/
{ GPIOA->ODR ^=(1<<5);
//configuration de la fréquence à 16MHz /***lancement de l’attente non-bloquante pour
…. 1000ms***/
/*activation de l'horloge pour le timer22 (sur le bus //lancement du timer

APB2)*/ TIM22->CR1|=TIM_CR1_CEN_Msk;
/****d'autres tâches*******/
……
while ((TIM22->SR & TIM_SR_UIF)==0);
TIM22->SR = TIM22->SR & ~TIM_SR_UIF_Msk;}
TIM22->PSC=999;
}
TIM22->ARR=16000-1;

….
40
• Par exemple: si on a une tâche périodique T1 à gérer par un timer et qu’en parallèle on veut
faire d’autres tâches
• 1ère méthode: sans interruption while(1){
/****Exécution de T1:inverser la led toutes les
secondes****/
• Inconvénient: GPIOA->ODR ^=(1<<5);
• Si les autres tâches dans la boucle /***lancement de l’attente non-bloquante pour
1000ms***/
infinie du main demandent plus de
temps que la période du timer de la //lancement du timer
tâche périodique T1, cette période sera
impactée /****d'autres tâches*******/
……
while ((TIM22->SR & TIM_SR_UIF)==0);

TIM22->SR = TIM22->SR & ~TIM_SR_UIF_Msk;}
}
41
• 2ème méthode: avec interruption
void TIM22_IRQHandler(){
//activation de l'interruption sur le timer
TIM22->SR = TIM22->SR & ~TIM_SR_UIF_Msk;
TIM22->DIER|=TIM_DIER_UIE_Msk;
/****Exécution de T1:inverser la led toutes
les secondes****/
//activation de l'interruption dans le contrôleur NVIC
GPIOA->ODR ^=(1<<5);
NVIC_EnableIRQ(TIM22_IRQn);
}
int main(void)
{
….
….
/*activation de l'horloge pour le timer22
(sur le bus APB2)*/
while(1){
/****d'autres tâches
*
*
******/
}
}
TIM22->ARR=16000-1;

TIM22->PSC=999;
42
L’horloge RTC
• Real-Time Clock
• Elle agit comme un compteur/timer BCD indépendant
• Utilisations
• Régler l’heure et la date
• Réveiller le système d’une manière périodique pour le sortir du mode basse-consommation
pour effectuer des tâches périodiques et retourner en mode basse-consommation
• Déclencher une alarme à une date et/ou heure précise
• Etc.
43
L’horloge RTC
44
L’horloge RTC
• Parfois, on a besoin d’un module RTC externe au microcontrôleur pour maintenir le comptage même si le
microcontrôleur n’est plus alimenté. Dans ce cas, le module RTC est alimenté par batterie.
45

Cours 3

Transféré par

Informations du documentcliquez pour développer les informations du document

Droits d'auteur :

Formats disponibles

Cours 3

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours 3

Transféré par

Droits d'auteur :

Formats disponibles

Gestion du temps

SYS3046-Microcontrôleurs : périphériques et applications – 3A-S2

La carte STM32l053 a des oscillateurs internes

• Taux d’erreur pour HSI16=1%

3) Le PLL (phase locked loop)

• Pour la carte STM32l053, le PLL peut alimenter:

• Il y a 4 sources différentes pour l’horloge du système

• Pour avoir une fréquence de 16MHz, deux possibilités:

2) Utiliser le PLL à partir de HSE

• Les horloges des bus de communication

• Le bus AHB: Advanced High performance bus c

• Le bus APB1: Advanced Peripheral Bus1

• Le bus APB2: Advanced Peripheral Bus2

• Les ports GPIO

Exemple: Si on veut activer l’horloge pour le timer TIM2, il

• Les horloges des bus de communication

• La carte STM32L0 fournit des quartz/oscillateurs hautes et basses fréquences

• Si on veut que la fréquence de l’horloge du système soit différente de celle du quartz/oscillateur  il

• Il y a deux façons pour implémenter des temps d’attente

• Utiliser des temporisateurs logiciels: des boucles

void delay_ms(uint32_t nb_ms){ • Pour déterminer le nombre d’itérations nécessaires

while(1){ • Attention cette méthode peut ne pas marcher si vous

//configuration de la led LD2

LL_Init1msTick(16000000);/*cet appel permet de calculer, à partir de la fréquence d’horloge passée

//configuration de la led LD2

//faire clignoter la led

• La fonction LL_mdelay() utilise le timer du système Systick

• Pour une fréquence de 16MHz,

F=16MHz  pour faire 1ms il faut

__STATIC_INLINE void LL_InitTick(uint32_t HCLKFrequency,

/* Load the SysTick Counter Value */

void LL_mDelay(uint32_t Delay)

Source: STM32L053C6 STM32L053C8 STM32L053R6 STM32L053R8 -- Ultra-low-power 32-bit MCU

• A la différence de Systick qui contient un registre de recharge de

• TIM2, TIM21 et TIM22 sont capables de fonctionner en mode

• TIM6 et TIM7 sont essentiellement utilisés avec le convertisseur

• Deux principales configurations à faire pour un timer:

2) La valeur de recharge (auto-reload)

• Deux principales configurations à faire pour un timer:

2) La valeur de recharge (auto-reload)

En mode décomptage En mode comptage

• Deux façons pour détecter le débordement d’un timer

1) Le bit UIF du registre SR

• Deux façons pour détecter le débordement d’un timer

2) Si le timer est configuré pour fonctionner une seule fois

• Implémentation d’un temps d’attente en ms en utilisant le timer TIM22

//désactivation du timer //chargement de la valeur d'auto-

• Implémentation d’un temps d’attente en ms en utilisant le timer TIM22

• Implémentation d’un temps d’attente en secondes en utilisant le timer TIM22

 La solution et d’utiliser un diviseur de fréquence pour le Timer (Prescaler)

• Implémentation d’un temps d’attente en secondes en utilisant le timer TIM22

• Ce diviseur peut être réparti entre le registre ARR et le registre PSC

• Exemple: PSC=999 et ARR=15999  l’horloge du timer est 16MHz/1000= 16KHz  un cycle de

nb_s--; //chargement de la valeur du prescaler

//désactivation du timer //configuration de la led LD2

• Utilisation des interruptions

• Utilisation des interruptions

Exemple: Si on appuie sur le bouton