Topic "[STM32]Librairie HAL, GPIOs et Diagramme PinOuts"

Flux RSS des posts récents dans ce topic ( Flux Atom)


Pas de photo de profil

weetoz

Membre

#151 | Signaler ce message



Introduction

Maintenant que vous savez compiler et charger un programme dans votre cartes, nous pouvons commencer à apprendre à programmer les cartes STM32. Dans le monde des µC ARM( µC=microcontrôleurs, il faut vous y faire, c' est le terme que j' emploierai d' hors en avant ) . Le langage Arduino n' est plus de rigueur, par exemple les instructions comme digitale.write(A0, LOW) ; n' existe pas. Vu la complexité de la configuration de chaque broches (pins), ARM impose au fabricants utilisant leur architecture de fournir des drivers(CMSIS), et des librairies afin de faciliter le développement sur cette technologie. De plus, ST fourni également des librairies HAL ( Hardware Abstraction Layout). HAL est une librairie complétant CMSIS, un peu dans le genre d' Arduino. Elle permet de faire le lien entre nos code source et CMSIS-CORE. Couche

Dans cet article, nous allons aborder HAL avec un exemple reprenant GPIO_IOToggle que nous avons vu dans le tutoriel précédant.

Les diagrammes « Pinout » .

Pour commencer, il faut savoir identifier l' emplacements des broches.

Le nombre de cartes STM32 est très importante, bien plus que celle d' Arduino. Nous n' avons pas forcément les mêmes cartes basés sur les mêmes µCs. Depuis le début de l' année, les Nucleo sont maintenant classé dans trois familles : les Nucleo 32, les Nucleo 64, (qui sont là depuis la première génération), puis les Nucleo 144.

Puis les discovery, plus diversifié par l' électronique embarqué. Les EvalBoards, de plus en plus nombreuses, et aussi les plus onéreuses, à partir d' environs 70 euros jusqu' à environs 750 Euros.

Pour nous aider à y voir plus clair, la communauté mbed fourni des « diagrammes Pinouts » visuellement plus agréable à l' œil. Voici la page de la liste des cartes ST supportées par mbed. Si votre carte si trouve, tant mieux, dans ce cas, ouvrez la page produit de votre carte, puis dans un autre onglet, celle de la Nucleo 32F303k8 https://developer.mbed.org/platforms/ST-Nucleo-F303K8/( c'est le modèle que j' utilise pour cette article). Pour illustrer mon propos, comparons les pinouts des Nucleo32_F303k8 et le Nucleo64_F411RE . N32

Commençons par regarder les broches analogiques, A0, A1… dans l' encadré sur fond vert, puis regardons leurs noms dans les registres : pour la F411(pas celle de Maranello…), la broche A2 correspond au port A pin 4 (PA_4), et la Nucleo F303, la broche A2 au port A également, mais à la pin 3 (PA_3).

N64

HAL, quelques bases pour les GPIOs.

A l'instart d' Arduino, HAL est une surcouche qui facilite la programmation, ainsi que la portabilité de nos code d' une carte à une autre. Si ce n'est fait, ouvrez le fichier /votreµC_hal_gpio.h, ainsi que le « hal_gpio.c ». Pour ce tutoriel, je vous recommande d' ouvrir la version du NucleoF303K8. Ceci afin d' avoir exactement le même exemples pour les démonstrations.

Le code du « main.c ».

Ouvrez l' exemple GPIO_IOToggle avec SW4STM32. Si par défaut le « main.c » n' est ouvert, ouvrez-le.

1
2
/* Includes ------------------------------------------------------------------*/
#include "main.h"

Le main.h regroupe d' autres inclusions, afin d' éviter de surcharger le main.c. Il contient aussi une macro de vérification d' inclusion.

1
static GPIO_InitTypeDef  GPIO_InitStruct;

En gros, on renomme la structure GPIO_InitTypeDef en GPIO_InitStruct, « static » afin que la structure ne soit modifiable que dans ce fichier ( main.c ).

1
static void SystemClock_Config(void) ;

Prototype de la fonction de configuration de l' horloge système. Observons maintenant ce que contient la fonction

1
int main(void)

 :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
int main(void)
{
  /* This sample code shows how to use GPIO HAL API to toggle LED3 IO
    in an infinite loop. */

  /* STM32F3xx HAL library initialization:
       - Configure the Flash prefetch
       - Configure the Systick to generate an interrupt each 1 msec
       - Set NVIC Group Priority to 4
       - Low Level Initialization
     */
  HAL_Init();

La ligne

1
HAL_Init();

sert à initialiser la librairie HAL.

  • Le prefetch est une optimisation interne des µC ARM, elle sert ici à participer à la gestion des interruptions par leurs gestions mémoires.

  • Le Systick Timer est normalement dédié aux systèmes d'exploitation en temps réel (RTOS) , mais peut également être utilisé en tant que décompteur.

  • NVIC (Nested vectored interrupt controller) ou contrôleur d'interruption vectorisées imbriquées, on se contentera de savoir que le niveau de priorité de l' interruption est de 4.

1
2
 /* -1- Enable GPIO Clock (to be able to program the configuration registers) */
  LED3_GPIO_CLK_ENABLE();

Cela semble être un délai d' attente après l' initialisation de RCC (Reset and Clock Control) .

1
2
3
4
5
6
7
  /* -2- Configure IO in output push-pull mode to drive external LEDs */
  GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP; 
  GPIO_InitStruct.Pull  = GPIO_PULLUP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  GPIO_InitStruct.Pin = LED3_PIN;

  HAL_GPIO_Init(LED3_GPIO_PORT, &GPIO_InitStruct);

Ce block est très intéressant, on configure chaque éléments de la structure GPIO_InitTypeDef, puis on l'envoie en paramètre dans la fonction HAL_GPIO_Init();. GPIO_initTypeDef s' appel maintenant GPIO_InitStruct. Pour rappel :

1
static GPIO_InitTypeDef  GPIO_InitStruct;

HAL_GPIO_Init(); est l' équivalent de la fonction  pinMode() ;  sous Arduino. Comme les configuration de GPIO on plus de possibilités, comme ici d' avoir mis une « pull up » en sortie. Vous aurez remarqué que ça ne se fait pas sur les Arduino, on utilise les « pull up » seulement sur les entrées. De plus sur les µC ARM, on peut, mais on peut aussi mettre des « pull down ».

1
2
3
4
5
6
7
8
  /* -3- Toggle IO in an infinite loop */
  while (1)
  {
    HAL_GPIO_TogglePin(LED3_GPIO_PORT, LED3_PIN);
    /* Insert delay 100 ms */
    HAL_Delay(100);
  }
}

La structure de contrôle while (1){} est l' équivalent de la fonction void loop(){} pour Arduino, c' est ici qu' on cuisine.

Commande de base pour les GPIOs avec HAL.

1
 HAL_Delay(); 

quand à elle appartient à la librairie « hal » , dans le même répertoire . C' est l' équivalent de la fonction delay() ; d' Arduino. Donc des millisecondes.

1
 HAL_GPIO_TogglePin () ; 

est une fonction de la librairie « hal_gpio.h » que l'on trouve dans le répertoire /votre_carte/Drivers/Votre_Carte_HAL_Driver. Cette fonction inverse l' état de la sortie à chaque fois qu' elle est appelée.

1
HAL_GPIO_ReadPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); 

Lecture des entrées. GPIOx est le PORT, une lettre et GPIO_Pin le numéro de la broche concerné. La fonction renvoie la valeur « bitstatus » pouvant être GPIO_PIN_SETou GPIO_PIN_RESET.

1
HAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState); 

Voici les deux valeurs de PinState : GPIO_PIN_SET et GPIO_PIN_RESET.

Configuration des GPIOs.

Dans un premier temps, il faut se familiariser avec les possibilités de sorties :

GPIO_conf

Configurations des entrées/ sorties.

Voyons d' un peu plus près les possibilités de configuration des pins avec HAL. Déjà retrouvons notre structure GPIO_InitTypeDef.

Pin.
1
2
3
4
typedef struct
{
  uint32_t Pin;        /*!< Specifies the GPIO pins to be configured.
                           This parameter can be any value of @ref GPIO_pins */

C' est le numéro (en partant de zero) de la pin (broche) à configurer. Dans notre exemple, c' est la définition LED3_PIN qui est utilisé. Pour savoir à quoi elle correspond, faite un clique gauche sur la définition puis appuyez sur la touche F3 de votre clavier. Eclipse va ouvrir le fichier où se trouve la définition de LED3_PIN

Mode.
1
2
  uint32_t Mode;       /*!< Specifies the operating mode for the selected pins.
                           This parameter can be a value of @ref GPIO_mode */

On défini ici le mode d' entrée ou sortie de la broche.

Les Entrées.
  • GPIO_MODE_INPUT Broche en entrée en mode flottant.

  • GPIO_MODE_IT_RISING interruption sur front montant.

  • GPIO_MODE_IT_FALLING interruption sur front descendant.

  • GPIO_MODE_IT_RISING_FALLING Interruption sur les deux fronts.

  • GPIO_MODE_EVT_RISING

  • GPIO_MODE_EVT_FALLING

  • GPIO_MODE_EVT_RISING_FALLING

Les Sorties.
  • GPIO_MODE_OUTPUT_PP Broche en sortie en mode Push/Pull.

  • GPIO_MODE_OUTPUT_OD Broche en sortie en drain ouvert.

  • GPIO_MODE_AF_PP Fonction alternative en mode Push/Pull.

  • GPIO_MODE_AF_OD Fonction alternative en mode drain ouvert.

Non défini.
  • GPIO_MODE_ANALOG

Note. Nous nous occupons ici que de l' essentiel, les fonctions alternatives ne rentre pas dans le cadre de ce tutoriel. Il en va de même pour les événements et les interruptions.

Pull.
1
2
  uint32_t Pull;       /*!< Specifies the Pull-up or Pull-Down activation for the selected pins.
                           This parameter can be a value of @ref GPIO_pull */

c' est ici que l' on configure les Pull Up et les Pull Down. Trois possibilités :

  • GPIO_NOPULL Pas de résistance.

  • GPIO_PULLUP Résistance de tirage vers le haut.

  • GPIO_PULLUP Résistance de tirage vers le bas.

Les résistances de tirages ont une valeur de 40 kOhms.

Speed.

Le paramètre « speed » n'a d'effet que lorsque la sortie est configuré en sortie. Il n'a rien à voir avec la fréquence de changement d'état de la broche, il s'agit du temps de monté et descente du signal. Au lieu d'avoir un signal carré, il sera « plutôt » trapézoïdale. La description que l'on peut faire c'est que plus le speed est élevé, plus le signal se rapprochera d'une forme carrée.

1
2
3
4
 
  uint32_t Speed;      /*!< Specifies the speed for the selected pins.
                           This parameter can be a value of @ref GPIO_speed */
 

ST n'a pas jugé bon d'uniformiser les définitions des valeurs possibles pour tous ses µCs.

STM32 F0/1/3/L0/1
  • GPIO_SPEED_LOW

  • GPIO_SPEED_MEDIUM

  • GPIO_SPEED_FAST

  • GPIO_SPEED_HIGH

STM32 F4/L4
  • GPIO_SPEED_FREQ_LOW

  • GPIO_SPEED_FREQ_MEDIUM

  • GPIO_SPEED_FREQ_HIGH

  • GPIO_SPEED_FREQ_VERY_HIGH

Voyez la différence.

Alternate.

Ce sont les périphériques comme I²C, SPI, USART…

1
2
3
4
 
  uint32_t Alternate;  /*!< Peripheral to be connected to the selected pins 
                            This parameter can be a value of @ref GPIOEx_Alternate_function_selection */
}GPIO_InitTypeDef;

Nous y reviendrons plus tard.

Le mot de la fin.

Nous avons fait un survol des configurations possibles des GPIOs, nous avons abordé sommairement la librairie Cube HAL. Nous avons vu aussi le raccourci clavier ctrl+espace pour la complétion qui propose pas mal de choses dans Eclipse. Ainsi que la touche F3 lorsque l'on sélectionne une instruction, définition… emmène à la déclaration. C'est très utile pour commencer à comprendre comment est fait un projet. Dernière petite astuce, si vous n' aviez pas remarqué, c' est que lorsque l'on survole les onglets, une info bulle apparaît indiquant le chemin du fichier concerné. Pour cette fois, il n' y aura pas d' exemple concret pour clôturer ce tutoriel, je sais, c' est pas gentil. Mais si vous êtes patient, je vous donne rendez-vous d' ici une dizaine de jour pour un nouveau tutoriel. Ce tutoriel portera sur CubeMix, nous y configurerons des broches en entrées et en sorties pour commander des LED via des boutons poussoirs. Sur ce, je vous souhaite beaucoups de plaisir avec vos cartes de développement.

Weetoz.

Derniére modification le par weetoz