Dans cet article détaillé, vous apprendrez à développer un micrologiciel intégré pour les microcontrôleurs 32 bits Cortex-M STM32 à l’aide des différents outils de développement.
La série STM32 compte parmi les microcontrôleurs les plus populaires utilisés dans une grande variété de produits. Ils ont également une excellente base de support de plusieurs forums de développement de microcontrôleurs.
Cette famille de microcontrôleurs de STMicroelectronics est basée sur le cœur de processeur ARM Cortex-M 32 bits.
Les microcontrôleurs STM32 offrent un grand nombre de périphériques de communication série et parallèle qui peuvent être interfacés avec toutes sortes de composants électroniques, y compris des capteurs, des écrans, des caméras, des moteurs, etc. Toutes les variantes STM32 sont équipées de mémoire Flash interne et de RAM.
La gamme de performances disponible avec le STM32 est assez étendue. Certaines des variantes les plus basiques incluent les sous-séries STM32F0 et STM32F1 qui commencent avec une fréquence d’horloge de seulement 24 MHz et sont disponibles dans des boîtiers avec aussi peu que 16 broches.
À l’autre extrême de performance, le STM32H7 fonctionne jusqu’à 400 MHz et est disponible en paquets avec jusqu’à 240 broches.
Les modèles les plus avancés sont disponibles avec des unités à virgule flottante (FPU) pour les applications nécessitant un traitement numérique important. Ces modèles plus avancés brouillent la frontière entre un microcontrôleur et un microprocesseur.
Enfin, la sous-série STM32L est conçue spécifiquement pour les applications portables de faible consommation fonctionnant à partir d’une petite batterie.
Outils de développement
Des outils de développement sont nécessaires pour développer le code, programmer le microcontrôleur et tester/déboguer le code. Les outils de développement incluent:
- Compilateur
- Débogueur
- Programmeur série en circuit (ICSP)
Programmation du STM32 via le Programmeur série en circuit (ICSP).
Il existe plusieurs outils de développement logiciel disponibles pour le développement de code sur les microcontrôleurs STM32. Les outils logiciels sont disponibles sous forme d’Environnements de développement intégrés ( Integrated) qui combinent tous les outils nécessaires dans un environnement intégré.
Deux packages de développement courants incluent :
- Keil MDK ARM (E uVison5) – L’E MDK ARM est un environnement de développement très stable qui peut être téléchargé gratuitement. Il permet le développement de code jusqu’à une taille de programme de 32 Ko. Pour développer des programmes plus importants, une version sous licence doit être achetée ici.
- CoIDE – Une chaîne d’outils gratuite basée sur une version réduite de l’EDI Eclipse intégrée avec une version ARM intégrée du compilateur GCC gratuit.
Il existe également plusieurs autresEs disponibles pour une utilisation avec les microcontrôleurs STM32. Cependant, cet article se concentre sur le développement et le clignotement d’un programme utilisant l’E très populaire Keil MDK ARM uVision5.
En dehors des outils logiciels, un programmeur série en circuit (ICSP) est nécessaire pour programmer et tester le code sur le microcontrôleur réel. L’ICSP est nécessaire pour interfacer le microcontrôleur avec les outils logiciels du PC via un port USB.
Les microcontrôleurs ARM Cortex-M prennent en charge deux protocoles de programmation : JTAG (nommé Joint Test Action Group par l’electronics industry association) et Serial Wire Debug (SWD).
Il existe plusieurs programmeurs ICSP disponibles qui prennent en charge ces protocoles, notamment:
- Keil U-Link 2
- Segger J-Link
- ST-Link
Développer la première application
Il est toujours plus facile de commencer avec un framework de code de base facilement disponible. Ensuite, ajoutez le code requis pour l’application et le modèle spécifiques du microcontrôleur.
Heureusement, STMicroelectronics fournit un outil graphique très utile appelé STM32CubeMx qui aide à créer un projet d’application de base pour n’importe quel microcontrôleur STM32 de votre choix. Il peut également être utilisé pour configurer les périphériques sur les broches multiplexées du microcontrôleur.
L’outil STM32CubeMX peut être téléchargé ici. Le STM32Cube est livré avec un vaste ensemble de pilotes pour tous les types de périphériques et prend en charge un FreeRTOS optionnel (un système d’exploitation gratuit en Temps Réel) pré-intégré au code.
La section suivante décrit en détail comment créer une application UART simple pour le microcontrôleur STM32F030 qui fait écho à tout ce qui est tapé sur une fenêtre de terminal.
- Installez le logiciel STM32CubeMX.
- Exécutez l’application et sélectionnez Nouveau projet. Il ouvrira alors la fenêtre du sélecteur MCU comme indiqué ci-dessous.
- Double-cliquez pour sélectionner le modèle de microcontrôleur utilisé. Dans ce cas, nous utilisons le STM32F030K6. Il vous amène ensuite à la page de brochage du microcontrôleur sélectionné.
Le STM32F030K6 est un cœur ARM Cortex-M0 avec 32 Ko de mémoire Flash et 4 Ko de mémoire RAM. L’exemple de code active l’UART qui utilise les broches PA9 et PA10 pour recevoir et transmettre des données série comme indiqué ci-dessous avec les broches vertes.
Configurez les paramètres UART sous l’onglet Configuration et choisissez les paramètres UART comme indiqué ci-dessous. Activez l’option Interruption globale NVIC sous l’onglet Paramètres NVIC.
Ensuite, accédez aux paramètres Project–> afin d’ajouter le nouveau nom de projet et de sélectionner l’E de chaîne d’outils à utiliser. Pour cet exemple, définissez le nom du projet sur ‘UARTEcho’ et sélectionnez l’E Keil-MDK5 pour le développement du projet.
Enfin, générez le code du projet en cliquant sur Project-> Générer du code.
Construire et faire clignoter le code
Ouvrez maintenant le fichier de projet MDK-ARM généré UARTEcho\MDK-ARM\UartEcho.uprojx.
Jusqu’à présent, ce programme initialise simplement le périphérique UART et s’arrête dans une boucle infinie.
Il est important de noter que le STM32Cube génère des blocs /*USER CODE BEGIN x */ et /*USER CODE END x */comment pour implémenter le code spécifique à l’utilisateur. Le code utilisateur doit être écrit dans ces blocs de commentaires. Chaque fois que le code est généré à nouveau avec des configurations modifiées, l’outil STMCube conserve le code utilisateur dans ces blocs de commentaires utilisateur.
Ensuite, définissez une variable globale pour recevoir un octet de l’UART dans le main.fichier source c:
/* USER CODE BEGIN PV *//* Private variables ———————————————————*/static uint8_t recv_data;/* USER CODE END PV */Après tout le code d’initialisation, activez le pilote à recevoir 1 octet. La fonction suivante active le bit d’interruption RXNE.
/* USER CODE BEGIN 2 */HAL_UART_Receive_IT(&huart1, &recv_data, 1);/* USER CODE END 2 */Maintenant, ajoutez une fonction de rappel pour gérer l’interruption de réception et transmettre l’octet reçu.
/* USER CODE BEGIN 0 */void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){HAL_UART_Transmit(huart, huart->pRxBuffPtr, 1, 1000);}/* USER CODE END 0 */Enfin, nous devons compiler le code et le flasher (télécharger) sur le microcontrôleur.
Lorsque l’E ARM Keil MDK est installé, les pilotes pour ST-LINK V2, J-Link et Ulink2 sont disponibles. Le débogueur ST-Link sera sélectionné par défaut. Allez dans Projets – > Options pour la cible et dans l’onglet Débogage, sélectionnez le programmeur ICSP utilisé.
Flashez le code en sélectionnant Flash-> Télécharger.
Le microcontrôleur va maintenant faire écho à toutes les données reçues sur l’UART. Il peut être connecté à un PC à l’aide d’un convertisseur USB-série. Sur le PC, ouvrez le port COM avec une application de terminal en utilisant les paramètres de 115200-8-N-1. Maintenant, tout ce qui est envoyé depuis le terminal fera écho à travers le microcontrôleur.
Système d’interruption
Le système d’interruption STM32 est basé sur le périphérique NVIC ARM Cortex M core. Les microcontrôleurs STM32 prennent en charge plusieurs canaux d’interruption masquables en dehors des 16 canaux d’interruption du cœur du BRAS.
Par exemple, la série MCU STM32F0 prend en charge 32 interruptions masquables. L’exception et la table de vecteurs d’interruption pour cette famille de microcontrôleurs sont données dans le tableau ci-dessous.
| Interrupt | Description | Vector Address |
| – | Reserved | 0x00000000 |
| Reset | Reset | 0x00000004 |
| NMI | Non maskable interrupt. The RCC clock security system (CSS) is linked to the NMI vector | 0x00000008 |
| HardFault | All class of faults | 0x0000000C |
| SVCall | System service call via SWI Instruction | 0x0000002C |
| PendSV | Pendable request for system service | 0x00000038 |
| SysTick | System tick timer | 0x0000003C |
| WWDG | Window watchdog interrupt | 0x00000040 |
| PVD_VDDIO2 | PVD and VDDIO2 supply comparator interrupt (combined with EXTI lines 16 and 31) | 0x00000044 |
| RTC | RTC interrupts (combined EXTI lines 17, 19 and 20) | 0x00000048 |
| Flash | Flash global interrupt | 0x0000004C |
| RCC_CRS | RCC and CRS global interrupts | 0x00000050 |
| EXTI0_1 | EXTI line interrupts | 0x00000054 |
| EXTI2_3 | EXTI line interrupts | 0x00000058 |
| EXTI4_15 | EXTI line interrupts | 0x0000005C |
| TSC | Touch sensing interrupt | 0x00000060 |
| DMA_CH1 | DMA channel 1 interrupt | 0x00000064 |
| DMA_CH2_3 DMA2_CH1_2 |
DMA channels 2 and 3 interrupts DMA2 channel1 and 2 interrupts |
0x00000068 |
| DMA_CH4_5_6_7 DMA2_CH3_4_5 |
DMA channel 4,5,6 and 7 interrupts DMA2 channel 3, 4, and 5 interrupts |
0x0000006C |
| ADC_COMP | ADC and COMP interrupts (Combined EXTI lines 21 and 22) | 0x00000070 |
| TIM1_BRK_UP_TRG_COM | TIM1 break, update, trigger and commutation interrupts | 0x00000074 |
| TIM1_CC | TIM1 capture compare interrupt | 0x00000078 |
| TIM2 | TIM2 global interrupt | 0x0000007C |
| TIM3 | TIM3 global interrupt | 0x00000080 |
| TIM6_DAC | TIM6 global interrupt and DAC underrun interrupt | 0x00000084 |
| TIM7 | TIM7 global interrupt | 0x00000088 |
| TIM14 | TIM14 global interrupt | 0x0000008C |
| TIM15 | TIM15 global interrupt | 0x00000090 |
| TIM16 | TIM16 global interrupt | 0x00000094 |
| TIM17 | TIM17 global interrupt | 0x00000098 |
| I2C1 | I2C1 global interrupt (combined with EXTI line 23) | 0x0000009C |
| I2C2 | I2C2 global interrupt | 0x000000A0 |
| SPI1 | SPI1 global interrupt | 0x000000A4 |
| SPI2 | SPI2 global interrupt | 0x000000A8 |
| USART1 | USART1 global interrupt (combined with EXTI line 25) | 0x000000AC |
| UART2 | USART2 global interrupt (combined with EXTI line 26) | 0x000000B0 |
| USART3_4_5_6_7_ 8 | USART3, USART4, USART5, USART6, USART7, USART8 global interrupts (combined with EXTI line 28) | 0x000000B4 |
| CEC_CAN | CEC and CAN global interrupts (combined with EXTI line 27 | 0x000000B8 |
| USB | USB global interrupt (combined with EXTI line 18) | 0x000000BC |
Extended Contrôleur d’interruptions et d’événements (EXTI)
Les microcontrôleurs STM32 disposent d’un contrôleur d’interruptions et d’événements étendu qui gère les événements/interruptions asynchrones externes et internes et génère la demande d’événement au contrôleur CPU/interruption et une demande de réveil au Gestionnaire d’alimentation.
Chacune des une ou plusieurs lignes EXTI est mappée à l’un des vecteurs d’interruption NVIC.
Pour les lignes d’interruption externes, pour générer une interruption, la ligne d’interruption doit être configurée et activée. Ceci est fait en programmant les deux registres de déclenchement avec la détection de bord souhaitée et en activant la demande d’interruption en écrivant un ‘1’ sur le bit correspondent dans le registre de masque d’interruption.
Interruption externe et mappage GPIO
Chacun des GPIO disponibles sur le système peut être configuré pour générer une interruption. Mais chacune des lignes d’interruption EXTI est mappée sur plusieurs broches GPIO. Par exemple, PIO0 sur tous les ports GPIO disponibles (A, B, C, etc.) sera mappé à la ligne EXTI0. PIO1 pour tous les ports sera mappé à la ligne EXTI1 et ainsi de suite.
Certaines des lignes EXTI sont combinées en un seul vecteur NVIC. Par exemple, EXTI4_15 est mappé à une seule adresse vectorielle, il y aura donc une routine d’interruption unique pour toutes les interruptions de PIO4 à PIO15. Mais la source de l’interruption peut être identifiée en lisant le registre en attente d’interruption.
Une chose importante à considérer lors de la conception d’un système utilisant les microcontrôleurs STM32 est la sélection des broches GPIO pour les interruptions. Le MCU peut avoir plus de 16 GPIO disponibles sur l’appareil, mais il n’y a que 16 lignes d’interruption externes disponibles.
Par exemple, EXTI_0 peut être mappé à PA0 ou PB0 mais pas aux deux. Ainsi, lors du choix des broches pour les interruptions externes, elles doivent être choisies de manière à pouvoir être mappées de manière unique à l’une des lignes EXTI.
La section suivante décrit comment configurer une interruption à l’aide du cube STM32.
Sélectionnez l’onglet Configuration et choisissez le module matériel pour lequel l’interruption doit être configurée. La fenêtre de configuration du module s’ouvre.
Sélectionnez ensuite l’onglet Paramètres NVIC et activez l’interruption globale.
Le code pour activer l’interruption pour le module sera généré dans le stm32f0xx_hal_msp.c dans la fonction HAL_< module >_MSPInit(…).
/* USART1 interrupt Init */HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);HAL_NVIC_EnableIRQ(USART1_IRQn);Le code généré par le cube STM32 aura l’implémentation IRQ_Handler de toutes les interruptions. Lorsque l’interruption est activée, le code sera inclus dans l’application.
Habituellement, le code généré gère déjà l’IRQ et efface l’indicateur qui a généré l’interruption. Il appelle ensuite un rappel d’application qui correspond à l’événement qui a généré l’interruption pour le module.
La couche d’abstraction matérielle STM32 implémente un rappel pour chacun des types d’événements de chaque module dans le cadre du pilote. Dans cet exemple, le rappel complet du transfert Rx doit être copié à partir du stm32f0xx_hal_UART.fichier c.
Les fonctions de rappel dans le pilote seront implémentées avec un attribut d’éditeur de liens __weak. L’utilisateur doit implémenter une copie de la fonction de rappel nécessaire en supprimant l’attribut __weak dans l’un des fichiers d’application, puis en écrivant la gestion spécifique requise dans cette fonction.
/*** @brief Rx Transfer completed callback.* @param huart UART handle.* @retval None*/__weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){/* Prevent unused argument(s) compilation warning */UNUSED(huart);/* NOTE : This function should not be modified, when the callback is needed,the HAL_UART_RxCpltCallback can be implemented in the user file.*/}
Conclusion
Ce tutoriel est une introduction à l’écriture d’une application qui fonctionne avec la famille de microcontrôleurs STM32. Il existe plusieurs autres méthodes pour écrire une application, mais le STM32Cube discuté est une méthode facile et intuitive pour commencer.
Cet outil simplifie l’initialisation des périphériques du microcontrôleur. Cela améliore également la maintenabilité du code, en particulier lorsqu’il y a des révisions matérielles qui nécessitent un remappage des signaux sur différentes broches.
Un autre avantage de l’utilisation de l’outil STM32Cube est qu’il génère un rapport de la configuration de l’utilisateur pour le microcontrôleur. Dans ce rapport, il détaille l’arborescence de l’horloge, le mappage des broches et la configuration du module matériel qui sont tous très utiles.
Il existe également plusieurs autres bibliothèques de code et exemples de programmes disponibles pour toutes les variantes STM32. La prise en charge de plusieursEs est également incluse.
Si votre projet nécessite un microcontrôleur 32 bits sophistiqué, je recommande vivement la série STM32. Non seulement ils sont puissants et populaires, mais les microcontrôleurs STM32 sont également très abordables.
Besoin de plus de formation sur la programmation des microcontrôleurs STM32? Si c’est le cas, voici un cours d’introduction plus approfondi que vous devriez consulter.
Cet article a été écrit par Mohan Kashivasi de Vithamas Technologies. Il est également l’un des experts disponibles pour vous aider avec votre produit au sein de la Hardware Academy.
Enfin, n’oubliez pas de télécharger votre PDF gratuit: Guide Ultime pour Développer et Vendre Votre Nouveau Produit Matériel Électronique. Vous recevrez également ma newsletter hebdomadaire où je partage du contenu premium non disponible sur mon blog.
Autres contenus susceptibles de vous intéresser:
- Introduction au Cube STM32 pour Microcontrôleurs STM32
- Comment Sélectionner le Microcontrôleur pour Votre Nouveau Produit
- Utiliser Arduino comme Plate-forme de Développement intégrée
- Revue de la Fiche technique: Entry-Level STM32 Cortex-M0 Microcontroller (Blog + Video)
- Introduction to the Ultra High-Performance STM32H7 32-bit Microcontroller