Maîtrise rapide des microcontrôleurs STM32. Commençons par étudier Cortex-M en utilisant le STM32 comme exemple

pendant que(condition) (

corps de boucle

Le corps de la boucle (tout entre accolades) est exécuté lorsque la condition est vraie (jusqu'à ce que la condition devienne fausse).

pour (valeur_initiale ; boucle_exécutée_jusqu'à, étape) (

corps de boucle

Valeur initiale- valeur initiale du compteur

Boucle_runs_jusqu'à - Jusqu'à quelle valeur est atteinte, la boucle s'exécute

Étape -à quelles étapes le compteur compte-t-il ?

Par exemple

pour (i=0; je<10, i++) {

corps de boucle

Voici la valeur initiale de la variable je est égal à 0, la boucle s'exécute jusqu'à la valeur de la variable je inférieur à 10, à chaque fois que la boucle est exécutée sur une variable je 1 est ajouté. Vous pouvez également modifier la valeur d'une variable directement dans la boucle.

si (condition)(

corps 1

) autre (

corps 2

Dans une transition conditionnelle, « corps 1 » est exécuté si la condition est vraie et « corps 2 » est exécuté si la condition est fausse. Il y a aussi cette option :

si (condition 1)(

) sinon si (condition 2) (

Dans ce cas, « corps 1 » est exécuté si la « condition 1 » est vraie, « corps 2 » est exécuté si « condition 2 » est vraie. Il peut y avoir un certain nombre de ces conditions, mais il peut aussi y en avoir une autre.

Les conditions peuvent être simples et composées : simples - une expression logique, et composées - plusieurs expressions logiques reliées par le signe & (les conditions sont vraies lorsque toutes les conditions reliées par ce signe sont vraies) ou | (une condition est vraie si au moins une condition reliée par ce signe est vraie).

Une autre chose utile, ce sont les commentaires. Ils vous aideront à retrouver un projet oublié :) ou simplement pour que vous n'oubliiez rien. Vous pouvez commenter soit après les panneaux // et jusqu'à la fin de la ligne ou commencer par les caractères /* et fin */ , dans ce cas, le commentaire peut comporter n'importe quel nombre de lignes. Les commentaires n'affectent pas la taille du programme.

Eh bien, cela semble être une question de base. Assez pour la première fois (jusqu'à la rédaction de la prochaine partie de l'article)

Premier programme

Ne nous écartons pas des traditions (sinon on ne sait jamais) et commençons par Hello World. Et en cours de route, nous continuerons à nous familiariser avec le microcontrôleur et à acquérir de l'expérience, pour ainsi dire.

Ouvrez l'environnement de développement :

Cliquez sur Parcourir dans le référentiel

Choisir ST

Ensuite, nous verrons une liste des bibliothèques connectées.

Pour notre programme simple, nous aurons besoin de : Noyau du CMSIS, Démarrage CMSIS, RCC, GPIO.

Bibliothèques Noyau du CMSIS Et Démarrage CMSIS - ceux du système, ils doivent être connectés

Bibliothèque RCC pour travailler avec un système de chronométrage

Bibliothèque GPIO pour travailler avec les ports E/S

Maintenant à gauche dans la fenêtre Projet ouvrir le fichier principal c.

Nous devons d’abord connecter nos bibliothèques (CMSIS n’a pas besoin d’être connecté).

On va au tout début du programme et on ajoute les lignes :

#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"

void Délai (int i) (
pour (; je != 0; je--);
}

Donc. Ici dans l'ordre, la fonction ne renvoie rien, donc vide, nom de la fonction Retard, déclarez immédiatement la variable je taper int. Entre accolades, le corps de la fonction est une boucle pour. C'est son entrée de ligne. Valeur initiale je on ne change pas, la boucle continue jusqu'à je n'est pas égal à zéro (comme je devient égal à zéro, le cycle s'arrête, la fonction est « désactivée »). A chaque exécution du corps de la boucle (cycle), la variable je diminue de 1. C'est-à-dire L’essence du cycle est simplement de se répéter un nombre égal de fois je. Pendant que la boucle s'exécute, le temps passe, un retard se produit.

Quel port est responsable de quelle sortie peut être trouvé dans la documentation du MK :

Pour synchroniser le port C, ajoutez la ligne :

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC , ENABLE);

Ajoutez la ligne au programme :

GPIO_InitTypeDef GPIO_Init1 ;

Avec cette ligne nous avons déclaré la structure GPIO_InitTypeDef- je lui ai donné un nom GPIO_Init pour une utilisation ultérieure dans notre programme.

Quels paramètres peuvent être configurés dans cette structure et quelle forme ils ont, nous regardons tout de la même manière stm32f10x_gpio.h:

Maintenant, pour configurer les paramètres de la broche à l'aide de la structure, vous devez écrire son nom, mettre un point et une fenêtre apparaîtra dans laquelle ces paramètres sont indiqués

Double-cliquez sur l'un d'eux, il apparaît dans la ligne, puis mettez = (attribuer) et écrire la valeur de stm32f10x_gpio.h

Nous faisons de même avec tous les paramètres. N'oubliez pas le point-virgule à la fin de chaque ligne !

GPIO_Init(GPIOC, &GPIO_Init);

Maintenant, nous allons cligner des yeux ! Nous clignerons des yeux de manière cyclique, nous ferons une boucle en boucle alors que. La condition du cycle sera 1. Un est toujours vrai, zéro est toujours faux... ça y est c'est la vie..

Pour appliquer du courant à la sortie, vous devez définir le bit ; pour désactiver la sortie, vous devez réinitialiser le bit. Comment faire - tout est pareil stm32f10x_gpio.h:

Nous faisons ceci :

tandis que (1)(

GPIO_SetBits(GPIOC, GPIO_Pin_9);

Retard (200 000);

GPIO_ResetBits(GPIOC, GPIO_Pin_9);

Retard (200 000);

1 est toujours vrai, ce qui signifie que la boucle sera en boucle.

GPIO_SetBits - fonction de réglage des bits

GPIO_ResetBits - fonction de réinitialisation des bits

Délai (200000) - sur cette ligne, l'exécution du programme passe à une fonction Retard, le même dans lequel le cycle pour. Le nombre 200000 entre parenthèses est passé à cette fonction en tant que variable je. (rappelez-vous la ligne Délai nul (int i)?) et la même boucle est exécutée dans cette fonction, toutes les 200 000 fois. C'est rapide :) une fois le cycle terminé pour fonction Drelais termine son travail parce que elle vide, alors il ne renvoie rien et le programme continue de s'exécuter.

Parce que alors que est bouclé, puis LED allumée, retard, LED éteinte, le retard sera effectué dans une boucle sans fin. Jusqu'à ce qu'il y ait une coupure de courant ou une interruption (plus d'informations à ce sujet dans le prochain article).

Eh bien, le premier programme est prêt. Appuyez maintenant sur F7, le programme se compile.

Maintenant, si vous avez une carte de débogage, connectez-la à l'aide d'un cordon USB et appuyez sur Télécharger le code pour flasher. Nous sommes satisfaits du travail effectué et des connaissances acquises :)

Et si vous n'avez pas de carte de débogage, connectez l'adaptateur fabriqué précédemment à votre carte et l'adaptateur au port COM de l'ordinateur. Ensuite, connectez la sortie DÉMARRAGE 0 avec l'alimentation positive du microcontrôleur et allumez le microcontrôleur. Cela fera passer le microcontrôleur en mode micrologiciel. En général, la procédure du firmware n'est pas compliquée. Il vous suffit de suivre les instructions de l'application Démonstrateur du chargeur Flash. Tout d'abord, indiquez le numéro du port COM via lequel votre microcontrôleur est connecté et la vitesse. Pour éviter les pannes, il vaut mieux choisir une vitesse inférieure

Si le programme voit votre microcontrôleur, une fenêtre apparaîtra dans laquelle il sera écrit la quantité de mémoire dont il dispose.

Après avoir cliqué sur « Suivant », vous verrez la page d'adressage de la mémoire. Nous n'en aurons pas besoin.

La prochaine étape est la plus importante. Vous pouvez choisir l'effacement de la mémoire ou le firmware

Pour le firmware, sélectionnez Télécharger sur l'appareil et sur le terrain Télécharger à partir du fichier sélectionnez le fichier .hex compilé, qui se trouve dans le dossier CooCox -> CooIDE -> espace de travail -> nom_projet -> nom_projet -> Debug -> Bin. Cliquez ensuite à nouveau sur « Suivant ».

Après avoir vu cette fenêtre :

Coupez l'alimentation du microcontrôleur et fermez Démonstrateur du chargeur Flash, débranchez l'adaptateur et allumez le microcontrôleur en mode normal (lorsque lorsqu'il est allumé la broche BOOT 0 est connectée à l'alimentation négative du microcontrôleur). Nous nous réjouissons !

Donc, maintenant nous savons pourquoi les microcontrôleurs STM sont meilleurs que les autres, nous savons comment fonctionne le microcontrôleur, nous savons comment flasher le microcontrôleur dans la carte de débogage et dans notre carte, nous connaissons les bases du langage C nécessaires pour programmer le STM32, nous avons acquis de l'expérience en travaillant avec le microcontrôleur (espérons-le positif) et le plus important est que vous puissiez désormais donner vie à vos idées d'appareils numériques (et en parler sur notre bien-aimée RadioKot) ! Ils sont peut-être encore simples, mais tout est inventé par l'expérience. Et dans les articles suivants, j'essaierai de parler des ADC, des DAC, des interruptions, de l'utilisation du débogage et d'autres choses utiles.

Toutes les images de cet article sont cliquables.

Les microcontrôleurs contiennent un cœur de microprocesseur ARM, plus précisément ARM Cortex-M. Ce noyau n'est pas seulement inhérent aux microcontrôleurs STM32, il existe en soi et de nombreux microcontrôleurs de différents fabricants sont produits sur sa base.

Ensuite on retrouve ce microcontrôleur dans la liste de gauche et on installe le package DFP correspondant :

Vous remarquerez peut-être que parmi les packages installés, il y a CMSIS. CMSIS est une bibliothèque pour le cœur Cortex-M, commune à tous les microcontrôleurs. La bibliothèque est développée par ARM et est disponible en téléchargement sur le site officiel après inscription. Il serait possible de ne pas installer ce package, mais d'utiliser la version officielle de la bibliothèque, mais ce sont des complications supplémentaires.

Fermez le gestionnaire de paquets et lancez Keil uVision5 (prononcé mu-vision) :

Keil uVision5 fait partie de MDK-ARM, un environnement GUI qui comprend un éditeur de code :

1. Encodage UTF-8.
2. La limite de code correcte est de 80 caractères.
3. Indenter de 4 espaces.

Ces paramètres sont assez controversés. Chaque développeur a ses propres préférences.

Créons maintenant un projet. Pour ce faire, sélectionnez le menu « Projet -> Nouveau projet uVision… ». Dans la fenêtre qui s'ouvre, sélectionnez l'emplacement et le nom du projet. Il est préférable de créer un dossier séparé pour le projet et d'y enregistrer le projet.

Après l'enregistrement, une fenêtre de sélection de périphérique apparaîtra. Sélectionnez le microcontrôleur souhaité et cliquez sur « OK ». Si nous n'avions pas installé le package requis, le microcontrôleur ne serait pas dans la liste :

Dans la fenêtre suivante, vous devez sélectionner les composants qui seront utilisés dans le projet. Vous devez sélectionner « CMSIS : CORE » et « Device : Startup » :

Après avoir cliqué sur « OK », le processus de création du projet sera terminé.

À l'avenir, vous pourrez toujours lancer la fenêtre de sélection des composants pour les ajouter ou les supprimer. Pour ce faire, sélectionnez le menu « Projet -> Gérer -> Environnement d'exécution... ».

Lorsque vous sélectionnez des composants, vous constaterez peut-être qu'un composant dépend d'autres composants que vous n'avez pas sélectionnés. Vous en saurez plus grâce aux messages en bas de la fenêtre. Vous devrez sélectionner les composants dépendants.

Après avoir créé un projet de la manière décrite, dans la fenêtre de droite, vous verrez la structure de projet suivante :

Ici, nous voyons le nom du projet « exemple », l'objectif du projet « Target 1 », le groupe de fichiers vide « Source Group 1 », les composants CMSIS et Device.

Il peut y avoir n’importe quel nombre d’objectifs de projet. L'objectif inclut les paramètres de projet les plus importants, y compris la sélection du microcontrôleur. Des objectifs sont nécessaires pour que vous puissiez élaborer un programme différentes façons pour les mêmes fichiers de code source. Par exemple, vous devrez peut-être que votre projet s'étende sur plusieurs microcontrôleurs.

Des groupes de fichiers sont nécessaires pour regrouper joliment les fichiers de code source. Les groupes vous aident à parcourir facilement les fichiers dans grand projet. Par exemple, vous pouvez avoir un groupe de fichiers responsables des LED et un groupe distinct avec des fichiers permettant d'interagir avec l'USB.

Dans la structure, nous voyons deux fichiers. Un avec une extension "s". Il contient du code source en langage assembleur. L'autre avec l'extension "c". Il contient du code source en langage C.

Vous pouvez créer le projet et obtenir le fichier du firmware en appuyant sur la touche F7. Mais sous cette forme, le projet ne sera pas construit et vous recevrez une erreur car la fonction « main() » est manquante.

La fonction "main()" est le point d'entrée de votre programme, là où le programme commence. Sa présence est obligatoire si vous écrivez un programme en C.

Créons cette fonction. Faites un clic droit sur le groupe « Groupe source 1 » et sélectionnez « Ajouter un nouvel élément au « Groupe source 1 »... » (traduction : ajouter un nouvel élément au « Groupe source 1 »). Créons un fichier "main.c" :

Ajoutez le code au fichier créé :

Int main() (retour 0;)

Vous devez ajouter une ligne vide à la fin du fichier, sinon lors de l'assemblage, vous recevrez un avertissement « avertissement : #1-D : la dernière ligne du fichier se termine sans nouvelle ligne ».

Le projet peut maintenant être assemblé à l'aide de la touche F7. En conséquence, vous obtiendrez le fichier « Objets\exemple.axf » (par défaut, le nom du fichier est le même que le nom du projet). Le fichier se trouve dans le dossier du projet.

En règle générale, le développeur nécessite un fichier de micrologiciel au format Intel HEX. Pour l'obtenir, vous devez configurer l'objectif. Pour voir les paramètres cibles, appuyez sur Alt-F7, allez dans l'onglet "Sortie" et sélectionnez "Créer un fichier HEX".

Après la prochaine build, vous recevrez le fichier « Objects\example.hex ».

Désormais, le programme ne fait plus rien et cela ne sert à rien de le flasher. Écrivons un programme qui contrôle l'état de la broche du microcontrôleur.

Commençons par sélectionner les composants en utilisant le menu « Projet -> Gérer -> Environnement d'exécution... » et sélectionnons le composant « Périphérique : STM32Cube Hal : GPIO ».

Au bas de la fenêtre, nous verrons la dépendance insatisfaite « Device:STM32Cube Hal:Common ». Sélectionnons ce composant et voyons une liste de dépendances encore plus grande. Vous devez sélectionner toutes les dépendances requises :

• Appareil : STM32Cube Hal : commun
• Appareil : STM32Cube Hal : RCC
• Appareil : STM32Cube Hal : PWR
• Appareil : STM32Cube Hal : Cortex
• Appareil : STM32Cube Framework : Classique

STM32Cube est une bibliothèque fournie par STMicroelectronics.

Lors du choix des composants, nous choisissons les fonctionnalités de cette bibliothèque à utiliser.

Le microcontrôleur, en plus du noyau, contient un grand nombre de périphériques : ADC, DAC, minuteries, diverses interfaces et bien plus encore. Chaque périphérique possède son propre nom. Par exemple, un périphérique permettant de travailler avec les ports du microcontrôleur s'appelle GPIO, vous pouvez en apprendre davantage à partir de la documentation du microcontrôleur.

La bibliothèque STM32Cube est multi-niveaux, c'est-à-dire qu'elle comprend de nombreuses bibliothèques intermédiaires. L'une des bibliothèques intermédiaires s'appelle STM32Cube HAL, ou simplement HAL. Il est divisé en modules et chaque module correspond à un périphérique. Le nom du module correspond au nom de l'appareil, par exemple, il existe un module GPIO.

Il existe une grande quantité de documentation pour le STM32Cube. Mais la description de base du travail avec les périphériques est contenue dans. Ceci est le guide utilisé par le développeur la plupart temps. Tournons-nous vers lui pour faire bouger les jambes du microcontrôleur.

Tout d’abord, connectons le HAL dans notre programme en ajoutant une ligne avant la définition de la fonction « main() » :

#include "stm32f4xx_hal.h"

Au tout début de la fonction « main() », on appelle la fonction « HAL_Init() », qui initialise la bibliothèque.

De cette façon, nous obtiendrons le code suivant dans le fichier "main.c":

#include "stm32f4xx_hal.h" int main() ( HAL_Init(); return 0; )

À suivre…

À ce stade, je suis obligé d'interrompre mon article, car ce moment Je n'ai rien sur lequel déboguer le programme, c'est-à-dire que je n'ai pas de carte de débogage sous la main.

J'ai écrit un programme qui est assemblé et qui devrait théoriquement fonctionner, mais je ne veux pas induire le lecteur en erreur. Je considère que le matériel ci-dessus est utile sans aucun résultat final.

#include "stm32f4xx_hal.h" int main() ( HAL_Init(); // Activer la synchronisation du port A. __HAL_RCC_GPIOA_CLK_ENABLE(); // Paramètres du port. GPIO_InitTypeDef s; s.Pin = GPIO_PIN_0; // Sortie 0. s.Mode = GPIO_MODE_OUTPUT_PP; // Sortie numérique. s.Pull = GPIO_NOPULL; // Pas de pullup. s.Speed ​​​​= GPIO_SPEED_FREQ_VERY_HIGH; // Vitesse maximale. // Configurer la broche 0 du port A. HAL_GPIO_Init(GPIOA, &s); // Basculez à l'infini l'état du port avec la vitesse maximale. while(1) ( HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_0); ) //return 0; ) void SysTick_Handler(void) ( HAL_IncTick(); )

Liens

1. Capture d'écran " Outils Eclipse et GNU pour le développement de microcontrôleurs ARM «.
2. Microcontrôleur STM32F407VG.
3. Carte de développement STM32F4-Discovery.
4. Bibliothèque STM32CubeF4.

DANS dernières années Les microcontrôleurs (MCU) 32 bits basés sur des processeurs ARM conquièrent rapidement le monde de l'électronique. Cette avancée est due à leurs hautes performances, leur architecture avancée, leur faible consommation d'énergie, leur faible coût et leurs outils de programmation avancés.

HISTOIRE COURTE
Le nom ARM est un acronyme pour Advanced RISC Machines, où RISC (Reduced Instruction Set Computer) signifie architecture de processeur à jeu d'instructions réduit. La très grande majorité des microcontrôleurs populaires, tels que les familles PIC et AVR, disposent également d'une architecture RISC, qui a augmenté les performances en simplifiant le décodage des instructions et en accélérant leur exécution. L'émergence de microcontrôleurs ARM 32 bits avancés et productifs nous permet de passer à la résolution de problèmes plus complexes que les MCU 8 et 16 bits ne peuvent plus résoudre. L'architecture du microprocesseur ARM avec un cœur de 32 bits et un jeu d'instructions RISC a été développée par la société britannique ARM Ltd, qui développe exclusivement des noyaux, des compilateurs et des outils de débogage. L'entreprise ne produit pas de MK, mais vend des licences pour leur production. MK ARM est l’un des segments du marché MK à la croissance la plus rapide. Ces appareils utilisent des technologies d'économie d'énergie, ils sont donc large application dans les systèmes embarqués et dominer le marché des appareils mobiles où une faible consommation d'énergie est importante. De plus, les microcontrôleurs ARM sont activement utilisés dans les appareils de communication, portables et intégrés où des performances élevées sont requises. Une caractéristique de l'architecture ARM est le cœur de calcul du processeur, qui n'est équipé d'aucun élément supplémentaire. Chaque développeur de processeur doit équiper indépendamment ce cœur des blocs nécessaires à ses tâches spécifiques. Cette approche a bien fonctionné pour les grands fabricants de puces, même si elle était initialement axée sur les solutions de processeurs classiques. Les processeurs ARM ont déjà traversé plusieurs étapes de développement et sont bien connus pour les familles ARM7, ARM9, ARM11 et Cortex. Ce dernier est divisé en sous-familles de processeurs CortexA classiques, de processeurs temps réel CortexR et de cœurs de microprocesseur CortexM. Ce sont les cœurs CortexM qui sont devenus la base du développement d'une large classe de MCU 32 bits. Ils diffèrent des autres variantes de l'architecture Cortex principalement par l'utilisation du jeu d'instructions Thumb2 16 bits. Cet ensemble combine les performances et la compacité des instructions ARM et Thumb « classiques » et a été développé spécifiquement pour travailler avec les langages C et C++, ce qui améliore considérablement la qualité du code. Le grand avantage des microcontrôleurs construits sur le cœur CortexM est leur compatibilité logicielle, qui permet théoriquement d'utiliser du code de programme dans le langage haut niveau dans des modèles de différents fabricants. En plus d'indiquer le domaine d'application du noyau, les développeurs MK indiquent les performances du noyau CortexM sur une échelle de dix points. Aujourd'hui, les options les plus populaires sont CortexM3 et CortexM4. Les MCU avec architecture ARM sont produits par des sociétés telles que Analog Devices, Atmel, Xilinx, Altera, Cirrus Logic, Intel, Marvell, NXP, STMicroelectronics, Samsung, LG, MediaTek, MStar, Qualcomm, SonyEricsson, Texas Instruments, nVidia, Freescale, Milander. , HiSilicon et autres.
Grâce à l'architecture optimisée, le coût des MCU basés sur le cœur CortexM est dans certains cas même inférieur à celui de nombreux appareils 8 bits. Les modèles « plus jeunes » peuvent actuellement être achetés pour 30 roubles. pour la carrosserie, ce qui crée une concurrence pour les générations précédentes de MK. MICROCONTRÔLEURS STM32 Considérons le MCU le plus abordable et le plus répandu de la famille STM32F100 de STMicroelectronics, l'un des principaux fabricants mondiaux de MCU. La société a récemment annoncé le début de la production d'un MK 32 bits tirant parti des technologies industrielles.
Cœurs STM32 dans des applications à faible coût. Les MCU de la famille STM32F100 Value line sont conçus pour les appareils où les performances des MCU 16 bits ne sont pas suffisantes et où les riches fonctionnalités des appareils 32 bits « classiques » sont redondantes. La gamme de MCU STM32F100 est basée sur un cœur ARM CortexM3 moderne avec des périphériques optimisés pour une utilisation dans des applications typiques où des MCU 16 bits ont été utilisés. Les performances du MCU STM32F100 à 24 MHz sont supérieures à celles de la plupart des MCU 16 bits. Cette ligne comprend des appareils avec différents paramètres :
● de 16 à 128 Ko de mémoire flash programme ;
● de 4 à 8 Ko de RAM ;
● jusqu'à 80 ports d'entrée/sortie GPIO ;
● jusqu'à neuf timers 16 bits avec fonctions avancées ;
● deux minuteries de surveillance ;
● CAN 12 bits haute vitesse 16 canaux ;
● deux DAC 12 bits avec générateurs de signaux intégrés ;
● jusqu'à trois interfaces UART prenant en charge les modes IrDA, LIN et ISO7816 ;
● jusqu'à deux interfaces SPI ;
● jusqu'à deux interfaces I2C prenant en charge les modes SMBus et PMBus ;
● Accès direct à la mémoire (DMA) à 7 canaux ;
● Interface CEC (Consumer Electronics Control) incluse dans la norme HDMI ;
● horloge en temps réel (RTC) ;
● Contrôleur d'interruption imbriqué NVIC.

Le schéma fonctionnel du STM32F100 est présenté à la figure 1.

Riz. 1. Architecture de la ligne MK STM32F100

Une commodité supplémentaire est la compatibilité des broches des appareils, qui permet, si nécessaire, d'utiliser n'importe quel MK de la famille avec plus de fonctionnalités et de mémoire sans retravailler le circuit imprimé. La gamme de contrôleurs STM32F100 est produite en trois types de boîtiers LQFP48, LQFP64 et LQFP100, comportant respectivement 48, 64 et 100 broches. L'affectation des broches est présentée sur les figures 2, 3 et 4. De tels boîtiers peuvent être installés sur des cartes de circuits imprimés sans utiliser d'équipement spécial, ce qui constitue un facteur important dans la production à petite échelle.

Riz. 2. MCU STM32 dans le boîtier LQFP48 Fig. 3. MCU STM32 dans le package LQFP64

Riz. 4. MCU STM32 dans le boîtier LQFP100

STM32F100 est un dispositif abordable et optimisé basé sur le cœur CortexM3, pris en charge par un environnement de développement avancé pour la famille de microcontrôleurs STM32, qui contient
Bibliothèques gratuites pour tous les périphériques, y compris la commande moteur et les claviers tactiles.

SCHÉMA DE CONNEXION STM32F100C4
Considérons l'utilisation pratique de MK en utilisant l'exemple du périphérique STM32F100C4 le plus simple, qui contient néanmoins tous les blocs principaux de la gamme STM32F100. Fondamental schéma électrique L'inclusion de STM32F100C4 est illustrée à la figure 5.


Riz. 5. Schéma de connexion pour MK STM32F100C4

Le condensateur C1 garantit la réinitialisation du MK à la mise sous tension et les condensateurs C2-C6 filtrent la tension d'alimentation. Les résistances R1 et R2 limitent le courant de signal des broches MK. L'oscillateur interne est utilisé comme source d'horloge, il n'est donc pas nécessaire d'utiliser un cristal externe.


Les entrées BOOT0 et BOOT1 vous permettent de sélectionner la méthode de chargement du MK lors de la mise sous tension conformément au tableau. L'entrée BOOT0 est connectée au bus à potentiel zéro via la résistance R2, qui protège la broche BOOT0 d'un court-circuit lorsqu'elle est utilisée comme port de sortie de PB2. À l'aide du connecteur J1 et d'un cavalier, vous pouvez modifier le potentiel à l'entrée BOOT0, déterminant ainsi comment le MK est chargé - à partir de la mémoire flash ou du chargeur de démarrage intégré. Si vous devez charger le MK depuis la RAM, un connecteur similaire avec un cavalier peut être connecté à l'entrée BOOT1.
La programmation du MK s'effectue via le port série UART1 ou via des programmeurs spéciaux - débogueurs JTAG ou STLink. Ce dernier fait partie du dispositif de débogage populaire STM32VLDISCOVERY, illustré à la figure 6. Sur la carte STM32VLDIS COVERY, le connecteur à 4 broches du programmeur - débogueur STLink - est désigné SWD. L'auteur de l'article suggère de programmer le MK via le port série UART1, car il est beaucoup plus simple, ne nécessite pas d'équipement spécial et n'est pas inférieur en vitesse à JTAG ou ST Link. Tout ordinateur personnel (PC) doté d'un port COM série ou d'un port USB avec un convertisseur USBRS232 peut être utilisé comme dispositif de contrôle capable de générer des commandes et d'afficher les résultats du programme MK, ainsi que comme programmeur.

Pour interfacer le port COM d'un PC avec un MK, tout convertisseur de signaux RS232 en niveaux de signaux logiques de 0 à 3,3 V, par exemple le microcircuit ADM3232, convient. Ligne de transmission TXD port série L'ordinateur, après le convertisseur de niveau, doit être connecté à l'entrée PA10 du microcontrôleur, et la ligne du récepteur RXD, via un convertisseur similaire, à la sortie PA9.

Si vous devez utiliser une horloge MK non volatile, vous devez y connecter une pile CR2032 avec une tension de 3 V et un résonateur à quartz avec une fréquence de 32768 Hz. À cet effet, le MK est équipé de broches Vbat/GND et OSC32_IN/OSC32_OUT. La broche Vbat doit d'abord être déconnectée du bus d'alimentation 3,3 V.

Les terminaux libres restants du MK peuvent être utilisés selon les besoins. Pour ce faire, ils doivent être connectés aux connecteurs situés autour du périmètre de la carte de circuit imprimé du MK, par analogie avec les appareils Arduino populaires et la carte de débogage STM32VLDISCOVERY.


Riz. 6. Dispositif de débogage STM32VLDISCOVERY

Schéma du circuit électrique STM32VLDISCOVERY.

Ainsi, selon le but et le mode d'utilisation du MK, vous pouvez vous y connecter éléments nécessaires pour activer d'autres blocs fonctionnels et ports, tels que ADC, DAC, SPI, I2C, etc. À l’avenir, ces appareils seront examinés plus en détail.

LA PROGRAMMATION
Aujourd'hui, de nombreuses entreprises proposent des outils pour créer et déboguer des programmes pour les microcontrôleurs STM32. Il s'agit notamment de Keil d'ARM Ltd, IAR Embedded Workbench pour ARM, Atol lic TrueStudio, CooCox IDE, GCC et Eclipse IDE. Le développeur peut choisir le logiciel selon ses préférences. Ci-dessous, nous décrirons la boîte à outils Keil uVision 4 de la société Keil, qui prend en charge un grand nombre de types de microcontrôleurs, dispose d'un système développé d'outils de débogage et peut être utilisée gratuitement avec des restrictions sur la taille du code généré de 32 Ko ( ce qui, en fait, est le maximum pour les microcontrôleurs considérés).

Démarrage facile et rapide avec CooCox CoIDE.

Alors, commençons. Accédez au site officiel de CooCox et téléchargez dernière version CooCox CoIDE. Pour télécharger, vous devez vous inscrire, l'inscription est simple et gratuite. Installez ensuite le fichier téléchargé et exécutez-le.

CooCoxCoIDE— un environnement de développement basé sur Eclipse, qui en plus de STM32 supporte un tas d'autres familles de microcontrôleurs : Freescale, Holtek, NXP, Nuvoton, TI, Atmel SAM, Energy Micro, etc. Avec chacun nouvelle version La liste CoIDE des MK est constamment mise à jour. Après avoir installé CoIDE avec succès, exécutez :

La fenêtre de démarrage de l'étape 1 apparaîtra, dans laquelle vous devrez sélectionner le fabricant de notre microcontrôleur. Appuyez sur ST et passez à l'étape 2 (sélection d'un microcontrôleur), dans laquelle vous devez sélectionner un modèle spécifique. Nous avons le STM32F100RBT6B, alors cliquez sur le modèle correspondant :

Sur la droite, la fenêtre d'aide affiche de brèves caractéristiques de chaque puce. Après avoir sélectionné le microcontrôleur dont nous avons besoin, nous passons à la troisième étape, l'étape 3 - pour sélectionner les bibliothèques nécessaires au travail :

Créons un projet simple pour faire clignoter une LED, comme il est d'usage pour l'apprentissage des microcontrôleurs.

Pour ce faire, nous avons besoin de la bibliothèque GPIO, lorsqu'elle est activée, CoIDE vous demandera de créer un nouveau projet. Cliquez sur Oui sur cette proposition, indiquez le dossier où sera stocké notre projet et son nom. Parallèlement, CoIDE connectera au projet 3 autres nécessaires au fonctionnement de la bibliothèque, et créera également toute la structure nécessaire du projet :

Un autre avantage de CoIDE est qu'il a la capacité de charger des exemples directement dans l'environnement de développement. Dans l'onglet Composants, vous pouvez voir qu'il existe des exemples pour presque toutes les bibliothèques, cliquez sur GPIO (avec 4 exemples) et voyez-les :

Vous pouvez y ajouter vos propres exemples. Comme vous pouvez le voir dans la capture d'écran ci-dessus, les exemples contiennent déjà du code pour faire clignoter la LED GPIO_Blink. Vous pouvez cliquer sur le bouton Ajouter et il sera ajouté au projet, mais en tant que fichier inclus, nous allons donc le faire différemment et copier simplement l'intégralité de l'exemple de code dans le fichier main.c. La seule chose est de remplacer la ligne void GPIO_Blink(void) par int main(void). Alors, appuyez sur F7 (ou sélectionnez Projet->Construire dans le menu) pour compiler le projet et... pas de chance !

L'environnement a besoin d'un compilateur GCC, mais nous n'en avons pas. Par conséquent, accédez à la page Outils GNU pour processeurs intégrés ARM, sélectionnez votre type de système d'exploitation sur la droite et téléchargez la dernière version de la chaîne d'outils. Ensuite, nous exécutons le fichier et installons la chaîne d'outils gcc. Ensuite, dans les paramètres CoIDE, nous indiquerons le chemin correct vers la chaîne d'outils :

Appuyez à nouveau sur F7 (Projet->Build) et vérifiez que la compilation a réussi :

Il ne reste plus qu'à flasher le microcontrôleur. Pour ce faire, nous connectons notre carte à l'ordinateur via USB. Ensuite, dans les paramètres du débogueur, vous devez installer ST-Link ; pour ce faire, sélectionnez Projet->Configuration dans le menu et ouvrez l'onglet Débogueur. Sélectionnez ST-Link dans la liste déroulante et fermez la fenêtre :

Essayons de flasher le MK. Dans le menu, sélectionnez Flash->Téléchargement du programme (ou cliquez sur l'icône correspondante dans la barre d'outils) et vérifiez que le MK a été flashé avec succès :

Nous voyons une LED clignotante sur le tableau, je pense que cela n'a aucun sens de fournir une vidéo ou une photo, car... tout le monde l'a vu.

De plus, différents modes de débogage fonctionnent dans CoIDE ; pour ce faire, appuyez sur CTRL+F5 (ou dans le menu Debug->Debug) :

C'est tout. Comme vous pouvez le constater, la configuration et l'utilisation de CoIDE sont très simples. J'espère que cet article vous encouragera à étudier les microcontrôleurs STM32 très prometteurs et peu coûteux.

Je souhaite la bienvenue à tous les amateurs de programmation, de microcontrôleurs et d'électronique en général sur notre site ! Dans cet article, je vais vous parler un peu de ce que nous allons faire ici, à savoir la formation sur les microcontrôleurs ARM.

Alors, commençons par déterminer ce que vous devez savoir et être capable de faire pour commencer à apprendre les ARM. Mais, en principe, rien de super compliqué et enchanteur 😉 Bien sûr, les gens passent généralement aux contrôleurs ARM après avoir déjà suffisamment joué avec les PIC et les AVR, c'est-à-dire que la plupart d'entre eux sont des développeurs expérimentés. Mais je vais essayer de décrire de manière aussi détaillée et claire que possible tout ce que nous analyserons, afin que ceux qui ont décidé de s'essayer à la programmation de microcontrôleurs pour la première fois puissent facilement comprendre le matériel. À propos, si vous avez des questions ou si quelque chose ne fonctionne tout simplement pas comme prévu, écrivez dans les commentaires, j'essaierai de comprendre et de vous aider.

Passons maintenant aux problèmes techniques) Plusieurs fois j'ai déjà évoqué le nom « Formation ARM", mais, dans l'ensemble, ce n'est pas tout à fait vrai. Il n’existe pas de microcontrôleur ARM. Il existe un contrôleur avec un noyau ARM (!), mais cela, voyez-vous, n'est toujours pas la même chose. Ainsi, de tels dispositifs sont produits par un certain nombre de sociétés, parmi lesquelles se distinguent STMicroelectronics et NXP Semiconductors. En conséquence, ils produisent des contrôleurs STM et LPC. J'ai opté pour le STM32, je les préférais juste =) C'est très captivant avec STM qu'une fois que vous aurez traité n'importe quel MK de la gamme STM32F10x, vous n'aurez aucun problème avec les autres. Une ligne – une fiche technique. D'ailleurs il y a grande quantité des cartes de développement à la fois chères et moins chères avec des contrôleurs STM32, ce qui est très agréable, même si au début nous déboguerons nos programmes dans un simulateur pour évaluer les capacités du contrôleur avant d'acheter du matériel. Voici, juste au cas où, le site officiel de STMicroelectronics -.

D'une manière ou d'une autre, nous sommes passés en douceur au sujet du compilateur, je vais donc en dire quelques mots. Sans y réfléchir à deux fois, j'ai choisi Keil, notamment en raison du puissant simulateur intégré. Vous pouvez y consulter l'UART et n'importe quel registre, et même un analyseur logique est disponible. En un mot, Keil ne m'a laissé pour la plupart que des impressions agréables, même s'il y a bien sûr quelques inconvénients, mais pas catastrophiques. Vous pouvez donc télécharger Keil uvision4 en toute sécurité. site(). Certes, il y en a un MAIS - l'IDE est payant, mais un mode démo est disponible avec une limite de code de 32 Ko, ce qui nous suffit largement pour l'instant. Pour qui cela ne suffit pas, il y a un grand nombre de fissures pour Keil 😉 Tout est installé sans problème - nous poussons plus loin plusieurs fois et tout s'installe parfaitement et fonctionne sans danses supplémentaires avec un tambourin.

En fait, c’est tout ce que je voulais vous dire ici, il est temps de passer des paroles aux actes, mais c’est dans le prochain article. Nous allons apprendre à programmer les microcontrôleurs STM32 à partir de zéro !

Cet article est le premier d'une série d'articles prévus sur l'étude de la programmation des microcontrôleurs. Étudier divers matériaux J'ai remarqué que presque tous commencent par le fait qu'il est demandé au débutant de télécharger (ou d'utiliser celle fournie avec l'environnement de développement) une bibliothèque pour travailler avec des périphériques et de l'utiliser pour écrire son premier programme (généralement une LED clignotante ).

Cela m'a beaucoup surpris. Si vous en croyez ces articles, vous n’avez même pas besoin de lire la documentation de l’automate programmable pour programmer. On m'a enseigné la sagesse "programmation matérielle" complètement différent.

Dans cet article, le chemin de la phrase « Oui, je veux essayer ! » jusqu'à ce que le clin d'œil joyeux de la LED soit bien plus long que celui des autres auteurs. Je vais essayer de révéler les aspects de la programmation des microcontrôleurs qui se cachent derrière l'utilisation de fonctions de bibliothèque et d'exemples prêts à l'emploi.
Si vous avez l'intention d'étudier sérieusement la programmation des microcontrôleurs, cet article est fait pour vous. Peut-être que cela pourrait également intéresser ceux qui ont suffisamment joué avec Arduino et souhaitent mettre la main sur toutes les capacités matérielles du matériel.

Sélection d'un microcontrôleur

Nous supposerons que nous avons déterminé le type de microcontrôleur. Mais le marché propose une vaste gamme de modifications différentes provenant de différents fabricants. Ils diffèrent par de nombreux paramètres - de la taille de la mémoire flash au nombre d'entrées analogiques. Pour chaque tâche, le choix doit être fait individuellement. Il n’y a pas et ne peut pas y avoir de recommandations générales ici. Je noterai seulement qu'il vaut la peine de commencer votre étude auprès des fabricants de MK qui disposent de la gamme la plus large possible. Ensuite, lorsque vous choisissez un MK pour une tâche spécifique, il y a de fortes chances que quelque chose de la gamme présentée vous convienne.

J'ai choisi STM32(même si je pense qu'il vaut mieux commencer à étudier avec MK de TexasInstruments - la documentation est très bien compilée), car ils sont répandus parmi les développeurs d'électronique russes. Si vous avez des problèmes ou des questions, vous pouvez facilement trouver des solutions sur les forums. Un autre avantage est le large choix de cartes de démonstration provenant à la fois du fabricant et d'organisations tierces.

Que devez-vous étudier ?

J'utilise moi-même une carte de démonstration. STM3220G-EVAL et programmeur J-Link PRO. Mais pour commencer, ce sera largement suffisant DÉCOUVERTE STM32F4, qui peut être acheté sans problème pour une petite somme.

Tous les exemples seront spécifiquement destinés à la carte de débogage DÉCOUVERTE STM32F4. À ce stade, il ne sera pas du tout important pour nous que cette carte dispose d'un MCU basé sur le cœur Cortex-M4. Nous n'utiliserons pas ses fonctionnalités et avantages par rapport au Cortex-M3 dans un avenir proche. Nous verrons ce qui se passera ensuite.

Si vous possédez une autre carte basée sur STM32F2xx/STM32F4xx, vous pouvez travailler avec elle. En présentant le matériel, j'essaierai de le décrire de manière aussi détaillée que possible. Pourquoi nous le faisons de cette façon et pas autrement. J'espère que personne n'aura de problèmes pour transférer des exemples vers d'autres matériels.

Environnement de développement

Pourquoi un environnement de développement payant ?

Peut-être que quelqu'un ne sera pas entièrement satisfait du fait que je suggère d'utiliser un environnement de développement payant, mais dans IAR, il est possible d'obtenir une licence temporaire sans restrictions de fonctionnalités, ou une licence illimitée avec une limite de taille de code (32 Ko pour MK, c'est beaucoup ).
De plus, je noterai tout de suite que pour certains MK il n'existe pas d'environnements de développement gratuits. Et malheureusement, ces députés sont irremplaçables dans certains domaines.

Où commencer?

Créer un projet

Un projet vide avec un fichier principal apparaîtra devant nous.

Vous devez maintenant configurer le projet pour commencer à travailler avec « notre » MK et notre débogueur. MK installé sur la carte STM32F4DISCOVERY STM32F407VG. Il doit être sélectionné dans les propriétés du projet (Options générales->Cible->Périphérique) :

Lorsque vous sélectionnez un processeur programmable cible, sa description est chargée, ce qui offre de nombreuses possibilités de débogage (ceci sera discuté ci-dessous). De plus, un fichier de configuration décrivant l'espace d'adressage disponible pour l'éditeur de liens est automatiquement joint. Si nécessaire, nous aborderons le sujet du fichier de configuration de l’éditeur de liens dans les prochains articles.

Après cela, vous devez configurer le débogueur. Le débogage du programme s'effectue directement « dans le matériel ». Cela se fait à l'aide d'un débogueur JTAG. Vous pouvez en savoir plus sur la façon dont cela se produit sur Wikipédia. Le débogueur ST-LINK/V2 est intégré sur la carte STM32F4DISCOVERY. Pour travailler avec le débogueur, vous devez sélectionner son pilote dans le menu Débogueur->Configuration->Pilote. Il faut également indiquer que le débogage doit être effectué directement dans le matériel. Pour ce faire, vous devez définir le drapeau Débogueur->Télécharger->Utiliser le(s) chargeur(s) Flash

Pour ceux qui ont vu le mot Simulator

En théorie, IAR permet de déboguer des programmes à l'aide d'un simulateur. Mais je ne l'ai jamais vu utilisé en pratique.

Le projet est maintenant prêt à fonctionner (programmation, remplissage et débogage).

"TZ" pour le premier projet

Ne nous écartons pas des classiques. Le premier projet sera une LED clignotante. Heureusement, il y en a beaucoup sur le tableau, qu'est-ce que cela signifie d'un point de vue programmation ? La première chose à faire est d'étudier le schéma de circuit de la carte de démonstration et de comprendre comment la LED « démarre ».
disponible sur le site du fabricant. DANS cette description il y a même une section séparée sur les LED sur la carte - 4.4 LED. Par exemple, nous utiliserons Utilisateur LD3. Trouvons-le dans le schéma :

L'analyse la plus simple du circuit suggère que pour « allumer » la LED, il faut appliquer « 1 » sur la broche MK (qui pour ce MK correspond à 3,3V). L'extinction se fait en appliquant « 0 » sur cette broche. Dans le schéma, cette broche est désignée PD13(c'est probablement l'information la plus importante de ce document).

En conséquence, nous pouvons écrire « TK » pour notre premier programme :
Le programme pour le MK doit transférer l'état de la broche MK PD13 de l'état « 0 » à l'état « 1 » et inversement avec une certaine périodicité perceptible à l'œil humain (une remarque importante, si la LED clignote trop souvent, l'œil humain ne sera peut-être pas en mesure de le distinguer).

Avant de commencer la programmation, ou un peu de théorie

Commençons par le fait que tout MK comprend un cœur, une mémoire et des unités périphériques. Je pense qu'avec la mémoire, tout est clair pour l'instant. Permettez-moi juste de mentionner que le STM32 dispose d'une mémoire flash dans laquelle le programme MK est stocké (en général, ce n'est pas une affirmation vraie, le programme peut être stocké dans une mémoire externe non volatile, mais nous l'ignorerons pour l'instant) et d'autres données, y compris les données des utilisateurs. Il existe également SRAM - mémoire vive.

Le cœur est la partie du microcontrôleur qui exécute un flux de commandes. Dans notre MK, le type de noyau est Cortex-M4. Le cœur MK peut être comparé au processeur d’un PC. Il ne peut qu'exécuter des commandes et transférer des données vers d'autres unités (les processeurs avec accélérateurs graphiques intégrés ne sont pas pris en compte dans cette comparaison).
Dans le même temps, le constructeur MK ne développe pas le noyau. Le noyau est acheté auprès d'ARM Limited. La principale différence entre les différents députés réside dans la périphérie.

Les blocs périphériques sont des blocs qui interagissent avec le « monde extérieur » ou remplissent des fonctions spécifiques inaccessibles au noyau MK. Les MCU modernes (y compris STM32) contiennent une vaste gamme d'unités périphériques. Les blocs périphériques sont conçus pour résoudre divers problèmes, de la lecture de la valeur de tension de l'entrée analogique du MK à la transmission de données à des appareils externes via le bus SPI.
Contrairement au noyau MK, les unités périphériques n'exécutent pas d'instructions. Ils exécutent uniquement les commandes du noyau. Dans ce cas, la participation du noyau lors de l'exécution de la commande n'est pas requise.

Exemple

Un exemple est le bloc UART, conçu pour recevoir et transmettre des données du MK vers des appareils externes. Le noyau n'a qu'à configurer le bloc et à lui fournir les données à transmettre. Après cela, le noyau peut continuer à exécuter les instructions. L'unité périphérique est chargée de contrôler la sortie MK correspondante pour la transmission des données conformément au protocole. L'unité périphérique transfère elle-même la sortie MK à l'état requis « 0 » ou « 1 » au bon moment, effectuant la transmission.

Interaction du noyau avec l'unité périphérique

IMPORTANT: Après avoir écrit des données dans un registre spécial puis les avoir lues, vous pouvez obtenir des données complètement différentes. Par exemple, l'envoi de données à un bloc UART à envoyer et la lecture des données reçues par le bloc depuis un périphérique externe sont effectués à l'aide du même registre.

Les registres spéciaux sont généralement divisés en champs de bits. Un (ou plusieurs) bits contrôlent un paramètre spécifique du bloc périphérique, généralement indépendamment. Par exemple, différents bits d'un registre contrôlent l'état des différentes sorties MK.

Rappelez-vous C

Écrire des données sur une adresse mémoire

Supposons qu'en lisant la description du bloc périphérique, nous nous soyons rendu compte que pour qu'il fonctionne correctement, il faut y inscrire le nombre 0x3B. L'adresse du registre spécial est 0x60004012. Le registre est de 32 bits.
Si vous ne savez pas immédiatement comment procéder, je vais essayer de décrire la chaîne de raisonnement pour obtenir la bonne commande.

La valeur 0x60004012 n'est rien de plus que la valeur d'un pointeur vers un emplacement mémoire. C'est exactement ce que nous devons indiquer dans notre programme, c'est-à-dire faire une conversion de type selon la syntaxe du langage C :

(long non signé*)(0x60004012)

Nous avons donc un pointeur vers un élément. Vous devez maintenant écrire la valeur requise dans cet élément. Cela se fait en déréférençant le pointeur. On obtient donc la bonne commande :

*(long non signé*)(0x60004012) = 0x3B;

Définir des bits arbitraires sur 1

Supposons que vous souhaitiez définir les bits 7 et 1 de l'adresse 0x60004012 sur « 1 » sans modifier la valeur de tous les autres bits du registre. Pour ce faire, vous devez utiliser l'opération binaire |. Je vais vous donner la bonne réponse tout de suite :

*(long non signé*)(0x60004012) |= 0x82;

Faites attention à 2 faits. Les bits sont comptés à partir de zéro et non à partir du premier. Cette opération en fait, cela prend au moins 3 cycles d'horloge - lire la valeur, la modifier, l'écrire. Parfois, cela n'est pas acceptable car entre la lecture et l'écriture, la valeur d'un des bits que nous ne sommes pas autorisés à modifier peut avoir été modifiée par l'unité périphérique. N'oubliez pas cette fonctionnalité, sinon des bugs extrêmement difficiles à détecter pourraient apparaître.

Mettre des bits arbitraires à 0

Supposons que nous souhaitions définir les bits 7 et 1 de l'adresse 0x60004012 sur "0" sans modifier la valeur de tous les autres bits du registre. Pour ce faire, vous devez utiliser l'opérateur binaire &. Je vais vous donner la bonne réponse tout de suite :

*(long non signé*)(0x60004012) &= 0xFFFFFF7D;

Ou sa notation plus simple (ne vous inquiétez pas de l'opération supplémentaire, le compilateur calculera tout à l'avance même avec une optimisation minimale) :

*(long non signé*)(0x60004012) &= (~0x82);

Quelques fonctionnalités des programmes pour MK

Mettons-nous au travail!

Tout d'abord, vous devez décider avec quels blocs travailler. Pour ce faire, il suffit d'étudier les sections Introduction Et Caractéristiques principales.

Le contrôle direct de l'état des broches MK s'effectue à l'aide du bloc GPIO. Comme indiqué dans la documentation, le MCU STM32 peut avoir jusqu'à 11 blocs GPIO indépendants. Divers blocs GPIO périphériques sont communément appelés ports. Les ports sont désignés par les lettres A à K. Chaque port peut contenir jusqu'à 16 broches. Comme nous l'avons noté précédemment, la LED est connectée à la broche PD13. Cela signifie que cette broche est contrôlée par le port GPIO D de l'unité périphérique. Broche numéro 13.

Cette fois, nous n'aurons besoin d'aucune autre unité périphérique.

Contrôle de l'horloge périphérique

Les registres sont chargés de permettre la synchronisation des unités périphériques Registre d'activation de l'horloge périphérique RCC XXX.A la place de XXX, il peut y avoir des pneus AHB1, AHB2, AHB3, APB1 et APB2. Après avoir soigneusement étudié la description des registres correspondants, nous pouvons conclure que la synchronisation du bloc périphérique GPIOD est activée en mettant « 1 » dans le troisième bit du registre. Registre d'activation de l'horloge périphérique RCC AHB1 (RCC_AHB1ENR):

Vous devez maintenant comprendre comment connaître l'adresse du registre lui-même RCC_AHB1ENR.

Commentaire: La description du système de synchronisation STM32 MK mérite un article séparé. Si les lecteurs le souhaitent, je couvrirai cette section plus en détail dans l’un des articles suivants.

Détermination des adresses de registres spéciaux

Pour obtenir l'adresse du registre, il faut ajouter à la valeur initiale de l'espace d'adressage du bloc RCC Adr. compenser le registre requis. Adresses décalées est également indiqué dans la description du registre (voir capture d'écran ci-dessus).

En conséquence, nous avons déterminé l'adresse du registre RCC_AHB1ENR-0x4002 3830.

Bloc GPIO

Notre tâche est maintenant d'apprendre à gérer l'état des broches MK. Passons directement à la description des registres GPIO.

Mode de fonctionnement

Comme le montre la description, pour effectuer l'ajustement dont nous avons besoin, nous devons écrire la valeur 01b dans 26-27 bits du registre. GPIOx_MODER. L'adresse du registre peut être déterminée en utilisant la même méthode que celle décrite ci-dessus.

Configuration des paramètres de fonctionnement des broches de sortie du port GPIO

• Registre de type de sortie du port GPIO (GPIOx_OTYPER)- définir le type de sortie push-pull ou open-drain
• Registre de vitesse de sortie du port GPIO (GPIOx_OSPEEDR)- régler la vitesse de sortie

Définition de la valeur sur la broche MK

Nous utilisons le registre de définition/réinitialisation des bits du port GPIO (GPIOx_BSRR)

L'écriture d'un « 0 » ou d'un « 1 » sur les bits 0 à 16 provoque un changement correspondant dans l'état des broches du port. Afin de fixer une certaine valeur à la sortie d'une ou plusieurs broches MK et de ne pas changer l'état des autres, il faudra utiliser l'opération de modification des bits individuels. Cette opération s'effectue en au moins 3 cycles. S'il est nécessaire d'écrire des 1 sur certains bits et des 0 sur d'autres, alors au moins 4 cycles d'horloge seront nécessaires. Cette méthode Utilisé de préférence pour inverser l’état d’une sortie si son état d’origine est inconnu.

Registre de définition/réinitialisation des bits du port GPIO (GPIOx_BSRR)

Contrairement à la méthode précédente, écrire 0 sur n’importe lequel des bits de ce registre ne mènera à rien (et en général, tous les bits sont en écriture seule !). L'écriture de 1 sur les bits 0 à 15 entraînera la définition d'un « 1 » à la sortie correspondante du MK. L'écriture de 1 sur les bits 16 à 31 définira « 0 » sur la sortie correspondante du MK. Cette méthode est préférable à la précédente si vous devez définir une valeur spécifique sur la broche « MK » plutôt que de la modifier.

Allumons la LED !

LED clignotante

Optimisation de l'algorithme

Afin d'éviter cela, un compteur de cycles est généralement utilisé et l'état de la broche MK change lorsque le programme passe par un certain nombre de cycles.
void main() ( //Activer la synchronisation du port D *(unsigned long*)(0x40023830) |= 0x8; //petit délai pour GPIOD préparez-vous volatile unsigned long i=0; i++; i++; i++; i=0; / /Définissez PD13 comme sortie à usage général *(unsigned long*)(0x40020C00) = (*(unsigned long*)(0x40020C00)& (~0x0C000000)) | (0x04000000); while(1) ( i++; if(!(i %2000000)) ( //Allumer la LED *(unsigned long*)(0x40020С14) |= 0x2020; ) else if(!(i%1000000)) ( //Éteindre la LED *(unsigned long*)(0x40020С14) & = ~0x2000; ) ) )
Mais même ici, cela ne sera pas sans problèmes : avec un changement dans le nombre de commandes exécutées dans le cycle, la période de clignotement de la LED (ou la période d'exécution des autres commandes dans le cycle) changera. Mais à ce stade, nous ne pouvons pas lutter contre cela.

Un peu sur le débogage

Mais en plus de cela, il est possible de visualiser les valeurs des registres du noyau, des registres spéciaux des unités périphériques (View->Register), etc.
Je vous recommande fortement de vous familiariser avec les capacités du débogueur tout en apprenant la programmation MK.

Quelques mots en conclusion

• Parfois, les bibliothèques du fabricant contiennent des erreurs ! Une fois, j'ai failli rater la date limite d'un projet à cause de cela. J'ai ressoudé la puce plusieurs fois, pensant que le cristal avait été endommagé lors de la soudure (cela s'était déjà produit). Le problème était que l’adresse du registre spécial était mal saisie dans la bibliothèque. Cela se produit généralement avec les lignes MK ou MK qui viennent d'entrer sur le marché.
• Les bibliothèques permettant de travailler avec des périphériques de certains fabricants n'implémentent pas toutes les capacités des unités périphériques. J'ai particulièrement péché avec ça Luminaire Micro, qui ont ensuite été rachetés par TI. J'ai dû écrire l'initialisation des périphériques manuellement.
• Beaucoup de gens s'habituent à démarrer la programmation MK en étudiant des exemples. Je pense que vous devez d'abord décider de ce qui vous permet de mettre en œuvre MK. Cela ne peut être compris qu'en lisant la documentation. Si quelque chose ne figure pas dans les exemples, cela ne signifie pas que le matériel ne le prend pas en charge. Le dernier exemple est la prise en charge matérielle PTP STM32. Bien sûr, vous pouvez trouver quelque chose en ligne, mais cela n'est pas inclus dans l'ensemble standard du fabricant.
• Les pilotes des unités périphériques de certains fabricants sont si peu optimisés que changer l'état d'une broche à l'aide de la bibliothèque prend jusqu'à 20 cycles d'horloge. C'est un luxe inabordable pour certaines tâches.

Merci à tous ceux qui ont lu mon message, il s'est avéré bien plus que ce à quoi je m'attendais au début.
J'attends avec impatience vos commentaires et critiques motivées. Si ceux qui le lisent en ont envie, j'essaierai de continuer la série d'articles. Peut-être que quelqu'un a des idées sur des sujets qui mériteraient d'être abordés - je serais heureux de les entendre.