Manuel d'utilisation de démarrage de la série STMicroelectronics STM32WBA

Principales caractéristiques du package MCU STM32CubeWBA :
Le package MCU STM32CubeWBA fournit tous les composants logiciels intégrés nécessaires au développement d'applications sur les microcontrôleurs de la série STM32WBA. Il est hautement portable au sein de la série STM32 et est livré avec les API HAL et LL, ex.ampfichiers et composants middleware.

Architecture terminéeview:
L'architecture du package MCU STM32CubeWBA se compose de trois niveaux : applications, composants basés sur la bibliothèque et le protocole, couche d'abstraction matérielle, pilotes BSP, pilotes principaux et API de couche inférieure.

FAQ

Qu'est-ce qui est inclus dans le package MCU STM32CubeWBA ?
Le package comprend des API de couche basse (LL) et de couche d'abstraction matérielle (HAL), ex.ampfichiers, applications, composants middleware comme FileX/LevelX, NetX Duo, bibliothèques mbed-crypto, et plus encore.

Le package MCU STM32CubeWBA est-il compatible avec le générateur de code STM32CubeMX ?
Oui, le package est entièrement compatible avec le générateur de code STM32CubeMX pour générer du code d'initialisation.

Introduction

STM32Cube est une initiative originale de STMicroelectronics visant à améliorer considérablement la productivité des concepteurs en réduisant les efforts, le temps et les coûts de développement. STM32Cube couvre l'ensemble du portefeuille STM32.
Le STM32Cube comprend :
- Un ensemble d'outils de développement logiciel conviviaux pour couvrir le développement de projet de la conception à la réalisation, parmi lesquels :
  - STM32CubeMX, un outil de configuration logicielle graphique qui permet la génération automatique de code d'initialisation C à l'aide d'assistants graphiques
  - STM32CubeIDE, un outil de développement tout-en-un avec des fonctionnalités de configuration périphérique, de génération de code, de compilation de code et de débogage
  - STM32CubeCLT, un ensemble d'outils de développement en ligne de commande tout-en-un avec compilation de code, programmation de carte et fonctionnalités de débogage
  - STM32CubeProgrammer (STM32CubeProg), un outil de programmation disponible en versions graphique et en ligne de commande
  - STM32CubeMonitor (STM32CubeMonitor, STM32CubeMonPwr, STM32CubeMonRF, STM32CubeMonUCPD), outils de surveillance puissants pour affiner le comportement et les performances des applications STM32 en temps réel
- Packages STM32Cube MCU et MPU, plates-formes logicielles intégrées complètes spécifiques à chaque série de microcontrôleurs et de microprocesseurs (telles que STM32CubeWBA pour la série STM32WBA), qui comprennent :
  - Couche d'abstraction matérielle (HAL) STM32Cube, garantissant une portabilité maximale sur l'ensemble du portefeuille STM32
  - API de couche inférieure STM32Cube, garantissant les meilleures performances et empreintes avec un degré élevé de contrôle de l'utilisateur sur le matériel
  - Un ensemble cohérent de composants middleware tels que ThreadX, FileX / LevelX, NetX Duo, USBX, bibliothèque tactile, mbed-crypto, TFM, MCUboot, OpenBL et STM32_WPAN (y compris Bluetooth® Low Energy profiles et services, Mesh, Zigbee®, OpenThread, Matter et couche MAC 802.15.4)
  - Tous les utilitaires logiciels embarqués avec des ensembles complets de périphériques et applicatifs examples
- Les packages d'extension STM32Cube, qui contiennent des composants logiciels intégrés qui complètent les fonctionnalités des packages MCU et MPU STM32Cube avec :
  - Extensions middleware et couches applicatives
  - Examples chiers s'exécutant sur certaines cartes de développement spécifiques de STMicroelectronics

Ce manuel d'utilisation décrit comment démarrer avec le package MCU STM32CubeWBA.
- La section 2 Principales fonctionnalités du STM32CubeWBA décrit les principales fonctionnalités du package MCU STM32CubeWBA.
- Section 3 Architecture STM32CubeWBA surview fournit un plusview de l'architecture STM32CubeWBA et de la structure du package MCU.

informations générales

Le package MCU STM32CubeWBA fonctionne sur des microcontrôleurs STM32 32 bits basés sur le processeur Arm® Cortex®-M33 avec Arm® TrustZone® et FPU.
Note: Arm et TrustZone sont des marques déposées d'Arm Limited (ou de ses filiales) aux États-Unis et/ou ailleurs.

Principales fonctionnalités du STM32CubeWBA

Le package MCU STM32CubeWBA fonctionne sur des microcontrôleurs STM32 32 bits basés sur le processeur Arm® Cortex®-M33 avec TrustZone® et FPU.
Le STM32CubeWBA rassemble, dans un seul package, tous les composants logiciels embarqués génériques nécessaires au développement d'une application pour les microcontrôleurs de la série STM32WBA. Conformément à l'initiative STM32Cube, cet ensemble de composants est hautement portable, non seulement au sein des microcontrôleurs de la série STM32WBA mais également vers d'autres séries STM32.

Le STM32CubeWBA est entièrement compatible avec le générateur de code STM32CubeMX, pour générer du code d'initialisation. Le package comprend des API de couche basse (LL) et de couche d'abstraction matérielle (HAL) qui couvrent le matériel du microcontrôleur, ainsi qu'un ensemble complet d'API ex.ampchiers fonctionnant sur les cartes STMicroelectronics. Les API HAL et LL sont disponibles dans une licence BSD open source pour plus de commodité.
Le package MCU STM32CubeWBA contient également un composant middleware complet construit autour du middleware Microsoft® Azure® RTOS et d'autres piles internes et open source, avec l'ex correspondantamples.
Ils sont accompagnés de conditions de licence gratuites et conviviales :
- Azure® RTOS intégré et complet : Azure® RTOS ThreadX
- Implémentation CMSIS-RTOS avec Azure® RTOS ThreadX
- Piles d’hôtes et de périphériques USB comprenant de nombreuses classes : Azure® RTOS USBX
- Avancé file couche système et traduction flash : FileX / NiveauX
- Pile réseau de qualité industrielle : optimisée pour les performances fournies avec de nombreux protocoles IoT : NetX Duo
- OuvrirBootloader
- Solution d'intégration Arm® Trusted Firmware-M (TF‑M)
- bibliothèques mbed-crypto
- Bibliothèque réseau ST
- Solution de bibliothèque de détection tactile STMTouch
Plusieurs applications et démonstrations implémentant tous ces composants middleware sont également fournies dans le package MCU STM32CubeWBA.
La disposition des composants du package MCU STM32CubeWBA est illustrée dans la figure 1. Composants du package MCU STM32CubeWBA.

Architecture STM32CubeWBA terminéeview

La solution de package MCU STM32CubeWBA est construite autour de trois niveaux indépendants qui interagissent facilement comme décrit dans la Figure 2. Architecture du package MCU STM32CubeWBA.

Niveau 0

Ce niveau est divisé en trois sous-couches :

Package de support de carte (BSP).

Couche d'abstraction matérielle (HAL) :
- Pilotes de périphériques HAL
- Pilotes de couche basse

Utilisation de base des périphériques examples.

Package de support du conseil d'administration (BSP)
Cette couche offre un ensemble d'API relatives aux composants matériels des cartes matérielles (tels que les pilotes LCD, Audio,\ microSD™ et MEMS). Il est composé de deux parties :

Pilote de composant :
Ce pilote est lié au périphérique externe de la carte et non au périphérique STM32. Le pilote de composant fournit des API spécifiques aux composants externes du pilote BSP et peut être portable sur n'importe quelle autre carte.

Pilote BSP :
Le pilote BSP permet de relier les pilotes de composants à une carte spécifique et fournit un ensemble de commandes conviviales.
Apis. La règle de dénomination de l'API est BSP_FUNCT_Action().
Exampfichier : BSP_LED_Init(), BSP_LED_On()
BSP est basé sur une architecture modulaire permettant un portage facile sur n'importe quel matériel en implémentant simplement les routines de bas niveau.

Couche d'abstraction matérielle (HAL) et couche basse (LL)
Les STM32CubeWBA HAL et LL sont complémentaires et couvrent un large éventail d'exigences d'application :

Les pilotes HAL offrent des API hautement portables de haut niveau orientées fonctions. Ils cachent la complexité du MCU et des périphériques à l'utilisateur final.
Les pilotes HAL fournissent des API génériques multi-instances orientées fonctionnalités, qui simplifient la mise en œuvre des applications utilisateur en fournissant des processus prêts à l'emploi. Par exempleample, pour les périphériques de communication (I2S, UART et autres), il fournit des API permettant d'initialiser et de configurer le périphérique, de gérer le transfert de données basé sur un processus d'interrogation, d'interruption ou DMA, et de gérer les erreurs de communication pouvant survenir lors de la communication. Les API du pilote HAL sont divisées en deux catégories :
1. API génériques, qui fournissent des fonctions communes et génériques à tous les microcontrôleurs de la série STM32.
2. API d'extension, qui fournissent des fonctions spécifiques et personnalisées pour une famille spécifique ou un numéro de pièce spécifique.
Les API de couche inférieure fournissent des API de bas niveau au niveau du registre, avec une meilleure optimisation mais moins de portabilité.
- Ils nécessitent une connaissance approfondie des spécifications des MCU et des périphériques.
- Les pilotes LL sont conçus pour offrir une couche rapide, légère et orientée expert, plus proche du matériel que le HAL. Contrairement au HAL, les API LL ne sont pas fournies pour les périphériques pour lesquels l'accès optimisé n'est pas une fonctionnalité clé, ni pour ceux nécessitant une configuration logicielle lourde ou une pile complexe de niveau supérieur.
- Les pilotes LL comportent :
  - Un ensemble de fonctions pour initialiser les principales fonctionnalités périphériques en fonction des paramètres spécifiés dans les structures de données.
  - Un ensemble de fonctions pour remplir les structures de données d'initialisation avec les valeurs de réinitialisation correspondant à chaque champ.
  - Fonction de désinitialisation des périphériques (registres périphériques restaurés à leurs valeurs par défaut).
  - Un ensemble de fonctions en ligne pour un accès direct et atomique aux registres.
  - Indépendance totale de HAL et possibilité d'être utilisé en mode autonome (sans pilotes HAL).
  - Couverture complète des fonctionnalités périphériques prises en charge.

Utilisation de base des périphériques examples
Cette couche renferme l'exampchiers construits sur les périphériques STM32 en utilisant uniquement les ressources HAL et BSP.

Niveau 1

Ce niveau est divisé en deux sous-couches :

Composants middleware

Exampchiers basés sur les composants middleware

Composants middleware

Le middleware est un ensemble de bibliothèques couvrant Bluetooth® Low Energy (Linklayer, HCI, Stack), Thread®, Zigbee®,

Matter, OpenBootloader, Microsoft® Azure® RTOS, TF‑M, MCUboot et mbed-crypto.
L'interaction horizontale entre les composants de cette couche se fait en appelant les API présentées.
L'interaction verticale avec les pilotes de couche inférieure se fait via des rappels spécifiques et des macros statiques implémentées dans l'interface d'appel système de la bibliothèque.

Les principales fonctionnalités de chaque composant middleware sont les suivantes :
- RTOS Microsoft® Azure®
  - Azure® RTOS ThreadX : un système d'exploitation en temps réel (RTOS), conçu pour les systèmes embarqués avec deux modes fonctionnels.
    - Mode commun : fonctionnalités RTOS courantes telles que la gestion et la synchronisation des threads, la gestion des pools de mémoire, la messagerie et la gestion des événements.
    - Mode module : un mode utilisateur avancé qui permet le chargement et le déchargement de modules ThreadX préliés à la volée via un gestionnaire de modules.
  - NetX Duo
  - FileX
  - USBX
- Bluetooth® Low Energy (BLE) : implémente le protocole Bluetooth® Low Energy pour les couches Link et Stack.
- MCUboot (logiciel open source)
- Protocoles Zigbee® pour la pile et les clusters associés.
- Pile de protocoles Thread® et couche de liaison.
- Firmware de confiance Arm®-M, TF‑M (logiciel open source) : implémentation de référence de l'architecture de sécurité de la plateforme Arm® (PSA) pour TrustZone® avec les services sécurisés associés.
- mbed-crypto (logiciel open source) : le middleware mbed-crypto fournit une implémentation d'API de cryptographie PSA.
- Bibliothèque de détection tactile STM32 : solution de détection tactile capacitive STMTouch robuste, prenant en charge les capteurs tactiles de proximité, tactiles, linéaires et rotatifs. Il repose sur un principe éprouvé d’acquisition par transfert de charges de surface.

Exampchiers basés sur les composants middleware
Chaque composant middleware est livré avec un ou plusieurs exampfichiers (également appelés applications) montrant comment l'utiliser. Intégration exampDes chiers utilisant plusieurs composants middleware sont également fournis.

Package du micrologiciel STM32CubeWBA terminéview

Appareils et matériel de la série STM32WBA pris en charge

STM32Cube offre une couche d'abstraction matérielle (HAL) hautement portable construite autour d'une architecture générique. Il permet le principe des couches superposées, comme l'utilisation de la couche middleware pour implémenter leurs fonctions sans savoir en profondeur quel MCU est utilisé. Cela améliore la réutilisabilité du code de la bibliothèque et garantit une portabilité facile vers d'autres appareils.

De plus, grâce à son architecture en couches, le STM32CubeWBA offre une prise en charge complète de toutes les séries STM32WBA.
L'utilisateur n'a qu'à définir la bonne macro dans stm32wbaxx.h.

Le tableau 1 présente la macro à définir en fonction du périphérique de la série STM32WBA utilisé. Cette macro doit également être définie dans le préprocesseur du compilateur.
Tableau 1. Macros pour la série STM32WBA

Macro définie dans stm32wbaxx.h	Appareils de la série STM32WBA
stm32wba52xx	STM32WBA52CGU6, STM32WBA52KGU6, STM32WBA52CEU6, STM32WBA52KEU6
stm32wba55xx	STM32WBA55CGU6, STM32WBA55CGU6U, STM32WBA55CGU7, STM32WBA55CEU6, STM32WBA55CEU7

STM32CubeWBA dispose d'un riche ensemble d'exampfichiers et applications à tous les niveaux, ce qui facilite la compréhension et l'utilisation de tout pilote ou composant middleware HAL. Ces exampLes chiers fonctionnent sur les cartes STMicroelectronics répertoriées dans le tableau 2.
Tableau 2. Cartes pour la série STM32WBA

Conseil Carte des appareils pris en charge par STM32WBA

NUCLÉO-WBA52CG STM32WBA52CGU6

NUCLÉO-WBA55CG STM32WBA55CGU6

STM32WBA55-DK1 STM32WBA55CGU7
Le package MCU STM32CubeWBA peut fonctionner sur n'importe quel matériel compatible. L'utilisateur met simplement à jour les pilotes BSP pour porter l'ex fourni.ampchiers sur la carte, si celle-ci possède les mêmes caractéristiques matérielles (telles que LED, écran LCD et boutons).

Package du micrologiciel terminéview

La solution du package STM32CubeWBA est fournie dans un seul package zip ayant la structure illustrée à la figure 3. Structure du package du micrologiciel STM32CubeWBA.
Pour chaque planche, un ensemble d'examples est fourni avec des projets préconfigurés pour les chaînes d'outils EWARM, MDK-ARM et STM32CubeIDE.

Figure 4. STM32CubeWBA examples finisview montre la structure du projet pour les cartes NUCLEO‑WBA52CG, NUCLEO-WBA55CG et STM32WBA55G-DK1.
L'exampLes fichiers sont classés en fonction du niveau STM32Cube auquel ils s'appliquent et sont nommés comme suit :
- Niveau 0 examples fichiers sont appelés Examples, Examples_LL, et Examples_MIX. Ils utilisent respectivement des pilotes HAL, des pilotes LL et un mélange de pilotes HAL et LL sans aucun composant middleware.
- Niveau 1 exampLes fichiers sont appelés Applications. Ils fournissent des cas d’utilisation typiques de chaque composant middleware. Toute application de firmware pour une carte donnée peut être rapidement construite grâce aux projets modèles disponibles dans les répertoires Templ ates et Templates_LL.

Projets activés par TrustZone®

TrustZone® activé ExampLes noms de fichiers contiennent le préfixe _TrustZone. La règle s'applique également aux applications (sauf pour TFM et SBSFU, qui sont nativement pour TrustZone®).
Ex compatible TrustZone®ampLes fichiers et applications sont fournis avec une structure multiprojet composée de sous-projets sécurisés et non sécurisés, comme présenté dans la figure 5. Structure de projet multiprojet sécurisé et non sécurisé.
Les projets compatibles TrustZone® sont développés selon le modèle de périphérique CMSIS-5, étendu pour inclure l'en-tête de partitionnement du système. file cloison_ .h, qui est principalement responsable de la configuration de l'unité d'attribut sécurisé (SAU), du FPU et de l'affectation des interruptions sécurisées/non sécurisées dans l'état d'exécution sécurisé.

Cette configuration est effectuée dans la fonction sécurisée CMSIS SystemInit(), qui est appelée au démarrage avant d'entrer dans la fonction main() de l'application sécurisée. Reportez-vous à la documentation Arm® TrustZone®-M relative aux directives logicielles.
Le package du micrologiciel STM32CubeWBA fournit un partitionnement de mémoire par défaut dans la partition _ .h files disponibles sous : \Drivers\CMSIS\Device\ST\STM32WBAxx\Include\T emplates

Dans ces partitions files, le SAU est désactivé par défaut. Par conséquent, le mappage de mémoire IDAU est utilisé pour l’attribution de sécurité. Reportez-vous à la figure Partitionnement sécurisé/non sécurisé à l'aide de la technologie TrustZone® dans le manuel de référence RM0495.
Si l'utilisateur active la SAU, une configuration de régions SAU par défaut est prédéfinie dans la partition. files comme suit:
- Région SAU 0 : 0x08080000 – 0x081FFFFF (moitié sécurisée non sécurisée de la mémoire flash (512 Ko))
- Région SAU 1 : 0x0BF88000 – 0x0BF97FFF (mémoire système non sécurisée)
- Région SAU 2 : 0x0C07E000 – 0x0C07FFFF (appelable sécurisé et non sécurisé)
- Région SAU 3 : 0x20010000 – 0x2001FFFF (SRAM2 non sécurisée (64 Ko))
- Région SAU 4 : 0x40000000 – 0x4FFFFFFF (mémoire mappée périphérique non sécurisée)
Pour correspondre au partitionnement par défaut, les appareils de la série STM32WBAxx doivent avoir les octets d'option utilisateur suivants définis :
- TZEN = 1 (appareil compatible TrustZone®)
- SECWM1_PSTRT = 0x0 SECWM1_PEND = 0x3F (64 pages sur 128 de la mémoire flash interne définies comme sécurisées) Remarque : La mémoire flash interne est entièrement sécurisée par défaut en TZEN = 1. Les octets d'option utilisateur SECWM1_PSTRT/ SECWM1_PEND doivent être définis en fonction de l'application. configuration de la mémoire (régions SAU, si SAU est activé). Éditeur de projets d'applications sécurisées/non sécurisées fileLes s doivent également être alignés.
Tous les examples chiers ont la même structure :
- Dossier \Inc contenant tous les en-têtes files.
- Dossier Src contenant le code source.
- Dossiers \EWARM, \MDK-ARM et \STM32CubeIDE contenant le projet préconfiguré pour chaque chaîne d'outils.
- readme.md et readme.html décrivant l'example comportement et l’environnement nécessaire pour que cela fonctionne.
- CIO file qui permet aux utilisateurs d'ouvrir la plupart des ex firmwareampfichiers dans STM32CubeMX.

Premiers pas avec STM32CubeWBA

Diriger un premier ex HALample

Cette section explique à quel point il est simple d'exécuter le premier exampchier dans STM32CubeWBA. Il utilise comme illustration la génération d'une simple bascule LED fonctionnant sur la carte NUCLEO-WBA52CG :

Téléchargez le package MCU STM32CubeWBA.

Décompressez-le dans un répertoire de votre choix.
Assurez-vous de ne pas modifier la structure du package illustrée dans la figure 1. Il est également recommandé de copier le package dans un emplacement proche de votre volume racine (c'est-à-dire C:\ST ou G:\Tests), car certains IDE rencontrent des problèmes lorsque le chemin la longueur est trop longue.

Exécution d'un premier ex activé par TrustZone®ample

Avant de charger et d'exécuter un ex activé par TrustZone®ample, il est obligatoire de lire l'example fichier readme file pour toute configuration spécifique, qui garantit que la sécurité est activée comme décrit dans la section 4.2.1 Projets activés par TrustZone® (TZEN=1 (octet d'option utilisateur)).
1. Accédez à \Projets\NUCLEO-WBA52CG\Examples.
2. Ouvrez les dossiers \GPIO, puis \GPIO_IOToggle_TrustZone.
3. Ouvrez le projet avec votre chaîne d'outils préférée. Un passage rapideview sur la façon d'ouvrir, de construire et de gérer un example fichier avec les chaînes d’outils prises en charge est indiqué ci-dessous.
4. Reconstruire en séquence tous les projets sécurisés et non sécurisés files et chargez les images sécurisées et non sécurisées dans la mémoire cible.
5. Exécutez l'example : régulièrement, l'application sécurisée bascule LD2 toutes les secondes, et l'application non sécurisée bascule LD3 deux fois plus vite. Pour plus de détails, reportez-vous au fichier Lisez-moi file de l'example.

Pour ouvrir, construire et gérer un example avec les chaînes d'outils prises en charge, suivez les étapes ci-dessous :
- CHAUD :
  1. Sous l'example dossier, ouvrez le sous-dossier \EWARM.
  2. Lancez l'espace de travail Project.eww
  3. Reconstruire le projet sécurisé xxxxx_S files : [Projet]>[Tout reconstruire].
  4. Définissez le projet non sécurisé xxxxx_NS comme application active (clic droit sur le projet xxxxx_NS [Définir comme actif])
  5. Reconstruire le projet non sécurisé xxxxx_NS files : [Projet]>[Tout reconstruire].
  6. Flashez le binaire non sécurisé avec [Project]>[Download]>[Download active application] .
  7. Définissez xxxxx_S comme application active (clic droit sur le projet xxxxx_S [Définir comme actif].
  8. Flashez le binaire sécurisé avec [Télécharger et Déboguer] (Ctrl+D).
  9. Exécutez le programme : [Debug]>[Go(F5)]
- MDK-ARM :
  1. Ouvrez la chaîne d'outils \MDK-ARM.
  2. Ouvrez l'espace de travail Multiprojets file Projet.uvmpw.
  3. Sélectionnez le projet xxxxx_s comme application active ([Définir comme projet actif]).
  4. Générez le projet xxxxx_s.
  5. Sélectionnez le projet xxxxx_ns comme projet actif ([Définir comme projet actif]).
  6. Générez le projet xxxxx_ns.
  7. Chargez le binaire non sécurisé ([F8]). Cela télécharge \MDK-ARM\xxxxx_ns\Exe\xxxxx_ns.axf dans la mémoire flash)
  8. Sélectionnez le projet Project_s comme projet actif ([Définir comme projet actif]).
  9. Chargez le binaire sécurisé ([F8]). Cela télécharge \MDK-ARM\xxxxx_s\Exe\xxxxx_s.axf dans la mémoire flash).
  10. Exécutez l'example.
- STM32CubeIDE :
  1. Ouvrez la chaîne d'outils STM32CubeIDE.
  2. Ouvrez l'espace de travail Multiprojets file .projet.
  3. Reconstruisez le projet xxxxx_Secure.
  4. Reconstruisez le projet xxxxx_NonSecure.
  5. Lancez l'application [Debug as STM32 Cortex-M C/C++] pour le projet sécurisé.
  6. Dans la fenêtre [Modifier la configuration], sélectionnez le panneau [Démarrage] et ajoutez l'image et les symboles du projet non sécurisé.
    Important: Le projet non sécurisé doit être chargé avant le projet sécurisé.
  7. Cliquez sur OK].
  8. Exécutez l'example sur la perspective du débogage.

Exécuter une première TrustZone® ex désactivéample

Avant de charger et d'exécuter une TrustZone® désactivée example, il est obligatoire de lire l'example fichier readme file pour toute configuration spécifique. S'il n'y a pas de mentions spécifiques, assurez-vous que la sécurité du périphérique de la carte est désactivée (TZEN=0 (octet d'option utilisateur)). Voir FAQ pour effectuer la régression facultative vers TZEN = 0
1. Accédez à \Projets\NUCLEO-WBA52CG\Examples.
2. Ouvrez les dossiers \GPIO, puis \GPIO_EXTI.
3. Ouvrez le projet avec votre chaîne d'outils préférée. Un passage rapideview sur la façon d'ouvrir, de construire et de gérer un example fichier avec les chaînes d’outils prises en charge est indiqué ci-dessous.
4. Reconstruire tout files et chargez votre image dans la mémoire cible.
5. Exécutez l'example : Chaque fois que le bouton-poussoir [USER] est enfoncé, la LED LD1 bascule. Pour plus de détails, reportez-vous au fichier Lisez-moi file de l'example.
Pour ouvrir, construire et gérer un example avec les chaînes d'outils prises en charge, suivez les étapes ci-dessous :
- CHAUD :
  1. Sous l'example dossier, ouvrez le sous-dossier \EWARM.
  2. Lancez l'espace de travail Project.eww (le nom de l'espace de travail peut changer d'un ancienample à un autre).
  3. Reconstruire tout files : [Projet]>[Tout reconstruire].
  4. Chargez l'image du projet : [Projet]>[Debug].
  5. Exécuter le programme : [Debug]>[Go (F5)].
- MDK-ARM :
  1. Sous l'example dossier, ouvrez le sous-dossier \MDK-ARM.
  2. Lancez l'espace de travail Project.uvproj (le nom de l'espace de travail peut changer d'un example à un autre).
  3. Reconstruire tout files:[Projet]>[Reconstruire toutes les cibles files].
  4. Chargez l'image du projet : [Debug]>[Start/Stop Debug Session].
  5. Exécuter le programme : [Debug]>[Exécuter (F5)].
- STM32CubeIDE :
  1. Ouvrez la chaîne d'outils STM32CubeIDE.
  2. Cliquez sur [File]>[Changer d'espace de travail]>[Autre] et accédez au répertoire de l'espace de travail STM32CubeIDE.
  3. Cliquez sur [File]>[Importer] , sélectionnez [Général]>[Projets existants dans l'espace de travail], puis cliquez sur [Suivant].
  4. Accédez au répertoire de l'espace de travail STM32CubeIDE et sélectionnez le projet.
  5. Reconstruire tout le projet files : Sélectionnez le projet dans la fenêtre [Explorateur de projet] puis cliquez sur le menu [Projet]>[Construire le projet].
  6. Exécutez le programme : [Exécuter]>[Debug (F11)]

Développement d'une application personnalisée

Note: Le logiciel doit permettre au cache d'instructions (ICACHE) d'obtenir une exécution en état d'attente 0 à partir de la mémoire flash, et d'atteindre des performances maximales et une meilleure consommation d'énergie.

Utiliser STM32CubeMX pour développer ou mettre à jour une application

Dans le package MCU STM32CubeWBA, presque tous les ex-projetsampLes fichiers sont générés avec l'outil STM32CubeMX pour initialiser le système, les périphériques et le middleware.
L’utilisation directe d’un projet existant exampLe fichier de l'outil STM32CubeMX nécessite STM32CubeMX 6.10.0 ou supérieur :
- Après l'installation de STM32CubeMX, ouvrez et si nécessaire mettez à jour un projet proposé. Le moyen le plus simple d'ouvrir un projet existant est de double-cliquer sur le fichier *.ioc file pour que STM32CubeMX ouvre automatiquement le projet et sa source files.
- STM32CubeMX génère le code source d'initialisation de ces projets. Le code source principal de l'application est contenu par les commentaires « USER CODE BEGIN » et « USER CODE END ». Dans le cas où la sélection et le paramètre IP sont modifiés, STM32CubeMX met à jour la partie d'initialisation du code mais préserve le code source principal de l'application.
Pour développer un projet personnalisé dans le STM32CubeMX, suivez le processus étape par étape :
1. Sélectionnez le microcontrôleur STM32 qui correspond à l'ensemble de périphériques requis.
2. Configurez tous les logiciels embarqués requis à l'aide d'un résolveur de conflits de brochage, d'un assistant de configuration d'arbre d'horloge, d'un calculateur de consommation d'énergie et de l'utilitaire effectuant la configuration des périphériques MCU (tels que GPIO ou USART) et des piles de middleware (telles que USB).
3. Générez le code C d'initialisation en fonction de la configuration sélectionnée. Ce code est prêt à être utilisé dans plusieurs environnements de développement. Le code utilisateur est conservé lors de la prochaine génération de code.
Pour plus d'informations sur STM32CubeMX, reportez-vous au manuel d'utilisation STM32CubeMX pour la configuration STM32 et la génération de code C d'initialisation (UM1718).
Pour une liste des projets disponibles exampfichiers pour STM32CubeWBA, reportez-vous à la note d'application du firmware STM32Cube exampchiers pour la série STM32WBA (AN5929).

Applications de pilote

Demande HAL
Cette section décrit les étapes requises pour créer une application HAL personnalisée à l'aide de STM32CubeWBA :

Créer un projet
- Pour créer un nouveau projet, démarrez soit à partir du projet modèle fourni pour chaque carte sous \Projets\ \Modèles ou à partir de n'importe quel projet disponible sous \Projets\ \Exemples ou \Projets\ \Applications (où fait référence au nom de la carte, tel que STM32CubeWBA).
- Le projet Template fournit une fonction de boucle principale vide. Cependant, c'est un bon point de départ pour comprendre les paramètres du projet STM32CubeWBA. Le modèle présente les caractéristiques suivantes :
  - Il contient le code source HAL, les pilotes CMSIS et BSP, qui constituent l'ensemble minimum de composants requis pour développer un code sur une carte donnée.
  - Il contient les chemins inclus pour tous les composants du micrologiciel.
  - Il définit les périphériques de la série STM32WBA pris en charge, permettant aux pilotes CMSIS et HAL d'être configurés correctement.
  - Il fournit à l'utilisateur prêt à l'emploi fileest préconfiguré comme indiqué ci-dessous :
    HAL initialisé avec la base de temps par défaut avec le noyau Arm® SysTick. SysTick ISR implémenté à des fins HAL_Delay().
    Note: Lorsque vous copiez un projet existant vers un autre emplacement, assurez-vous que tous les chemins inclus sont mis à jour.
Ajouter le middleware nécessaire au projet utilisateur (facultatif)
Pour identifier la source files à ajouter au projet file liste, reportez-vous à la documentation fournie pour chaque middleware. Reportez-vous aux applications sous \Projects\STM32xxx_yyy\Applications\ (où fait référence à la pile middleware, telle que ThreadX) pour savoir quelle source files et inclure des chemins doivent être ajoutés.
Configurer les composants du micrologiciel
Les composants HAL et middleware offrent un ensemble d'options de configuration au moment de la construction à l'aide de macros #define déclarées dans un en-tête file. Une configuration de modèle file est fourni dans chaque composant, qui doit être copié dans le dossier du projet (généralement le fichier de configuration file est nommé xxx_conf_template.h, le mot _template doit être supprimé lors de sa copie dans le dossier du projet). La configuration file fournit suffisamment d’informations pour comprendre l’impact de chaque option de configuration. Des informations plus détaillées sont disponibles dans la documentation fournie pour chaque composant.
Démarrer la bibliothèque HAL
Après avoir accédé au programme principal, le code de l'application doit appeler l'API HAL_Init() pour initialiser la bibliothèque HAL, qui effectue les tâches suivantes :
- Configuration de la prélecture de la mémoire flash et de la priorité d'interruption SysTick (via des macros définies dans st m32wbaxx_hal_conf.h).
- Configuration du SysTick pour générer une interruption toutes les millisecondes à la priorité d'interruption SysTick TICK_INT_PRIO définie dans stm32wbaxx_hal_conf.h.
- Réglage de la priorité du groupe NVIC à 0.
- Appel de la fonction de rappel HAL_MspInit() définie dans l'utilisateur stm32wbaxx_hal_msp.c file pour effectuer des initialisations matérielles globales de bas niveau.
Configurer l'horloge système
La configuration de l'horloge système se fait en appelant les deux API décrites ci-dessous :
- HAL_RCC_OscConfig() : cette API configure les oscillateurs internes et externes. L'utilisateur choisit de configurer un ou tous les oscillateurs.
- HAL_RCC_ClockConfig() : cette API configure la source d'horloge système, la latence de la mémoire flash et les préscalers AHB et APB.
Initialiser le périphérique
- Écrivez d’abord la fonction périphérique HAL_PPP_MspInit. Procédez comme suit:
  - Activez l’horloge périphérique.
  - Configurez les GPIO périphériques.
  - Configurez le canal DMA et activez l'interruption DMA (si nécessaire).
  - Activez l’interruption périphérique (si nécessaire).
- Modifiez le fichier stm32xxx_it.c pour appeler les gestionnaires d'interruption requis (périphérique et DMA), si nécessaire.
- Écrivez les fonctions de rappel complètes du processus, si une interruption périphérique ou un DMA est prévu pour être utilisé.
- Dans l'utilisateur main.c file, initialisez la structure du handle du périphérique puis appelez la fonction HAL_PPP_Init() pour initialiser le périphérique.
Développer une application
- À ce stadetage, le système est prêt et le développement du code de l'application utilisateur peut commencer.
- Le HAL fournit des API intuitives et prêtes à l'emploi pour configurer le périphérique. Il prend en charge les interrogations, les interruptions et un modèle de programmation DMA, pour répondre à toutes les exigences des applications. Pour plus de détails sur l'utilisation de chaque périphérique, reportez-vous au riche exampensemble de fichiers fournis dans le package MCU STM32CubeWBA.
  Prudence: Dans l'implémentation par défaut de HAL, le timer SysTick est utilisé comme base de temps : il génère des interruptions à intervalles de temps réguliers. Si HAL_Delay() est appelé depuis le processus ISR périphérique, assurez-vous que l'interruption SysTick a une priorité plus élevée (numériquement inférieure) que l'interruption périphérique. Sinon, le processus ISR de l'appelant est bloqué. Les fonctions affectant les configurations de base de temps sont déclarées comme __weak pour permettre le remplacement en cas d'autres implémentations chez l'utilisateur file (en utilisant une minuterie à usage général, par ex.ample, ou une autre source de temps). Pour plus de détails, reportez-vous à l'ex HAL_TimeBaseample.

Demande de LL
Cette section décrit les étapes nécessaires pour créer une application LL personnalisée à l'aide de STM32CubeWBA.

Créer un projet
- Pour créer un nouveau projet, soit démarrez à partir du projet Templates_LL fourni pour chaque carte sous \Projects\ \Templates_LL, ou depuis n'importe quel projet disponible sous \Projects\ \Examples_LL ( fait référence au nom de la carte, tel que NUCLEO-WBA32CG).
- Le projet modèle fournit une fonction de boucle principale vide, ce qui constitue un bon point de départ pour comprendre les paramètres du projet pour STM32CubeWBA. Les principales caractéristiques du modèle sont les suivantes :
  - Il contient les codes sources des pilotes LL et CMSIS, qui constituent l'ensemble minimum de composants nécessaires pour développer du code sur une carte donnée.
  - Il contient les chemins inclus pour tous les composants du micrologiciel requis.
  - Il sélectionne le périphérique de la série STM32WBA pris en charge et permet la configuration correcte des pilotes CMSIS et LL.
  - Il fournit à l'utilisateur prêt à l'emploi files qui sont préconfigurés comme suit :
    ◦ main.h : couche d'abstraction de définition LED et USER_BUTTON.
    ◦ main.c : configuration de l'horloge système pour une fréquence maximale.
Portez un projet existant vers une autre carte
Pour prendre en charge un projet existant sur une autre carte cible, démarrez à partir du projet Templates_LL fourni pour chaque carte et disponible sous \Projets\ \Templates_LL.
- Sélectionnez un ex LLample : Pour retrouver le plateau sur lequel LL examples chiers sont déployés, se référer à la liste des ex LLamples STM32CubeProjectsList.html.
Portez l'ex LLample:
- Copiez/collez le dossier Templates_LL – pour conserver la source initiale – ou mettez directement à jour le projet Temp lates_LL existant.
- Ensuite le portage consiste principalement à remplacer Templates_LL files par l'Exampprojet ciblé les_LL.
- Conservez toutes les pièces spécifiques à la carte. Pour des raisons de clarté, les pièces spécifiques à la carte sont signalées par un tags:
- Ainsi, les principales étapes du portage sont les suivantes :
  - Remplacez le stm32wbaxx_it.h file
  - Remplacez le stm32wbaxx_it.c file
  - Remplacez le main.h file et mettez-le à jour : conservez la définition des LED et des boutons utilisateur du modèle LL sous CONFIGURATION SPÉCIFIQUE À LA CARTE tags.
  - Remplacez le main.c file et mettez-le à jour :
- Conservez la configuration de l'horloge de la fonction de modèle LL SystemClock_Config() sous CONFIGURATION SPÉCIFIQUE À LA CARTE tags.
- En fonction de la définition de la LED, remplacez chaque occurrence LDx par une autre LDy disponible dans le main.h file.
- Avec ces modifications, l'example s'exécute maintenant sur la carte ciblée

Applications de sécurité
Ce package est livré avec les applications de sécurité.

Candidatures SBSFU

SBSFU fournit une solution Root of Trust, comprenant les fonctionnalités Secure Boot et Secure Firmware Update (basées sur MCUboot).
La solution est utilisée avant d'exécuter l'application.
La solution fournit un example d'un service sécurisé (bascule GPIO), isolé de l'application non sécurisée. L'application non sécurisée au moment de l'exécution peut toujours utiliser cette solution.

Applications TFM
Le TFM fournit une solution Root of Trust comprenant des fonctionnalités de démarrage sécurisé et de mise à jour sécurisée du micrologiciel.
(basé sur MCUboot). La solution est utilisée avant d'exécuter l'application. La solution fournit des services sécurisés TFM isolés de l'application non sécurisée. L'application non sécurisée au moment de l'exécution peut toujours utiliser cette solution.

Applications RF
L'application RF est décrite dans cette note d'application : Création d'applications sans fil avec les microcontrôleurs de la série STM32WBA (AN5928).

Obtenir les mises à jour de la version STM32CubeWBA
Les dernières versions et correctifs du package MCU STM32CubeWBA sont disponibles auprès de la série STM32WBA. Ils peuvent être récupérés à partir du bouton CHECK FOR UPDATE dans STM32CubeMX. Pour plus de détails, reportez-vous à la section 3 du manuel d'utilisation STM32CubeMX pour la configuration STM32 et la génération de code C d'initialisation (UM1718).

FAQ

Quand dois-je utiliser les pilotes HAL au lieu des pilotes LL ?
- Les pilotes HAL offrent des API de haut niveau et orientées fonctions, avec un haut niveau de portabilité. La complexité du produit ou des périphériques est cachée pour les utilisateurs finaux.
- Les pilotes LL offrent des API de niveau registre de couche inférieure, avec une meilleure optimisation mais moins portables. Ils nécessitent une connaissance approfondie des spécifications du produit ou de la propriété intellectuelle.
Puis-je utiliser les pilotes HAL et LL ensemble ? Si je peux, quelles sont les contraintes ?
- Il est possible d'utiliser à la fois les pilotes HAL et LL. Utilisez le HAL pour la phase d'initialisation IP, puis gérez les opérations d'E/S avec les pilotes LL.
- La principale différence entre HAL et LL réside dans le fait que les pilotes HAL nécessitent de créer et d'utiliser des handles pour la gestion des opérations, tandis que les pilotes LL fonctionnent directement sur les registres périphériques. Le EXamples_MIX example illustre comment mélanger HAL et LL.
Comment les API d'initialisation LL sont-elles activées ?
- La définition des API d'initialisation LL et des ressources associées (Structures, littéraux et prototypes) est conditionnée par le commutateur de compilation USE_FULL_LL_DRIVER.
- Pour pouvoir utiliser les API d'initialisation LL, ajoutez ce commutateur dans le préprocesseur du compilateur de chaîne d'outils.
Comment STM32CubeMX peut-il générer du code basé sur un logiciel embarqué ?
STM32CubeMX possède une connaissance intégrée des microcontrôleurs STM32, y compris leurs périphériques et logiciels qui permettent de fournir une représentation graphique à l'utilisateur et de générer *.h ou *.c files basés sur la configuration de l'utilisateur.

AVIS IMPORTANT – À LIRE ATTENTIVEMENT

STMicroelectronics NV et ses filiales (« ST ») se réservent le droit d'apporter des modifications, des corrections, des améliorations et des perfectionnements aux produits ST et/ou au présent document à tout moment et sans préavis. Les acheteurs doivent se procurer les dernières informations pertinentes sur les produits ST avant de passer commande. Les produits ST sont vendus conformément aux conditions générales de vente de ST en vigueur au moment de l'accusé de réception de la commande.
Les acheteurs sont seuls responsables du choix, de la sélection et de l'utilisation des produits ST et ST n'assume aucune responsabilité pour l'assistance à l'application ou la conception des produits des acheteurs.
Aucune licence, expresse ou implicite, sur aucun droit de propriété intellectuelle n'est accordée par ST ici.
La revente de produits ST avec des dispositions différentes des informations énoncées dans le présent document annulera toute garantie accordée par ST pour ce produit.
ST et le logo ST sont des marques déposées de ST. Pour plus d'informations sur les marques ST, consultez www.st.com/trademarks. Tous les autres noms de produits ou de services sont la propriété de leurs propriétaires respectifs.
Les informations contenues dans ce document remplacent et annulent les informations précédemment fournies dans toutes les versions antérieures de ce document.

Documents / Ressources

Mise en route de la série STMicroelectronics STM32WBA [pdf] Manuel de l'utilisateur
Série STM32WBA Mise en route, Mise en route, Démarrage

Références

Manuel d'utilisation

Mise en route de la série STMicroelectronics STM32WBA

Informations sur le produit

Instructions d'utilisation du produit

FAQ