Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  6.9 :  Le  code  avant  la  fonction  main

Figure  6.10 :  Le  code  à  l'intérieur  de  la  boucle  while

Si,  comme  dans  la  figure  6.5,  nous  sélectionnons  le  compilateur  Keil  uVision  V5,  le  code  est  généré  dans  cet  
environnement  de  compilateur  et  nous  pouvons  ajouter  le  code  nécessaire  à  main.c  comme  indiqué  dans  les  
figures  6.11  et  6.12.

•  74
Machine Translated by Google

Chapitre  6  •  Convertisseurs  numérique­analogique  (DAC)  dans  les  microcontrôleurs  STM32

Figure  6.11 :  Le  code  avant  la  fonction  principale  dans  Keil  uVision

Figure  6.12 :  Le  code  à  l'intérieur  de  la  boucle  while  dans  Keil  uVision

6.4  •  Résumé

Les  convertisseurs  numérique­analogique  (DAC)  fonctionnent  de  manière  inverse  par  rapport  aux  
convertisseurs  analogique­numérique.  Ils  convertissent  une  valeur  numérique  en  un  signal  analogique.  Dans  
ce  chapitre,  nous  avons  activé  une  unité  DAC  et  généré  une  forme  d'onde,  puis  l'avons  affichée  sur  un  oscilloscope.

•  75
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Chapitre  7  •  Temporisateurs  et  compteurs  dans  les  microcontrôleurs  STM32

7.1  •  Présentation

Les  temporisateurs  et  les  compteurs  sont  les  sections  les  plus  importantes  d'un  microcontrôleur  et  jouent  un  rôle  
essentiel  dans  la  synchronisation  et  le  fonctionnement.  L'utilisation  d'une  fonction  de  retard  dans  un  programme  
entraîne  l'arrêt  de  l'exécution  du  programme.  Ce  n'est  pas  une  technique  recommandable  dans  un  programme  
professionnel.  En  utilisant  des  minuteries,  tous  les  retards  sont  omis  du  programme.  Tous  les  horaires  et  retards  
(sans  arrêter  le  programme)  sont  gérés  par  un  temporisateur  qui  fonctionne  en  parallèle  avec  le  processeur.  Un  
temporisateur  est  un  compteur  qui  peut  compter  les  impulsions  régulières  d'un  oscillateur  et  générer  des  temps  réguliers.
Ce  compteur  peut  compter  les  impulsions  externes  qui  sont  appliquées  au  microcontrôleur.  Le  microcontrôleur  
STM32F103RET6  dispose  de  8  temporisateurs.

7.2  •  Paramètres  du  projet  de  minuterie

Nous  allons  piloter  2  temporisateurs  de  250  ms  et  1  s  respectivement  et  compter  une  variable  avec  chacun  d'eux  et  
l'afficher  sur  un  écran  LCD.  La  conduite  des  autres  minuteries  est  similaire.  À  cette  fin,  conformément  à  la  Figure  7.1  
dans  la  section  des  temporisateurs  et  la  sous­section  TIM1,  la  source  d'horloge  est  définie  comme  l'horloge  interne.  
Dans  la  section  des  paramètres  de  paramètres,  nous  définissons  le  prédiviseur  sur  7999  et  la  période  du  compteur  
sur  249.  Ensuite,  à  partir  de  la  section  Paramètres  NVIC,  nous  activons  l'interruption  de  mise  à  jour  TIM1,  comme  
illustré  à  la  Figure  7.2.

Figure  7.1 :  Activation  de  l'unité  TIM1

•  76
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  7.2 :  Activation  de  l'interruption  de  mise  à  jour  TIM1

Pour  activer  TIM6,  nous  sélectionnons  l'icône  activée.  Dans  la  section  des  réglages  des  paramètres,  nous  avons  
également  défini  le  prescaler  sur  7999  et  la  période  du  compteur  sur  999,  comme  illustré  à  la  Figure  7.3.  Ensuite,  à  
partir  de  la  section  des  paramètres  NVIC,  nous  activons  l'interruption  globale  TIM6,  comme  illustré  à  la  figure  7.4.

Figure  7.3 :  Activation  de  l'unité  TIM6

•  77
Machine Translated by Google

Chapitre  7  •  Temporisateurs  et  compteurs  dans  les  microcontrôleurs  STM32

Figure  7.4 :  Activation  de  l'interruption  globale  TIM6

Nous  activons  également  les  broches  du  microcontrôleur  liées  à  la  commande  de  l'écran  LCD  et  du  résonateur  à  
cristal  externe,  comme  mentionné  dans  les  chapitres  précédents.  La  section  de  configuration  de  l'horloge  est  
illustrée  à  la  Figure  7.5.  Comme  illustré  à  la  Figure  7.5,  les  fréquences  des  horloges  APB1  (TIM6)  et  APB2  Timer  
(TIM1)  sont  sélectionnées  à  8  MHz.  Pour  générer  des  interruptions  TIM1  toutes  les  250  ms,  sélectionnez  la  valeur  
de  prédiviseur  égale  à  7999  pour  diviser  la  fréquence  de  8  MHz  de  TIM1  à  8000  (de  0  à  7999)  pour  produire  une  
fréquence  de  1  kHz  avec  une  période  de  1  ms.  Pour  Counter  Period,  sélectionnez  249  (de  0  à  249)  pour  générer  
250  ms.  De  même,  pour  générer  des  interruptions  TIM6  toutes  les  1  s,  sélectionnez  la  valeur  Prescaler  égale  à  
7999  pour  diviser  la  fréquence  de  8  MHz  de  TIM6  à  8000  (de  0  à  7999)  pour  produire  une  fréquence  de  1  kHz  
avec  une  période  de  1  ms.  De  plus,  pour  Counter  Period,  sélectionnez  999  (de  0  à  999)  pour  générer  des  1.  Pour  
déterminer  la  priorité  d'interruption  à  partir  de  la  section  de  configuration  NVIC,  sélectionnez  1  pour  TIM1  et  2  
pour  la  priorité  de  préemption  TIM6,  comme  illustré  à  la  Figure  7.6.

Figure  7.5 :  La  section  Configuration  de  l'horloge

•  78
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  7.6 :  Section  des  paramètres  NVIC

Après  avoir  saisi  les  paramètres  ci­dessus,  sélectionnez  SW4STM32  dans  l'onglet  Project  Manager  
et  générez  le  code  comme  illustré  à  la  Figure  7.7.

Figure  7.7 :  sélection  de  SW4STM32  comme  compilateur

•  79
Machine Translated by Google

Chapitre  7  •  Temporisateurs  et  compteurs  dans  les  microcontrôleurs  STM32

Le  code  d'en­tête  du  fichier  main.c  est  illustré  à  la  Figure  7.8.  De  plus,  le  corps  des  fonctions  MX_TIM1_Init  et  
MX_TIM6_Init  sont  représentés  respectivement  dans  la  Figure  7.9  et  la  Figure  7.10.

Figure  7.8 :  Le  code  d'en­tête  du  fichier  main.c

Figure  7.9 :  Le  corps  de  la  fonction  MX_TIM1_Init

•  80
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  7.10 :  Le  corps  de  la  fonction  MX_TIM6_Init

Les  fonctions  liées  à  l'unité  Timer  se  trouvent  dans  le  fichier  stm32f1xx_hal_tim.c,  comme  illustré  à  la  Figure  
7.11.  Les  fonctions  de  service  d'interruption  pour  les  interruptions  de  minuterie  se  trouvent  dans  le  fichier  
stm32f1xx_it.c,  comme  illustré  à  la  Figure  7.12.

•  81
Machine Translated by Google

Chapitre  7  •  Temporisateurs  et  compteurs  dans  les  microcontrôleurs  STM32

Figure  7.11 :  Les  fonctions  de  la  minuterie  dans  le  fichier  stm32f1xx_hal_tim.c

Figure  7.12 :  Fonctions  d'interruption  du  temporisateur  dans  le  fichier  stm32f1xx_it.c

•  82
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Comme  mentionné  précédemment,  nous  allons  piloter  deux  temporisateurs  (TIM1  et  TIM6)  et  générer  une  
interruption  de  250  ms  avec  TIM1  et  une  interruption  de  1  s  avec  TIM6,  puis  compter  une  variable  avec  
chaque  temporisateur  et  l'afficher  sur  un  écran  LCD.  Les  codes  avant  la  fonction  principale  sont  illustrés  
à  la  Figure  7.13.

Figure  7.13 :  Le  code  avant  la  fonction  main

Le  code  à  l'intérieur  de  la  boucle  while  est  illustré  à  la  Figure  7.14.  Le  code  d'en­tête  du  fichier  
stm32f1xx_it.c  est  illustré  à  la  Figure  7.15.

Figure  7.14 :  Le  code  à  l'intérieur  de  la  boucle  while

•  83
Machine Translated by Google

Chapitre  7  •  Temporisateurs  et  compteurs  dans  les  microcontrôleurs  STM32

Figure  7.15 :  Le  code  d'en­tête  du  fichier  stm32f1xx_it.c

La  fonction  d'exécution  des  codes  d'utilisateur  à  l'aide  de  la  fonction  HAL_TIM_PeriodElapsedCallback  (dans  le  
fichier  stm32f1xx_hal_tim.c)  qui  est  copiée  dans  le  fichier  stm32f1xx_it.c  est  illustrée  à  la  Figure  7.16.

Figure  7.16 :  La  fonction  d'exécution  des  codes  d'utilisateur  copiés  dans  le  fichier  stm32f1xx_it.c

Nous  pouvons  ensuite  compiler  le  projet  en  cliquant  avec  le  bouton  droit  sur  le  nom  du  projet  et  en  sélectionnant  
l'icône  'build  project'  comme  illustré  à  la  Figure  7.17.

•  84
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  7.17 :  Compilation  du  projet

Une  fois  le  projet  compilé  avec  succès,  le  fichier  hexadécimal  généré  pour  la  programmation  du  
microcontrôleur  se  trouvera  dans  le  dossier  de  débogage,  comme  illustré  à  la  figure  7.18.

Figure  7.18 :  Le  fichier  hexadécimal  généré  dans  le  dossier  Debug

•  85
Machine Translated by Google

Chapitre  7  •  Temporisateurs  et  compteurs  dans  les  microcontrôleurs  STM32

7.3  •  Paramètres  du  projet  de  compteur

Les  temporisateurs  sont  des  compteurs  qui  comptent  les  impulsions  régulières  d'un  oscillateur.  Les  temporisateurs  
peuvent  également  compter  les  impulsions  appliquées  de  manière  externe  à  une  broche.  Dans  ce  cas,  la  minuterie  
est  appelée  un  compteur.  Nous  voulons  activer  l'unité  TIM1  en  tant  que  compteur  d'impulsions  externes  et  la  
connecter  à  une  broche  par  un  bouton­poussoir  et  l'exciter  avec  des  impulsions  à  front  montant,  en  les  comptant  
avec  une  variable  associée  au  compteur,  puis  en  l'affichant  sur  un  écran  LCD.  À  cette  fin,  conformément  à  la  Figure  
7.19  de  la  section  Pinout  &  Configuration  et  de  la  sous­section  TIM1,  réglez  le  mode  esclave  sur  External  Clock  
Mode  1  et  Trigger  Source  sur  TI1FP1,  puis  activez  les  broches  liées  à  la  commande  de  l'écran  LCD  sur  GPIO_Output.  
Activez  également  les  broches  du  résonateur  à  cristal  externe.  À  partir  des  réglages  des  paramètres,  des  réglages  
tels  que  Prescaler  (0),  Counter  Mode  (Up),  Counter  Period  (65535  pour  une  valeur  de  16  bits),  Trigger  Polarity  
(Rising  Edge)  et  Trigger  Filter  (15)  sont  activés.  Dans  la  section  centrale  du  système  et  la  sous­section  TIM,  
définissez  le  pull­down  pour  le  mode  GPIO  (puisque  nous  avons  choisi  la  polarité  de  déclenchement  comme  front  
montant  auparavant),  comme  illustré  à  la  Figure  7.20.  Dans  la  section  centrale  du  système  et  la  sous­section  NVIC,  
activez  l'interruption  de  mise  à  jour  TIM1.  Lorsque  la  valeur  du  compteur  atteint  la  valeur  de  la  période  du  compteur,  
l'interruption  TIM1  est  activée.  Enfin,  nous  pouvons  générer  du  code  dans  l'environnement  logiciel  SW4STM32,  
comme  illustré  à  la  Figure  7.21.  Le  corps  de  la  fonction  MX_TIM1_Init  est  illustré  à  la  Figure  7.22.

Figure  7.19 :  Activation  de  TIM1  comme  compteur  externe

•  86
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  7.20 :  Réglage  déroulant  pour  le  mode  GPIO  du  TIM1

Figure  7.21 :  Le  code  d'en­tête  de  main.c

•  87
Machine Translated by Google

Chapitre  7  •  Temporisateurs  et  compteurs  dans  les  microcontrôleurs  STM32

Figure  7.22 :  Le  corps  de  la  fonction  MX_TIM1_Init

Figure  7.23 :  Macros  HAL_TIM_GET_COUNTER  et  HAL_TIM_SET_COUNTER  dans  le  fichier  stm32f1xx_hal_tim.h

Les  macros  HAL_TIM_GET_COUNTER  et  HAL_TIM_SET_COUNTER  dans  le  fichier  stm32f1xx_hal_tim.h  sont  
illustrées  à  la  Figure  7.23.  Nous  les  utiliserons  dans  l'exemple  suivant.  Puisque  nous  utilisons  la  bibliothèque  LCD  
dans  ce  projet,  ajoutez  le  dossier  LCD  (y  compris  les  fichiers  lcd.h  et  lcd.c)  à

•  88
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

le  dossier  Src  comme  illustré  à  la  Figure  7.24.  Cliquez  ensuite  avec  le  bouton  droit  sur  le  dossier  Src  et  
sélectionnez  Actualiser,  comme  illustré  à  la  Figure  7.25.  Le  code  précédant  la  fonction  main  du  fichier  main.c  est  
illustré  à  la  Figure  7.26.

Figure  7.24 :  Ajout  d'un  dossier  LCD  au  dossier  Src  du  projet

Figure  7.25 :  Actualisation  du  dossier  Src  du  projet

•  89
Machine Translated by Google

Chapitre  7  •  Temporisateurs  et  compteurs  dans  les  microcontrôleurs  STM32

Figure  7.26 :  Le  code  avant  la  fonction  main  du  fichier  main.c

Les  structures  initiales  pour  les  fonctions  LCD  et  TIM1  et  l'utilisation  des  macros  HAL_TIM_SET_COUNTER  et  
HAL_TIM_GET_COUNTER  avant  et  à  l'intérieur  de  la  boucle  while  sont  illustrées  à  la  Figure  7.27.
Nous  faisons  ensuite  un  clic  droit  sur  le  projet  et  sélectionnons  "build  project"  pour  compiler  le  projet  et  générer  le  
code  hexadécimal  pour  programmer  le  microcontrôleur.

Figure  7.27:  Le  code  à  l'intérieur  de  la  boucle  while  du  fichier  main.c

7.4  •  Résumé

Tous  les  horaires  et  les  retards  sans  arrêt  du  programme  sont  gérés  par  une  minuterie  qui  fonctionne  en  parallèle  
avec  le  processeur.  Un  temporisateur  est  un  compteur  qui  peut  compter  les  impulsions  régulières  d'un  oscillateur  
et  générer  des  temps  réguliers.  Ce  compteur  peut  compter  les  impulsions  externes  qui  sont  appliquées  au  
microcontrôleur.  Dans  ce  chapitre,  les  réglages  du  minuteur  et  du  compteur  de  projet  ont  été  expliqués  en  détail.

•  90
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Chapitre  8  •  Modulation  de  largeur  d'impulsion  (PWM)  dans  STM32
Microcontrôleurs

8.1  •  Présentation

La  modulation  de  largeur  d'impulsion  (PWM)  est  une  caractéristique  importante  des  microcontrôleurs  et  est  utilisée  
pour  la  transmission  de  données.  Il  peut  également  être  utilisé  pour  contrôler  la  puissance  des  appareils  en  modifiant  
la  largeur  d'impulsion  de  la  forme  d'onde.  La  durée  d'activation  d'une  forme  d'onde  est  appelée  le  rapport  cyclique  
qui  est  le  rapport  de  la  durée  d'activation  à  la  période  du  signal.  Il  est  généralement  déterminé  en  pourcentage.  
L'onde  PWM  est  générée  dans  des  unités  de  minuterie  qui  peuvent  produire  des  signaux  PWM.
Le  microcontrôleur  STM32F103RET6  dispose  de  8  unités  de  temporisation  dont  6  unités  peuvent  générer  des  
signaux  PWM.  Chaque  temporisateur  peut  produire  4  signaux  PWM  avec  une  résolution  de  16  bits.

8.2  •  Paramètres  du  projet  PWM

Dans  l'exemple  suivant,  nous  allons  activer  deux  temporisateurs  (TIM1  et  TIM4)  et  les  afficher  sur  un  oscilloscope  
avec  des  rapports  cycliques  différents.  Dans  la  section  Timers  et  la  sous­section  TIM1,  sélectionnez  la  source  
d'horloge  comme  horloge  interne  et  channel1  comme  PWM  Generation  CH1.  À  partir  des  paramètres  Paramètres,  
procédez  à  des  réglages  tels  que  Prescaler  (0)  afin  que  sa  valeur  maximale  pour  16  bits  soit  65535,  Counter  Mode  
(Up),  Counter  Period  (255)  comme  illustré  à  la  Figure  8.1.  La  fréquence  du  signal  PWM  est  calculée  comme  suit :

Figure  8.1 :  Paramètres  TIM1  pour  la  génération  de  signaux  PWM

•  91
Machine Translated by Google

Chapitre  8  •  Modulation  de  largeur  d'impulsion  (PWM)  dans  les  microcontrôleurs  STM32

Figure  8.2 :  Paramètres  du  TIM4  pour  la  génération  de  signaux  PWM

Étant  donné  que  les  fréquences  d'horloge  des  minuteries  APB1  et  APB2  sont  de  8  MHz,  la  fréquence  des  signaux  
PWM  sera  de  31,25  kHz.  De  même,  dans  la  section  des  minuteries  et  la  sous­section  TIM4,  sélectionnez  la  source  
d'horloge  comme  horloge  interne  et  Channel3  comme  PWM  Generation  CH3.  À  partir  des  réglages  de  paramètres,  
procédez  à  des  réglages  tels  que  Prescaler  (0)  de  sorte  que  le  maximum  pour  la  valeur  16  bits  soit  65535,  Counter  
Mode  (Up),  Counter  Period  (255)  comme  illustré  à  la  Figure  8.2.  Activez  également  les  broches  liées  au  résonateur  
à  cristal  externe,  comme  illustré  à  la  figure  8.3.

Figure  8.3 :  Activation  des  broches  de  résonateur  à  cristal  externe

Enfin,  à  partir  de  la  section  Project  Manager,  nous  pouvons  générer  du  code  dans  l'environnement  logiciel  
SW4STM32,  comme  illustré  à  la  Figure  8.4.  Le  corps  de  la  fonction  MX_TIM1_Init  est  illustré  à  la  Figure  8.5.  Le  
corps  de  la  fonction  MX_TIM4_Init  est  illustré  à  la  Figure  8.6.

•  92
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  8.4 :  Le  code  d'en­tête  du  fichier  main.c

Figure  8.5 :  Le  corps  de  la  fonction  MX_TIM1_Init

•  93
Machine Translated by Google

Chapitre  8  •  Modulation  de  largeur  d'impulsion  (PWM)  dans  les  microcontrôleurs  STM32

Figure  8.6 :  Le  corps  de  la  fonction  MX_TIM4_Init

Les  fonctions  Timer  se  trouvent  dans  le  fichier  stm32f1xx_hal_tim.c,  comme  illustré  à  la  Figure  8.7.  La  fonction  
HAL_TIM_PWM_Start  est  utilisée  pour  activer  la  génération  PWM  en  unités  de  temporisation.  La  macro  
HAL_TIM_SET_COMPARE  dans  le  fichier  stm32f1xx_hal_tim.h  est  utilisée  pour  atteindre  la  valeur  de  
comparaison  pour  la  génération  de  signal  PWM,  comme  illustré  à  la  Figure  8.8.  Nous  utiliserons  cette  macro  
dans  l'exemple  suivant.  Le  rapport  cyclique  d'un  signal  PWM  est  calculé  selon  l'équation  suivante :

•  94
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  8.7 :  Fonctions  à  l'intérieur  du  fichier  stm32f1xx_hal_tim.c

Figure  8.8 :  Macro  HAL_TIM_SET_COMPARE  dans  le  fichier  stm32f1xx_hal_tim.h

Comme  mentionné  précédemment,  nous  allons  activer  deux  minuteries  en  tant  que  sorties  PWM  et  
les  afficher  sur  un  oscilloscope  avec  deux  cycles  de  service  différents.  Les  codes  d'initialisation  pour  
TIM1  et  TIM4  ainsi  que  les  codes  à  l'intérieur  de  la  boucle  while  sont  illustrés  à  la  Figure  8.9.

•  95
Machine Translated by Google

Chapitre  8  •  Modulation  de  largeur  d'impulsion  (PWM)  dans  les  microcontrôleurs  STM32

Figure  8.9 :  Les  codes  d'initialisation  pour  TIM1  et  TIM4  ainsi  que  les  codes  à  l'intérieur  de  la  boucle  while

Faites  un  clic  droit  sur  le  projet  et  sélectionnez  "Build  Project"  pour  compiler  et  générer  le  code  hexadécimal  pour  
la  programmation  du  microcontrôleur.

8.3  •  Résumé

L'onde  PWM  est  générée  dans  des  unités  de  minuterie  qui  peuvent  produire  des  signaux  PWM.  Dans  ce  chapitre,  
les  paramètres  du  projet  PWM  ont  été  expliqués  en  détail.

•  96
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Chapitre  9  •  Horloge  en  temps  réel  (RTC)  dans  les  microcontrôleurs  STM32

9.1  •  Présentation

L'horloge  en  temps  réel  (RTC)  est  l'une  des  exigences  de  conception  de  système  intelligent  pour  accéder  au  temps  
réel  et  à  la  date.  Les  puces  RTC  sont  également  disponibles  séparément.  Cependant,  la  plupart  des  microcontrôleurs  
ARM  incluent  une  section  RTC.  L'horloge  d'une  unité  RTC  est  alimentée  par  un  oscillateur  d'une  fréquence  de  32,768  
kHz  qui  est  fournie  par  une  partie  en  cristal  de  quartz  appelée  «cristal  temporel».  Les  unités  RTC  ont  généralement  
une  batterie  de  secours  qui  restaure  l'heure  et  la  date  lorsque  l'alimentation  principale  est  déconnectée.  Dans  une  
unité  RTC,  la  fréquence  de  32,768  kHz  (c'est­à­dire  2  à  la  puissance  de  15)  est  pré­calibrée  à  32768  pour  générer  la  
fréquence  de  1  Hz.  Cette  fréquence  est  ensuite  utilisée  comme  base  de  comptage  en  unités  RTC  pour  produire  la  
seconde,  la  minute,  l'heure  et  la  date.

9.2  •  Paramètres  du  projet  RTC

Dans  l'exemple  suivant,  nous  allons  activer  l'unité  RTC  avec  les  broches  associées  et  définir  la  seconde,  la  minute  
et  l'heure  ainsi  que  la  date  et  les  afficher  sur  un  écran  LCD.  De  plus,  nous  voulons  générer  des  impulsions  avec  une  
fréquence  de  1  Hz  sur  la  broche  de  sortie  RTC.  À  cette  fin,  selon  la  figure  9.1  de  la  sous­section  System  Core  et  
RCC,  nous  définissons  l'horloge  à  basse  vitesse  (LSE)  comme  résonateur  cristal/céramique  pour  permettre  aux  
broches  liées  au  cristal  (avec  la  fréquence  de  32,768  kHz)  de  se  connecter  à  le  microcontrôleur.

Figure  9.1 :  Réglage  de  l'horloge  basse  vitesse  (LSE)  en  tant  que  résonateur  cristal/céramique

•  97
Machine Translated by Google

Chapitre  9  •  Horloge  en  temps  réel  (RTC)  dans  les  microcontrôleurs  STM32

Figure  9.2 :  Réglage  de  RTC  OUT  comme  sortie  RTC  sur  la  broche  Tamper

À  partir  de  la  section  des  temporisateurs  et  de  la  sous­section  RTC,  nous  définissons  ensuite  RTC  OUT  comme  
sortie  RTC  sur  la  broche  anti­sabotage  pour  activer  la  broche  anti­sabotage  de  l'unité  RTC,  comme  illustré  à  la  Figure  
9.2.  Nous  activons  également  les  broches  liées  à  la  commande  LCD  en  tant  que  GPIO_Output  et  activons  le  
résonateur  à  cristal  externe  comme  illustré  à  la  figure  9.3.

Figure  9.3 :  Activation  des  broches  liées  à  la  commande  de  l'écran  LCD  et  du  résonateur  à  cristal  externe

Dans  l'onglet  Configuration  de  l'horloge,  sélectionnez  LSE  pour  régler  la  fréquence  d'horloge  de  l'unité  RTC,  comme  
illustré  à  la  Figure  9.4.

•  98
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  9.4 :  Sélection  de  LSE  pour  régler  la  fréquence  d'horloge  de  l'unité  RTC

Dans  la  section  des  minuteries  et  la  sous­section  RTC,  ouvrez  les  paramètres  de  l'unité  RTC.  Dans  les  sous­
ensembles  d'heure  et  de  date  du  calendrier,  saisissez  l'heure  et  la  date  initiales.  Dans  le  sous­ensemble  
général,  activez  le  calcul  du  prédiviseur  automatique.  Définissez  la  valeur  du  pré­diviseur  asynchrone  sur  le  
calcul  automatique  du  pré­diviseur  activé  et  la  sortie  comme  deuxième  signal  d'impulsion  sur  la  broche  
TAMPER,  comme  illustré  à  la  Figure  9.5.

Figure  9.5 :  Réglages  des  paramètres  pour  l'unité  RTC

De  plus,  à  partir  de  la  sous­section  minuteries  et  RTC  de  l'onglet  Paramètres  NVIC,  nous  pouvons  activer  
l'interruption  globale  RTC  pour  chaque  seconde  (fréquence  d'horloge  de  1  Hz  dans  l'unité  RTC),  comme  
illustré  à  la  Figure  9.6.

•  99
Machine Translated by Google

Chapitre  9  •  Horloge  en  temps  réel  (RTC)  dans  les  microcontrôleurs  STM32

Figure  9.6 :  Activation  de  l'interruption  globale  RTC

Nous  sélectionnons  également  RTC  dans  la  section  des  minuteries  et  activons  le  calendrier  comme  illustré  à  la  Figure  9.7.
Dans  l'onglet  du  gestionnaire  de  projet,  sélectionnez  SW4STM32  comme  compilateur  et  générez  le  code.
Le  code  d'en­tête  du  fichier  main.c  est  illustré  à  la  Figure  9.8

Figure  9.7 :  Activation  du  calendrier  dans  la  sous­section  RTC

•  100
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  9.8 :  Le  code  d'en­tête  de  main.c

Le  corps  de  la  fonction  MX_RTC_Init  est  illustré  à  la  Figure  9.9.

Figure  9.9 :  Le  corps  de  la  fonction  MX_RTC_Init

•  101
Machine Translated by Google

Chapitre  9  •  Horloge  en  temps  réel  (RTC)  dans  les  microcontrôleurs  STM32

Les  fonctions  liées  à  l'unité  RTC  se  trouvent  dans  le  fichier  stm32f1xx_hal_rtc.c,  comme  illustré  à  la  Figure  
9.10.

Figure  9.10 :  Fonctions  de  l'unité  RTC  dans  le  fichier  stm32f1xx_hal_rtc.c

Comme  mentionné  précédemment,  nous  allons  régler  l'heure  et  la  date  dans  l'unité  RTC  et  les  afficher  sur  un  
écran  LCD.  Nous  voulons  également  générer  une  impulsion  avec  une  fréquence  de  1  Hz  sur  la  broche  
TAMPER.  Le  code  d'en­tête  du  fichier  main.c  est  illustré  à  la  Figure  9.11.  Les  corps  de  structure  
RTC_TimeTypeDef  et  RTC_DateTypeDef  sont  illustrés  respectivement  dans  la  Figure  9.12  et  la  Figure  9.13.  
Le  code  d'initialisation  de  l'unité  LCD  et  RTC  ainsi  que  le  code  à  l'intérieur  de  la  boucle  while  sont  illustrés  à  
la  Figure  9.14.

Figure  9.11 :  Le  code  d'en­tête  de  main.c

•  102
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  9.12 :  Le  corps  de  la  structure  RTC_TimeTypeDef

Figure  9.13 :  Le  corps  de  la  structure  RTC_DateTypeDef

Figure  9.14 :  Le  code  à  l'intérieur  de  la  boucle  while  dans  main.c

•  103
Machine Translated by Google

Chapitre  9  •  Horloge  en  temps  réel  (RTC)  dans  les  microcontrôleurs  STM32

Nous  pouvons  ensuite  compiler  le  projet  en  cliquant  avec  le  bouton  droit  sur  le  nom  du  projet  et  en  sélectionnant  
l'icône  Construire  le  projet.  Une  fois  le  projet  compilé  avec  succès,  le  fichier  hexadécimal  généré  pour  la  
programmation  du  microcontrôleur  se  trouvera  dans  le  dossier  Debug,  comme  indiqué  dans  les  figures  9.15  et  9.16.

Figure  9.15 :  Compilation  du  projet

Figure  9.16 :  Le  fichier  hexadécimal  généré  dans  le  dossier  Debug

•  104
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

9.3  •  Résumé

L'horloge  en  temps  réel  (RTC)  est  l'une  des  exigences  de  conception  de  système  intelligent  pour  accéder  
au  temps  réel  et  à  la  date.  Dans  ce  chapitre,  les  paramètres  du  projet  RTC  ont  été  abordés  en  détail.

•  105
Machine Translated by Google

Chapitre  9  •  Horloge  en  temps  réel  (RTC)  dans  les  microcontrôleurs  STM32

Chapitre  10  •  Communication  série  dans  les  microcontrôleurs  STM32

10.1  •  Présentation

La  communication  série  est  l'une  des  caractéristiques  les  plus  importantes  d'un  microcontrôleur  communiquant  
avec  d'autres  appareils.  L'un  des  principaux  protocoles  de  communication  série  est  le  récepteur/émetteur  
universel  asynchrone  (UART),  appelé  communication  asynchrone  sans  horloge.  Ce  protocole  de  communication  
constitue  deux  routes  (RX  et  TX)  qui  sont  représentées  sur  la  Figure  10.1.

Figure  10.1 :  Communication  série  UART  au  niveau  TTL

La  communication  série  peut  également  être  entreprise  en  mode  synchrone.  Dans  ce  cas,  il  s'appelle  
Universal  Synchronous/Asynchronous  Receiver/Transmitter  (USART).  Le  protocole  de  communication  
synchrone  comprend  une  horloge.  Dans  l'exemple  suivant,  nous  allons  activer  l'unité  USART1  en  mode  
asynchrone  et  envoyer  et  recevoir  des  données  depuis  un  ordinateur.

Figure  10.2 :  Activation  de  USART1  en  mode  asynchrone

Nous  voulons  également  afficher  les  caractères  reçus  d'un  ordinateur  sur  un  écran  LCD.

•  106
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

10.2  •  Envoi  des  paramètres  du  projet  de  données

Conformément  à  la  figure  10.2,  dans  la  section  de  connectivité  et  la  sous­section  USART1,  réglez  le  
mode  sur  asynchrone  et  le  débit  en  bauds  sur  9600.  Activez  également  les  broches  associées  à  la  
commande  de  l'écran  LCD  et  activez  le  résonateur  à  cristal  externe  comme  illustré  à  la  figure  10.3.

Figure  10.3 :  Activation  des  broches  pour  piloter  l'écran  LCD  et  activer  le  résonateur  à  cristal  externe

Figure  10.4 :  Paramètres  de  configuration  de  l'horloge

Dans  la  section  de  configuration  de  l'horloge,  réglez  les  horloges  périphériques  APB2  sur  8  MHz  avec  
un  résonateur  d'horloge  externe  (HSE)  activé,  comme  illustré  à  la  Figure  10.4.  En  outre,  dans  la  
section  Connectivité,  la  sous­section  USART1  et  l'onglet  Paramètres  NVIC,  activez  l'interruption  
globale  USART1,  comme  illustré  à  la  Figure  10.5.  La  broche  RX  (qui  est  entrée)  est  mieux  réglée  en  
mode  Pull  up  comme  illustré  à  la  Figure  10.6.  Nous  pouvons  alors  déterminer  l'interruption  globale  USART1

•  107
Machine Translated by Google

Chapitre  10  •  Communication  série  dans  les  microcontrôleurs  STM32

priorité  de  préemption  dans  la  section  NVIC  comme  illustré  à  la  Figure  10.7.

Figure  10.5 :  Activation  de  l'interruption  globale  USART1

Figure  10.6 :  Réglage  de  la  broche  RX  en  mode  pull­up

•  108
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  10.7 :  Choix  de  la  priorité  de  préemption  d'interruption  globale  USART1

Après  avoir  saisi  les  paramètres  ci­dessus,  dans  l'onglet  Gestionnaire  de  projet,  sélectionnez  
"SW4STM32"  comme  compilateur  et  générez  le  code.  Le  code  d'en­tête  du  fichier  main.c  est  décrit  
dans  la  Figure  10.8.  Le  corps  de  la  fonction  MX_USART1_UART_Init  est  illustré  à  la  Figure  10.9.

Figure  10.8 :  Le  code  d'en­tête  de  main.c

•  109
Machine Translated by Google

Chapitre  10  •  Communication  série  dans  les  microcontrôleurs  STM32

Figure  10.9 :  Le  code  d'en­tête  de  main.c

Les  fonctions  relatives  à  l'UART  se  trouvent  dans  le  fichier  stm32f1xx_hal_uart.c,  comme  illustré  à  la  Figure  
10.10.

•  110
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  10.10 :  Fonctions  à  l'intérieur  du  fichier  stm32f1xx_hal_uart.c

Pour  envoyer  des  données  d'un  microcontrôleur  vers  un  PC,  on  va  ajouter  une  unité  à  une  variable  
toutes  les  500  ms  puis  faire  une  chaîne.  Le  code  d'en­tête  du  fichier  main.c  avec  les  nouvelles  
définitions  de  variables  est  illustré  à  la  Figure  10.11.  Le  code  avant  la  fonction  principale  est  illustré  à  
la  Figure  10.12.  De  plus,  le  code  à  l'intérieur  de  la  boucle  while  de  la  fonction  main  est  illustré  à  la  figure  10.13.

Figure  10.11 :  Code  d'en­tête  du  fichier  main.c  avec  les  nouvelles  définitions  de  variables

•  111
Machine Translated by Google

Chapitre  10  •  Communication  série  dans  les  microcontrôleurs  STM32

Figure  10.12 :  Le  code  avant  la  fonction  principale

Figure  10.13 :  Le  code  à  l'intérieur  de  la  boucle  while  de  la  fonction  main

Nous  pouvons  ensuite  compiler  le  projet  en  cliquant  avec  le  bouton  droit  sur  le  nom  du  projet  et  en  
sélectionnant  l'icône  "build  project".  Une  fois  le  projet  compilé  avec  succès,  le  fichier  hexadécimal  généré  
pour  la  programmation  du  microcontrôleur  se  trouvera  dans  le  dossier  Debug.

10.3  •  Réception  des  paramètres  du  projet  de  données

Pour  recevoir  des  données  sur  un  microcontrôleur  à  partir  d'un  PC  et  les  afficher  sur  un  écran  LCD,  
considérez  l'exemple  suivant :  Le  code  d'en­tête  de  main.c  avec  la  nouvelle  définition  de  variable  est  
illustré  à  la  Figure  10.14.  Le  code  à  l'intérieur  de  la  boucle  while  de  la  fonction  main  est  illustré  à  la  Figure  10.15.
La  définition  de  la  structure  UART_HandleTypeDef  est  illustrée  à  la  Figure  10.16.  La  fonction  de  service  
d'interruption  USART1  dans  le  fichier  stm32f1xx_it.c  est  illustrée  à  la  Figure  10.17.

•  112
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  10.14 :  Le  code  d'en­tête  du  fichier  main.c  avec  une  nouvelle  définition  de  variable

Figure  10.15 :  Code  à  l'intérieur  de  la  boucle  while  de  la  fonction  main

•  113
Machine Translated by Google

Chapitre  10  •  Communication  série  dans  les  microcontrôleurs  STM32

Figure  10.16 :  Définition  de  la  structure  UART_HandleTypeDef

Figure  10.17 :  Fonction  de  service  d'interruption  USART1  dans  stm32f1xx_it.c

La  fonction  HAL_UART_RxCpltCallback  a  été  copiée  du  fichier  stm32f1xx_hal_uart.c  dans  le  fichier  stm32f1xx_it.c,  
comme  illustré  à  la  Figure  10.17.  L'activation  des  interruptions  est  effectuée  via  la  macro  HAL_UART_ENABLE_IT.  
Cette  macro  se  trouve  dans  le  fichier  stm32f1xx_hal_uart.h  comme  suit :

#define  HAL_UART_ENABLE_IT  (HANDLE , INTERRUPTION )

Cliquez  avec  le  bouton  droit  sur  le  projet  et  sélectionnez  "Build  Project"  pour  compiler  le  projet  et  générer  le  code  
hexadécimal  pour  la  programmation  du  microcontrôleur.

•  114
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

10.4  •  Résumé

La  communication  série  est  l'un  des  aspects  importants  de  la  communication  entre  un  microcontrôleur  
et  d'autres  appareils.  Dans  ce  chapitre,  les  paramètres  du  protocole  de  communication  série,  y  
compris  l'envoi  et  la  réception  de  données  vers  et  depuis  un  PC  et  leur  affichage  sur  un  projet  LCD,  
ont  été  expliqués  en  détail.

•  115
Machine Translated by Google

Chapitre  10  •  Communication  série  dans  les  microcontrôleurs  STM32

Chapitre  11  •  Interface  périphérique  synchrone  (SPI)  dans  STM32
Microcontrôleurs

11.1  •  Présentation

Le  protocole  SPI  est  une  interface  de  communication  série  bidirectionnelle  synchrone.  L'interface  est  l'un  des  
protocoles  de  communication  les  plus  importants  et  les  plus  utiles  dans  les  microcontrôleurs  en  raison  de  sa  
vitesse  rapide.  Les  puces  et  appareils  à  haut  débit  ont  tendance  à  utiliser  ce  protocole  de  communication.  
L'interface  synchrone  comprend  une  unité  maître  et  une  unité  esclave  ou  plusieurs  unités  esclaves.  Le  maître  
génère  généralement  l'horloge  d'interface.  Cette  interface  étant  synchrone,  l'envoi  et  la  réception  de  données  
sont  effectués  par  l'horloge.  L'interface  d'un  maître  et  d'un  esclave  utilisant  le  protocole  SPI  est  illustrée  à  la  
Figure  11.1.

Figure  11.1 :  L'interface  d'  un  maître  et  d'un  esclave  utilisant  le  protocole  SPI

Les  broches  d'un  protocole  SPI  sont  les  suivantes :

MOSI :  entrée  esclave  de  sortie  maître
MISO :  entrée  maître  sortie  esclave
SCK :  Horloge
SS :  sélection  de  l'esclave

Le  schéma  fonctionnel  de  l'interfaçage  d'un  maître  et  de  plusieurs  esclaves  est  illustré  à  la  Figure  11.2.

•  116
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  11.2 :  Interfaçage  d'un  maître  et  de  plusieurs  esclaves  à  l'aide  du  protocole  SPI

Dans  l'exemple  suivant,  nous  allons  utiliser  deux  microcontrôleurs  en  tant  que  maître  et  esclave.  Nous  
utiliserons  le  microcontrôleur  STM32F103RET6  en  tant  que  maître  et  STM32F030F4P6  en  tant  qu'esclave.
Le  microcontrôleur  maître  dans  la  boucle  while  du  programme  envoie  deux  caractères :  a  et  b,  à  l'esclave.  
Si  le  caractère  reçu  sur  le  microcontrôleur  esclave  est  A,  une  LED  sur  une  broche  du  microcontrôleur  
esclave  s'allume.  Si  le  caractère  reçu  sur  le  microcontrôleur  esclave  est
B,  une  LED  sur  une  broche  du  microcontrôleur  esclave  sera  éteinte.

Figure  11.3 :  Activation  de  SPI2  pour  un  microcontrôleur  maître

•  117
Machine Translated by Google

Chapitre  11  •  Interface  périphérique  synchrone  (SPI)  dans  les  microcontrôleurs  STM32

11.2  •  Paramètres  SPI  pour  le  microcontrôleur  maître

Tout  d'abord,  nous  considérons  les  paramètres  du  microcontrôleur  maître.  Dans  la  section  Connectivité  et  la  sous­
section  SPI2,  sélectionnez  le  mode  en  tant  que  maître  Full­Duplex.  Dans  l'onglet  Paramètres  des  paramètres,  
appliquez  les  paramètres,  y  compris  la  taille  des  données,  le  Prescaler,  etc.,  comme  illustré  à  la  Figure  11.3.
Activez  également  la  commande  de  l'écran  LCD  et  des  broches  du  résonateur  à  cristal  externe.  Dans  l'onglet  de  
configuration  de  l'horloge,  réglez  l'horloge  du  bus  APB1  sur  8  MHz  (l'unité  SPI2  est  connectée  au  bus  APB1)  avec  
un  résonateur  à  cristal  externe  (HSE)  activé,  comme  illustré  à  la  Figure  11.4.

Figure  11.4 :  Configuration  de  l'horloge  pour  le  microcontrôleur  maître

Dans  l'onglet  du  gestionnaire  de  projet,  sélectionnez  SW4STM32  comme  compilateur  et  générez  le  code  pour  le  
microcontrôleur  maître.

11.3  •  Paramètres  SPI  pour  le  microcontrôleur  esclave

Les  paramètres  du  microcontrôleur  esclave  (STM32F030F4P6)  sont  les  suivants :  Dans  la  section  Connectivité  et  la  
sous­section  SPI1,  sélectionnez  le  mode  en  tant  que  maître  duplex  intégral  et  le  signal  matériel  NSS  en  tant  que  
signal  d'entrée  matériel  NSS.  À  partir  de  l'onglet  Paramètres  des  paramètres,  appliquez  des  paramètres  tels  que  la  
taille  des  données,  le  Prescaler,  etc.,  comme  illustré  à  la  Figure  11.5.  L'onglet  de  configuration  de  l'horloge  est  illustré  
à  la  Figure  11.6.  Les  réglages  de  l'horloge  de  l'interface  SPI  sont  effectués  sur  l'unité  maître.
Dans  la  section  Connectivité  et  la  sous­section  SPI1,  à  partir  de  l'onglet  Paramètres  NVIC,  nous  pouvons  activer  
l'interruption  globale  SPI1,  comme  illustré  à  la  Figure  11.7.  À  partir  de  la  section  centrale  du  système  et  de  la  sous­
section  NVIC,  nous  pouvons  alors  déterminer  la  priorité  de  préemption  pour  l'interruption  globale  SPI1,  comme  
illustré  à  la  figure  11.8.  Après  avoir  effectué  les  réglages  ci­dessus,  à  partir  de  l'onglet  du  gestionnaire  de  projet,  
sélectionnez  SW4STM32  comme  compilateur  et  générez  le  code  pour  le  microcontrôleur  esclave.

•  118
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  11.5 :  Activation  de  SPI1  pour  le  microcontrôleur  esclave

Figure  11.6 :  Configuration  de  l'horloge  pour  le  microcontrôleur  esclave

•  119
Machine Translated by Google

Chapitre  11  •  Interface  périphérique  synchrone  (SPI)  dans  les  microcontrôleurs  STM32

Figure  11.7 :  Activation  de  l'interruption  globale  SPI1

Figure  11.8 :  Sélection  de  la  priorité  de  préemption  pour  l'interruption  globale  SPI1

11.4  •  Code  d'en­tête  de  main.c  pour  le  microcontrôleur  maître

Le  code  d'en­tête  du  fichier  main.c  pour  le  microcontrôleur  maître  est  illustré  à  la  Figure  11.9.
Le  code  à  l'intérieur  de  la  fonction  MX_SPI2_Init  est  illustré  à  la  Figure  11.10.

•  120
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  11.9 :  Le  code  d'en­tête  de  main.c  (maître)

Figure  11.10 :  Code  à  l'intérieur  de  la  fonction  MX_SPI2_Init

11.5  •  Code  d'en­tête  de  main.c  pour  le  microcontrôleur  esclave

Le  code  d'en­tête  du  fichier  main.c  pour  le  microcontrôleur  esclave  est  illustré  à  la  Figure  11.11.
Le  code  à  l'intérieur  de  la  fonction  MX_SPI2_Init  est  illustré  à  la  Figure  11.12.  Les  fonctions  à  l'intérieur  
du  fichier  stm32f1xx_hal_spi.c  sont  illustrées  à  la  Figure  11.13.

•  121
Machine Translated by Google

Chapitre  11  •  Interface  périphérique  synchrone  (SPI)  dans  les  microcontrôleurs  STM32

Figure  11.11:  Le  code  d'en­tête  de  main.c  esclave)

Figure  11.12 :  Code  à  l'intérieur  de  la  fonction  MX_SPI1_Init

Figure  11.13 :  Fonctions  à  l'intérieur  du  fichier  stm32f1xx_hal_spi.c

•  122
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  11.14 :  Code  avant  la  fonction  principale  (maître)

11.6  •  Les  paramètres  du  fichier  main.c  pour  les  microcontrôleurs  maître  et  esclave

Le  code  avant  la  fonction  principale  du  microcontrôleur  maître  est  illustré  à  la  figure  11.14.
De  plus,  le  code  à  l'intérieur  de  la  boucle  while  est  illustré  à  la  Figure  11.15.  Le  code  avant  la  fonction  
principale  du  microcontrôleur  esclave  est  illustré  à  la  figure  11.16.  De  plus,  le  code  à  l'intérieur  de  la  
boucle  while  est  illustré  à  la  Figure  11.17.  La  fonction  HAL_SPI_RxCpltCallback  dans  le  fichier  
stm32f0xx_hal_spi.c  (comme  illustré  à  la  Figure  11.18)  est  utilisée  pour  la  routine  de  service  
d'interruption  et  a  été  copiée  à  partir  du  fichier  stm32f0xx_hal_spi.c  dans  le  fichier  stm32f0xx_it.c  
comme  illustré  à  la  Figure  11.19.  En  outre,  le  code  utilisateur  peut  être  inséré  dans  la  fonction  SPI1_IRQHandler.

Figure  11.15 :  Code  à  l'intérieur  de  la  boucle  while  (maître)

•  123
Machine Translated by Google

Chapitre  11  •  Interface  périphérique  synchrone  (SPI)  dans  les  microcontrôleurs  STM32

Figure  11.16 :  Code  avant  la  fonction  principale  (esclave)

Figure  11.17 :  Code  à  l'intérieur  de  la  boucle  while  (esclave)

Figure  11.18 :  Fonction  HAL_SPI_RxCpltCallback  dans  le  fichier  stm32f0xx_hal_spi.c

•  124
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  11.19 :  Fonction  HAL_SPI_RxCpltCallback  copiée  dans  le  fichier  stm32f0xx_it.c

L'activation  des  interruptions  est  obtenue  à  l'aide  de  la  macro  HAL_SPI_ENABLE_IT.  Cette  macro  se  trouve  dans  
le  fichier  stm32f0xx_hal_spi.h  comme  suit :

#define  HAL_SPI_ENABLE_IT  ( HANDLE , INTERRUPTION )

De  plus,  l'élément  d'activation  d'interruption  de  réception  est  la  fonction  SPI_IT_RXNE.  Faites  un  clic  droit  sur  le  
projet  et  sélectionnez  "Build  Project"  pour  compiler  le  projet  et  générer  le  code  hexadécimal  pour  la  programmation  
des  microcontrôleurs  maître  et  esclave.

11.7  •  Résumé

Le  protocole  SPI  est  une  interface  de  communication  série  bidirectionnelle  synchrone.  Cette  interface  est  l'un  des  
protocoles  de  communication  les  plus  importants  et  les  plus  utiles  dans  les  microcontrôleurs  en  raison  de  sa  très  
grande  vitesse.  Dans  ce  chapitre,  les  paramètres  du  protocole  SPI  pour  les  microcontrôleurs  maître  et  esclave  ont  
été  expliqués  en  détail.

•  125
Machine Translated by Google

Chapitre  11  •  Interface  périphérique  synchrone  (SPI)  dans  les  microcontrôleurs  STM32

Chapitre  12  •  Minuterie  de  chien  de  garde  dans  les  microcontrôleurs  STM32

12.1  •  Présentation

Le  temporisateur  de  chien  de  garde  est  utilisé  pour  réinitialiser  le  processeur  lorsqu'il  se  bloque.  Il  est  réglable  et  réinitialise  
le  CPU  à  des  moments  prédéterminés.  Cependant,  le  CPU  dans  la  boucle  principale  du  programme  réinitialise  le  
temporisateur  de  chien  de  garde  et  ne  permet  pas  au  temporisateur  de  chien  de  garde  d'atteindre  le  temps  déterminé  et  de  
réinitialiser  le  CPU.  Le  temporisateur  de  chien  de  garde  réinitialise  le  processeur  uniquement  lorsqu'il  se  bloque  et  ne  se  
réinitialise  pas  lui­même.  La  structure  du  temporisateur  chien  de  garde  est  illustrée  à  la  Figure  12.1.

Figure  12.1 :  Structure  du  temporisateur  de  chien  de  garde

Les  microcontrôleurs  STM32  ont  deux  unités  de  minuterie  de  surveillance  appelées  Independent  Watchdog  (IWDG)  et  
Window  Watchdog  (WWDG).  Un  schéma  de  fonctionnement  du  temporisateur  WWDG  est  illustré  à  la  Figure  12.2.

Figure  12.2 :  Schéma  de  fonctionnement  de  la  minuterie  WWDG

Le  temporisateur  IWDG  a  une  horloge  indépendante  de  l'horloge  principale.  Il  reste  actif  même  si  l'horloge  principale  tombe  
en  panne.

•  126
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

12.2  •  Paramètres  du  projet  de  minuterie  WWDG

Nous  considérons  l'exemple  suivant  pour  le  fonctionnement  de  la  minuterie  WWDG :  dans  la  section  centrale  du  
système  et  la  sous­section  SYS,  choisissez  de  déboguer  en  tant  que  câble  série,  comme  illustré  à  la  figure  12.3.  À  
partir  du  noyau  du  système  et  de  la  sous­section  RCC,  réglez  le  résonateur  à  cristal  externe  comme  illustré  à  la  
figure  12.4.  De  plus,  à  partir  de  l'onglet  Configuration  de  l'horloge,  réglez  PCLK1  sur  36  MHz,  comme  illustré  à  la  
Figure  12.5.  Enfin,  nous  devons  activer  le  temporisateur  WWDG,  LED_GREEN,  LED_YELLOW  en  tant  que  sorties  
et  SW  en  tant  qu'entrée  et  mode  pull­up,  comme  illustré  à  la  Figure  12.6  et  à  la  Figure  12.7.

Figure  12.3 :  Définition  du  débogage  en  tant  que  câble  série.

Figure  12.4 :  Réglage  du  résonateur  à  cristal  externe

•  127
Machine Translated by Google

Chapitre  12  •  Minuterie  de  chien  de  garde  dans  les  microcontrôleurs  STM32

Figure  12.5 :  Réglage  de  PCLK1  à  36  MHz

Figure  12.6 :  Activation  de  la  minuterie  WWDG,  LED_GREEN,  LED_YELLOW  et  SW

Figure  12.7 :  Définition  de  SW  comme  mode  d'entrée  et  d'extraction

•  128
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  12.8 :  Schéma  fonctionnel  WWDG  du  fichier  du  manuel  de  référence  RM0008

À  partir  des  figures  12.5,  12.6  et  12.8  (PCLK1  est  divisé  en  4096,  puis  appliqué  au  bloc  WDG  Prescaler),  nous  
pouvons  calculer  la  fréquence  et  la  période  WWDG  comme  suit :

Fréquence  WWDG  =  36  MHz/(4096×8)  ≈  1099  Hz,  période  WWDG  =  1/1099  ≈  910  µs

Début  de  fenêtre  =  910  µs  ×  (127  –  80)  ≈  43  ms

Délai  de  fenêtre  =  910  µs  ×  (127  –  63)  ≈  58  ms

Enfin,  nous  pouvons  générer  du  code  dans  l'environnement  logiciel  SW4STM32  comme  illustré  à  la  Figure  12.9.  Le  
code  à  l'intérieur  de  la  boucle  while  de  la  fonction  main  est  illustré  à  la  figure  12.10.

Figure  12.9 :  Le  code  d'en­tête  avant  la  fonction  principale

•  129
Machine Translated by Google

Chapitre  12  •  Minuterie  de  chien  de  garde  dans  les  microcontrôleurs  STM32

Figure  12.10 :  Code  à  l'intérieur  de  la  boucle  while  de  la  fonction  main

Cliquez  avec  le  bouton  droit  sur  le  projet  et  sélectionnez  "Build  Project"  pour  compiler  le  projet  et  générer  le  code  
hexadécimal  pour  la  programmation  du  microcontrôleur.  Lors  de  l'exécution  du  programme,  la  LED  jaune  sera  allumée.  
En  appuyant  sur  le  bouton  de  réinitialisation,  la  LED  jaune  s'éteint  et  la  LED  verte  s'allume.  Si  le  bouton  SW  est  enfoncé,  
la  LED  verte  s'éteint  et  la  LED  jaune  s'allume.  Si  nous  changeons  HAL_Delay(50)  en  HAL_Delay(42)  puis  compilons  et  
exécutons  le  programme  en  appuyant  sur  le  bouton  de  réinitialisation,  la  LED  verte  s'allumera  momentanément.  En  
relâchant  le  bouton  de  réinitialisation,  la  LED  verte  s'éteindra  et  la  LED  jaune  se  rallumera.

12.3  •  Paramètres  du  projet  de  minuterie  IWDG

Dans  l'exemple  suivant,  nous  évaluons  le  fonctionnement  de  la  minuterie  IWDG.  Comme  précédemment,  activez  SW,  
LED_GREEN  et  LED_YELLOW.  Activez  ensuite  les  broches  du  résonateur  à  cristal  externe.  Enfin,  à  partir  du  noyau  du  
système  et  de  la  sous­section  IWDG,  nous  activons  le  mode.  Dans  l'onglet  Paramètres,  réglez  le  Prescaler  de  l'horloge  
du  compteur  IWDG  sur  32  et  la  valeur  de  rechargement  du  décompteur  IWDG  sur  4095,  comme  illustré  à  la  Figure  
12.11.  Dans  l'onglet  Configuration  de  l'horloge,  nous  pouvons  voir  que  la  fréquence  d'horloge  IWDG  est  de  40  kHz,  
comme  illustré  à  la  Figure  12.12.

Figure  12.11 :  Réglage  des  paramètres  de  la  minuterie  IWDG

•  130
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  12.12 :  La  fréquence  d'horloge  IWDG

D'après  les  figures  12.11  et  12.12,  nous  avons  les  équations  suivantes :

Période  du  compteur  IWDG  =  1/(40  kHz  ×  32)  =  0,8  ms  Temps  
de  rechargement  du  compteur  IWDG  =  4095  ×  0,8  ms  ≈  3,2  s

Depuis  l'onglet  Project  Manager,  nous  pouvons  alors  sélectionner  le  logiciel  SW4STM32  comme  
compilateur  et  générer  le  code.  Le  code  d'en­tête  du  fichier  main.c  est  illustré  à  la  Figure  12.13.  Le  
code  à  l'intérieur  de  la  boucle  while  est  illustré  à  la  figure  12.14.

Figure  12.13 :  Le  code  d'en­tête  de  main.c

•  131
Machine Translated by Google

Chapitre  12  •  Minuterie  de  chien  de  garde  dans  les  microcontrôleurs  STM32

Figure  12.14 :  Le  code  à  l'intérieur  de  la  boucle  while

Nous  pouvons  ensuite  compiler  le  projet  en  cliquant  avec  le  bouton  droit  sur  le  nom  du  projet  et  en  sélectionnant  l'  icône  
"Construire  le  projet".  Une  fois  le  projet  compilé  avec  succès,  le  fichier  hexadécimal  généré  peut  être  utilisé  pour  
programmer  le  microcontrôleur.  En  exécutant  le  programme,  la  LED  jaune  s'allumera.  Si  le  bouton  de  réinitialisation  est  
enfoncé,  la  LED  verte  s'allume.  En  appuyant  sur  le  bouton  SW  pendant  plus  de  3,2  secondes,  la  LED  verte  s'éteint  et  la  
LED  jaune  s'allume.

12.4  •  Résumé

La  minuterie  de  chien  de  garde  est  un  aspect  important  des  microcontrôleurs.  Il  est  utilisé  pour  réinitialiser  le  CPU  
lorsqu'il  se  bloque.  Les  microcontrôleurs  STM32  ont  deux  unités  de  minuterie  de  surveillance  appelées  minuteries  de  
surveillance  indépendante  (IWDG)  et  surveillance  de  fenêtre  (WWDG).  Dans  ce  chapitre,  les  paramètres  de  projet  de  
minuterie  WWDG  et  IWDG  ont  été  discutés  en  détail.

•  132
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Chapitre  13  •  Circuit  inter­intégré  (I2C)  dans  STM32
Microcontrôleurs

13.1  •  Présentation

Le  circuit  inter­intégré  (I2C)  est  un  protocole  de  bus  série  composé  de  deux  lignes  de  signal  
appelées  lignes  SCL  et  SDL.  Ceux­ci  sont  utilisés  pour  la  communication  avec  différents  appareils.  
SCL  signifie  la  ligne  d'horloge  série  et  ce  signal  est  toujours  généré  par  l'appareil  maître.
SDL  signifie  Serial  Data  Line.  Le  signal  SDL  est  généré  soit  par  le  maître,  soit  par  les  appareils  qui  
lui  sont  connectés  avec  le  protocole  I  2C.  Les  lignes  SCL  et  SDL  sont  en  mode  drain  ouvert  lorsqu'il  
n'y  a  pas  de  transfert  entre  les  dispositifs  d'interface  I  2C.  Dans  l'exemple  suivant,  nous  allons  
configurer  le  microcontrôleur  STM32  comme  un  simple  dispositif  esclave  I  2C.  La  communication  
est  alors  établie  avec  le  dispositif  esclave  I  2C  à  partir  d'un  autre  microcontrôleur  STM32  qui  est  un  
dispositif  maître  I  2C.  Le  schéma  fonctionnel  de  l'  exemple  de  protocole  I  2C  est  illustré  à  la  Figure  13.1.

Figure  13.1 :  Le  schéma  fonctionnel  de  l'  exemple  de  protocole  I2C

Figure  13.2 :  Définition  du  débogage  en  tant  que  fil  série

•  133
Machine Translated by Google

Chapitre  13  •  Circuit  inter­intégré  (I2C)  dans  les  microcontrôleurs  STM32

13.2  •  Paramètres  I  2C  pour  le  microcontrôleur  esclave

Tout  d'abord,  nous  avons  défini  le  microcontrôleur  esclave  I  2C.  Dans  la  section  System  Core  et  la  sous­
section  SYS,  sélectionnez  debug  en  tant  que  Serial  Wire,  comme  illustré  à  la  Figure  13.2.  Ensuite,  à  partir  
de  la  sous­section  RCC,  nous  activons  le  résonateur  à  cristal  externe  comme  illustré  à  la  figure  13.3.  Dans  
la  section  Connectivité  
et  la  
section  Asnalogique  
ous­section   Il  a  
et   2C  2 ,  sélectionnez  
sous­section   I  2a
ADC1,   C  comme  
ctivez   illustré  
IN6   à  lia  
comme   Figure  
à  1
llustré   3.4.  
la   Dans  
Figure   la  
13.5.  
L'onglet  de  réglage  des  paramètres  pour  ADC1  (IN6)  est  illustré  à  la  Figure  13.6.  Les  réglages  des  
paramètres  pour  I  2C  2  sont  illustrés  à  la  Figure  13.7.  Enfin,  dans  l'onglet  Project  Manager,   'SW4STM32'  
sélectionnez  
comme  compilateur  et  générez  le  code.

Figure  13.3 :  Activation  du  résonateur  à  cristal  externe

Figure  13.4 :  Activation  de  I2C2  pour  le  microcontrôleur  esclave

•  134
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  13.5 :  Activation  de  l'ADC1  (IN6)

Figure  13.6 :  Onglet  Paramètres  des  paramètres  pour  ADC1  (IN6)

•  135
Machine Translated by Google

Chapitre  13  •  Circuit  inter­intégré  (I2C)  dans  les  microcontrôleurs  STM32

Figure  13.7 :  Les  réglages  des  paramètres  pour  I2C2

Le  code  d'en­tête  de  main.c  est  illustré  à  la  Figure  13.8.  Le  code  à  l'intérieur  de  la  boucle  while  est  
montré  dans  les  Figures  13.9  et  13.10.

Figure  13.8 :  Le  code  d'en­tête  du  fichier  main.c

•  136
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  13.9 :  Code  à  l'intérieur  de  la  boucle  while  (partie  1)

Figure  13.10 :  Code  à  l'intérieur  de  la  boucle  while  (partie  2)

Faites  un  clic  droit  sur  le  projet  et  sélectionnez  "Construire  le  projet"  pour  compiler  le  projet  et  générer  le  code  
hexadécimal  pour  la  programmation  du  microcontrôleur  esclave  I  2C.

13.3  •  Paramètres  I  2C  pour  le  microcontrôleur  maître

Nous  pouvons  maintenant  régler  le  microcontrôleur  maître  I  2C.  Dans  la  section  System  Core  et  la  sous­section  
SYS,  sélectionnez  Debug  comme  câble  série,  comme  illustré  à  la  Figure  13.11.  Dans  la  section  Connectivité  
et  la  sous­section  I  2Figure  
C  1 ,  sélectionnez  I  2dC  
13.12.  Enfin,   et  ll'onglet  
ans   es  réglages  
des  
Mp
Project   aramètres  
anager,   par  défaut  
sélectionnez  ScW4STM32  
omme  illustré  
à  la  
comme  
compilateur  et  générez  le  code.

•  137
Machine Translated by Google

Chapitre  13  •  Circuit  inter­intégré  (I2C)  dans  les  microcontrôleurs  STM32

Figure  13.11 :  Définition  du  débogage  en  tant  que  fil  série

Figure  13.12 :  Activation  d'I2C1  pour  le  microcontrôleur  maître

Le  code  d'en­tête  du  fichier  main.c  est  illustré  à  la  Figure  13.13.  Le  code  à  l'intérieur  de  la  boucle  
while  est  illustré  respectivement  aux  figures  13.14  et  13.15.

•  138
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  13.13 :  Le  code  d'en­tête  de  main.c

Figure  13.14 :  Code  à  l'intérieur  de  la  boucle  while  (partie  1)

Figure  13.15 :  Code  à  l'intérieur  de  la  boucle  while  (partie  2)

•  139
Machine Translated by Google

Chapitre  13  •  Circuit  inter­intégré  (I2C)  dans  les  microcontrôleurs  STM32

Faites  un  clic  droit  sur  le  projet  et  sélectionnez  "Construire  le  projet"  pour  compiler  le  projet  et  générer  le  
code  hexadécimal  pour  la  programmation  du  microcontrôleur  maître  I  2C.

13.4  •  Résumé

Le  circuit  inter­intégré  (I2C)  est  un  protocole  de  bus  série  composé  de  deux  lignes  de  signal  appelées  lignes  
SCL  et  SDL.  Ceux­ci  sont  utilisés  pour  la  communication.  SCL  signifie  'Serial  Clock
Line'  et  ce  signal  est  toujours  généré  par  l'appareil  maître.  SDL  signifie  Serial  Data  Line  et  le  signal  SDL  est  
généré  soit  par  le  maître,  soit  par  les  appareils  qui  lui  sont  connectés  avec  le  protocole  I  2C.  Les  lignes  SCL  
et  SDL  sont  en  mode  drain  ouvert  lorsqu'il  n'y  a  pas  de  transfert  entre  les  dispositifs  d'interface  I  2C.  Dans  
ce  chapitre,  les  paramètres  du  protocole  I  2C  pour  les  microcontrôleurs  maître  et  esclave  ont  été  expliqués  
en  détail.

•  140
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Chapitre  14  •  Accès  direct  à  la  mémoire  (DMA)  dans  STM32
Microcontrôleurs

14.1  •  Présentation

Dans  de  nombreux  projets  de  microcontrôleurs,  la  lecture  et  l'écriture  de  données  sont  nécessaires.  La  lecture  des  
données  peut  provenir  d'une  unité  périphérique  comme  un  ADC,  puis  l'écriture  des  valeurs  dans  la  RAM.  D'autre  
part,  il  peut  être  nécessaire  d'envoyer  des  données  à  l'aide  du  protocole  SPI,  de  plus,  pour  lire  les  données  de  la  
RAM  et  écrire  en  continu  dans  le  registre  de  données  SPI.  En  utilisant  le  processeur,  une  quantité  importante  de  
temps  de  traitement  est  perdue.  Pour  éviter  de  monopoliser  le  temps  de  traitement  du  processeur,  la  plupart  des  
microcontrôleurs  avancés  disposent  d'un  contrôleur  d'accès  direct  à  la  mémoire  (DMA).  Les  transferts  de  données  
à  l'aide  de  DMA  sont  mis  en  œuvre  entre  les  emplacements  de  mémoire  sans  avoir  besoin  de  CPU.  Le  schéma  
fonctionnel  de  DMA  est  illustré  à  la  Figure  14.1.

Figure  14.1 :  Schéma  fonctionnel  du  DMA

Considérez  les  exemples  suivants  pour  démontrer  les  applications  DMA  dans  la  programmation  du  microcontrôleur  
STM32.

14.2  •  Paramètres  DMA  pour  ADC

À  partir  de  la  section  centrale  du  système  et  de  la  sous­section  RCC,  activez  le  résonateur  à  cristal  externe,  comme  
illustré  à  la  Figure  14.2.  Dans  la  section  Analogique  et  la  sous­section  ADC1,  activez  IN0  et  IN1.  Dans  l'onglet  
Paramètres,  définissez  les  paramètres  requis  et  activez  la  broche  PB0  (GPIO_Output)  comme  illustré  à  la  Figure  
14.3.  À  partir  de  ADC1  de  la  section  Analogique  et  de  l'onglet  Paramètres  DMA,  cliquez  sur  le  bouton  « Ajouter »  et  
appliquez  les  paramètres  comme  indiqué  dans  la  Figure  14.4.
Dans  l'onglet  Configuration  de  l'horloge,  réglez  les  fréquences  d'horloge  appropriées,  comme  illustré  à  la  Figure  
14.5.

•  141
Machine Translated by Google

Chapitre  14  •  Accès  direct  à  la  mémoire  (DMA)  dans  les  microcontrôleurs  STM32

Figure  14.2 :  Activation  du  résonateur  à  cristal  externe

Figure  14.3 :  Activation  des  broches  analogiques  et  de  la  broche  de  sortie  numérique

•  142
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  14.4 :  Paramètres  DMA  pour  ADC1

Figure  14.5 :  Réglage  des  fréquences  d'horloge  dans  l'onglet  Configuration  de  l'horloge

Dans  l'onglet  Project  Manager,  sélectionnez  MDK­ARM  V5  comme  compilateur  et  générez  du  
code  dans  Keil  uVision.  Le  code  d'en­tête  du  fichier  main.c  est  illustré  à  la  Figure  14.6.

•  143
Machine Translated by Google

Chapitre  14  •  Accès  direct  à  la  mémoire  (DMA)  dans  les  microcontrôleurs  STM32

Figure  14.6 :  Le  code  d'en­tête  de  main.c

Le  code  à  l'intérieur  de  la  boucle  while  est  illustré  à  la  Figure  14.7.  Enfin,  nous  pouvons  compiler  le  projet  
et  générer  un  code  hexadécimal  pour  programmer  le  microcontrôleur.

14.3  •  Paramètres  de  minuterie,  ADC  et  DMA

Le  but  de  l'exemple  suivant  est  de  configurer  une  minuterie  périodique  qui  démarre  une  mesure  ADC  en  
arrière­plan  à  l'aide  de  DMA.  Comme  la  fréquence  d'horloge  du  TIM3  est  de  8  MHz,  pour  générer  des  
événements  à  10  Hz,  un  Prescaler  de  800­1  est  utilisé  avec  une  période  de  compteur  de  1000­1.
Après  le  Prescaler,  la  fréquence  est  de  10  kHz.  Le  compteur  atteint  1000  après  0,1  seconde,  après  quoi  
la  valeur  est  rechargée.  Un  paramètre  important  ici  est  le  "Trigger  Event  Selection:  Update  Event"  qui  
sera  utilisé  pour  déclencher  l'ADC.  Dans  la  section  des  temporisateurs  et  la  sous­section  TIM3,  
sélectionnez  la  source  d'horloge  comme  horloge  interne  et  effectuez  les  réglages  de  paramètres  requis,  
comme  illustré  à  la  Figure  14.8.

•  144
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  14.7 :  Le  code  à  l'intérieur  de  la  boucle  while

Figure  14.8 :  Réglages  des  paramètres  du  TIM3

Dans  la  section  Analogique  et  la  sous­section  ADC1,  activez  IN0.  Dans  l'onglet  Paramètres,  définissez  les  
paramètres  requis  comme  illustré  à  la  Figure  14.9.  À  partir  de  ADC1  de  la  section  Analogique  et  de  l'onglet  
Paramètres  DMA,  cliquez  sur  le  bouton  Ajouter  et  appliquez  les  paramètres  comme  illustré  à  la  Figure  14.10.  Dans  
l'onglet  Project  Manager,  sélectionnez  'MDK­ARM  V5'  comme  compilateur  et  générez  le  code  dans  Keil  uVision.  Le  
code  d'en­tête  de  main.c  est  illustré  à  la  Figure  14.11.

•  145
Machine Translated by Google

Chapitre  14  •  Accès  direct  à  la  mémoire  (DMA)  dans  les  microcontrôleurs  STM32

Figure  14.9 :  Réglages  des  paramètres  ADC1

Figure  14.10 :  Paramètres  DMA  pour  ADC1

•  146
Machine Translated by Google

Programmation  avancée  avec  les  microcontrôleurs  STM32

Figure  14.11 :  Le  code  d'en­tête  de  main.c

Le  code  avant  la  boucle  while  et  à  l'intérieur  de  la  fonction  main  est  illustré  à  la  Figure  14.12.
Quelque  part  dans  le  fichier  main.c,  nous  ajoutons  la  fonction  d'interruption  pour  une  conversion  ADC  
terminée,  comme  illustré  à  la  figure  14.13.  Nous  pouvons  enfin  compiler  le  projet  et  générer  un  code  
hexadécimal  pour  programmer  le  microcontrôleur.

•  147