Donc, nous nous sommes déjà tenus sur les jambes, au sens des conclusions du microcontrôleur sur le tableau de découverte STM32VL, nous avons connecté tout ce que nous devons dire, nous avons appris dans la langue de programmation, il est temps de créer un projet dans la première classe.
Écrire le programme
Après avoir complété la création et la configuration du projet, vous pouvez commencer à écrire un programme réel. Comme tous les programmeurs ont été effectués, le premier programme écrit au travail sur un ordinateur est le programme affiché à l'écran "Helloworld" et tous les lecteurs de microcontrôleurs Le premier programme pour le microcontrôleur produit un clignotant du voyant. Nous n'exposerons pas de cette tradition et d'écrire un programme qui contrôlera le voyant LD3 sur le tableau de découverte STM32VL.
Après avoir créé un projet vide dans le CIAR, il crée le code de programme minimal:
Maintenant, notre programme sera toujours "tourner" dans le cycle pendant que.
Pour que nous contrôlions la DEL, nous devons autoriser le port dont il est connecté et configuré la sortie correspondante du port de microcontrôleur à la sortie. Comme nous l'avons déjà examiné plus tôt dans la première partie, pour la résolution de l'horloge de port DE des réponses Iople. S'inscrire Rcc_apb2enr.. Selon le document " RM0041Référence.manuel.pdf.»Pour résoudre le tact de bus de port DE nécessaire dans le registre Rcc_apb2enr. Mettre des bits Iople. dans une. Pour pouvoir installer ce bit, nous n'avons pas abandonné les autres installés dans ce registre, nous devons appliquer une addition logique (logique "ou") à l'état actuel de l'état du registre, puis écrivez la valeur reçue au contenu de le registre. Conformément à la structure de la bibliothèque ST, appelez les valeurs du registre de la lecture et de l'écriture est faite par un pointeur à la structure. RCC-> Apb.2 Enr.. Ainsi, en vous souvenant du matériau de la deuxième partie, vous pouvez enregistrer le code suivant qui effectue l'installation du bit. Iople. Dans le registre Rcc_apb2enr.:
Comment vous assurerez-vous du fichier "stm32f10x.h", la valeur du bit Iople. défini comme 0x00000010, qui correspond au quatrième bit ( Iople.) S'inscrire Apb2enr. et coïncide avec la valeur spécifiée dans le datashet.
Maintenant, vous configurerez la conclusion. 9 Port. DE. Pour ce faire, nous devons configurer cette sortie de port sur la sortie en mode Push-Pull. S'inscrire rencontre le registre pour la configuration du mode / sortie de port GPIOC_CRHHNous l'avons déjà envisagé, sa description est également dans la section "7.2.2 Enregistrement de la configuration du port High" Datashets. Pour régler la sortie au mode de sortie avec une vitesse maximale 2 MHz, elle est nécessaire dans le registre GPIOC_CRHH Ensemble Mode9. par unité et réinitialisation bits Mode9. en zéro. Pour la configuration du mode de sortie en tant que fonction principale avec la sortie push-tire, des bits sont répondu. CNF.9 et CNF.9 Pour configurer le mode de fonctionnement requis par nous, ces deux bits doivent être réinitialisés à zéro.
Maintenant, la sortie du port sur lequel la LED est connectée est configurée à la sortie, pour contrôler la DEL, nous devons modifier l'état de la sortie du port en réglant l'unité logique à la sortie. Pour modifier l'état de sortie du port, le premier est un enregistrement directement au registre d'état du port du registre de port modifié, ainsi que le paramètre de port. Cette méthode n'est pas recommandée pour utiliser la possibilité d'une situation dans laquelle le registre de port peut être enregistré non true. Cette situation peut se produire si lors d'une modification de l'état du registre, à partir du moment où le statut du registre a déjà été lu et jusqu'à ce que l'état modifié soit enregistré dans le registre, tout périphérique ou interruption changera l'état. de ce port. À la fin de l'opération pour modifier l'état du registre, la valeur sera enregistrée dans le registre sans prendre en compte les modifications survenues. Bien que la probabilité d'occurrence de cette situation soit très faible, elle vaut toujours la peine d'utiliser une autre méthode dans laquelle la situation décrite est exclue. Pour cela, il y a deux registres dans le microcontrôleur Gpiox_bsrr. et Gpiox_brrr.. Lorsque vous écrivez une unité logique au bit de registre requis Gpiox_brrr. Il y aura une réinitialisation de la sortie appropriée du port dans un zéro logique. S'inscrire Gpiox_bsrr. Il peut produire à la fois l'installation et réinitialiser l'état des sorties de port, pour définir la sortie du port sur une unité logique, il est nécessaire d'installer des bits BSN., Le nombre correspondant du bit requis, ces bits sont situés dans les registres d'octets plus jeunes. Pour réinitialiser l'état de la sortie d'état à zéro logique, il est nécessaire d'enregistrer des bits BRN. Conclusions appropriées, ces bits sont situés dans les anciens décharges du registre du port.
LED LD3 connectée à la sortie 9 Port. DE. Pour activer cette DEL, nous devons appliquer une unité logique sur la sortie du port approprié pour "igniter" la DEL.
Ajoutez le code de configuration de la sortie du port LED dans notre programme et ajoutez une fonction de délai de programme pour réduire la fréquence de commutation du voyant:
|
// N'oubliez pas de connecter un fichier d'en-tête avec une description des registres du microcontrôleur #Include "stm32f10x.h" annuler. Retard ( annuler.); annuler. Retard ( annuler.) //Notre fonction principale annuler. Principale ( annuler.)
// Nettoyer les décharges Mode9 (réinitialiser les bits mode9_1 et mode9_0 à zéro) // stop mode9_1 bits Pour régler la sortie à la sortie avec la vitesse de 2 MHz // Nettoyer les décharges CNF (mise en place à titre général, symétrique (pull-pull))) Pendant que(1) // Définit le port de sortie 9 avec une unité logique (LED "allumée")
} |
Vous pouvez télécharger l'archive avec le code source du programme écrit à l'aide du contrôle direct des registres du microcontrôleur par référence.
Notre premier programme de travail est écrit, lors de l'écriture, pour le rédiger et configurer la périphérie, nous avons utilisé des données de la fiche officielle " RM0041Référence.manuel.pdf.«Cette source d'informations sur les registres du microcontrôleur est la plus précise, mais pour qu'ils soient utilisées, vous devez relire beaucoup d'informations, ce qui complique les programmes d'écriture. Pour faciliter le processus de réglage de la périphérie du microcontrôleur, divers générateurs de code sont présentés dans divers générateurs de code de la société ST sont présentés avec Microxplorer, mais il reste petit et pour cette raison, le programme alternatif "Le générateur de code de programme STM32 a été créé par des développeurs tiers. » . Ce programme Vous permet d'obtenir facilement le code de réglage périphérique à l'aide d'une interface graphique visuelle pratique (voir Fig. 2).
Figure. 2 Capture d'écran du générateur de code de programme STM32
Comme on peut le voir à partir de la figure 2, le programme généré par le code de réglage de sortie LED correspond au code que nous avons écrit plus tôt.
Pour exécuter le programme écrit, après avoir compilé le code source, vous devez télécharger notre programme sur le microcontrôleur et voir comment il est effectué.
Mode de débogage de la vidéo clignotant LED LED
Vidéo fonctionnement d'un programme clignotant LED sur le tableau de découverte STM32VL
Caractéristiques de la bibliothèque fonctionnent avec la périphérie
Pour simplifier le travail avec la configuration des registres périphériques du microcontrôleur, ST a développé des bibliothèques, grâce à l'utilisation de laquelle, il n'est pas nécessaire de lire Datashet, car lors de l'utilisation de ces bibliothèques, le programme rédaction du programme deviendra plus proche de Écrire des programmes de haut niveau, compte tenu de ce que toutes les fonctions de bas niveau sont implémentées au niveau des fonctions de la bibliothèque. Cependant, il ne devrait pas être complètement abandonné de l'utilisation de travaux directs avec les registres du microcontrôleur, compte tenu du fait que les fonctions de bibliothèque nécessitent plus de temps de processeur sur son exécution, en conséquence, leur utilisation des sections de programme n'est pas justifiée. dans le temps d'exécution. Mais toujours, dans la plupart des cas, de telles choses que l'initialisation périphérique ne sont pas essentielles au moment de l'exécution et que la commodité d'utilisation des fonctions de bibliothèque est préférable.
Ecrivez maintenant notre programme à l'aide de la bibliothèque St. Le programme nécessite de configurer des ports d'E / S, d'utiliser les ports de la bibliothèque des paramètres de port, vous devez connecter le fichier d'en-tête " stm32f10x_gpio.h."(Voir table. 1). Connexion de ce fichier peut ne pas s'épuiser la chaîne correspondante dans le fichier de configuration de l'en-tête connecté " sTM32F10X_CONF.H." À la fin du fichier " stm32f10x_gpio.h.»Il existe une liste de fonctionnalités de fonctionnalités pour travailler avec des ports. Une description détaillée de toutes les fonctions disponibles est disponible dans le fichier " sTM32F10X_STDPERIPH_LIB_UM.CHM.», brève description Le plus fréquemment applicable est présenté dans le tableau 2.
Tableau 2. Apprenez les fonctions principales des paramètres du port
|
Une fonction |
Description de la fonction Paramètres transmis et retournés |
|
Gpio_deinit ( |
Définit les valeurs des registres de configuration du port GPIOX aux valeurs par défaut |
|
Gpio_init ( |
Donne les registres de la configuration du port GPIOX conformément aux paramètres spécifiés de la structure GPIO_INIDSTUT |
|
Gpio_tructinit ( |
Remplit tous les champs de structure GPIO_InsiStruct, valeurs par défaut |
|
uint8_t gpio_readinputdatabit ( |
Lecture de la valeur de sortie GPIO_PIN du port GPIOX |
|
uint16_t gpio_readinputdata ( |
Lecture des valeurs d'entrée de toutes les sorties de port Gpiox |
|
Gpio_setbits ( |
Définition de la valeur de sortie de la sortie GPIO_PIN du port GPIOX dans une unité logique |
|
Gpio_resetbits ( |
Réinitialiser la sortie de sortie GPIO_PIN Port de sortie GPIOX dans zéro logique |
|
Gpio_writbit ( |
Enregistrez la valeur Bitval dans GPIO_PIN SORTIE GPIOX Port |
|
Gpio_write ( |
Enregistrez la valeur Portval dans le port Gpioxx |
Comme on peut le voir à partir de la description des fonctions, comme les paramètres des paramètres du port, etc., peu de paramètres individuels différents sont transmis à la fonction et une structure. Les structures sont les données combinées qui ont une relation logique. Contrairement aux tableaux, les structures peuvent contenir des données différents types. En d'autres termes, la structure représente un ensemble de diverses variables avec différents types, combinées dans un type de variable. Les variables de cette structure s'appellent dans les champs de structure et les appels à ceux-ci sont effectués comme suit, le nom de la structure est d'abord, puis le point et le nom du champ de structure (nom de la variable dans cette structure) est écrit.
La liste des variables incluses dans les structures des fonctions de travail avec des ports est décrite dans le même fichier quelque peu plus élevé que la description des fonctions. Donc, par exemple, la structure " Gpio_inittypedef."Il a la structure suivante:
|
typedeft struct uint16_t gpio_pin; /*!< Specifies the GPIO pins to be configured. Gpiropeed_typedf gpio_speed; /*!< Specifies the speed for the selected pins. Gpiomode_typedf gpio_mode; /*!< Specifies the operating mode for the selected pins. ) Gpio_inittypedef; |
Le premier champ de cette structure contient une variable " GPIO._ ÉPINGLER."Taper non signé courtDans cette variable, vous devez enregistrer les indicateurs des numéros des conclusions correspondantes pour lesquelles il est censé effectuer le réglage nécessaire. Vous pouvez configurer plusieurs conclusions à la fois, en définissant plusieurs constantes comme paramètre à travers l'opérateur. souffler ou (cm. ). Amer ou "collectera" toutes les unités des constantes énumérées et les constantes elles-mêmes sont masques, vient d'être destinée à une telle utilisation. Les constantes de Macrolo sont affichées dans le même fichier ci-dessous.
Le deuxième champ de la structure " Gpio_inittypedef."Spécifie la vitesse maximale possible de la sortie du port. La liste des valeurs possibles de ce champ est répertoriée ci-dessus:
Description des valeurs possibles:
- Gpio_mode_ain - Entrée analogique (ENG. Entrée analogique);
- Gpio_mode_in_floating - Entrée sans suspension, bavardage (eng. Float d'entrée) dans l'air
- Gpio_mode_ipd. - Entrée avec un atout au sol (ENG. INPUT Pull-Down)
- Gpio_mode_ipu. - Entrée avec une suspension de puissance (eng. Entrée d'entrée)
- Gpio_mode_out_od. - Quitter le stock ouvert (fred. Sortie Open Drain)
- Gpio_mode_out_pp - Sortie avec deux états (eng. Push-pull de sortie - là-bas et ici)
- Gpio_mode_af_od. - Quittez le stock ouvert pour des fonctions alternatives (fonction alternative anglaise). Utilisé dans les cas où la sortie doit contrôler la périphérie attachée à cette sortie de port (par exemple, la sortie TX USART1, etc.)
- Gpio_mode_af_pp - le même, mais avec deux états
De même, vous pouvez voir la structure des variables d'autres structures nécessaires au fonctionnement avec les fonctions de la bibliothèque.
Pour travailler avec des structures, ils sont également en tant que variables, il est nécessaire de les déclarer et d'attribuer un nom unique, après quoi vous pouvez contacter les champs de la structure annoncée, en fonction du nom qui lui est attribué.
|
// déclarer la structure /* Pour transférer les valeurs de la structure sur la fonction, il est nécessaire de mettre un symbole et une structure avant le nom de la structure. Ce symbole dit le compilateur qu'il est nécessaire de transmettre des fonctions que les valeurs contenues dans la structure, mais l'adresse en mémoire, sur laquelle sont situées les valeurs. Ceci est fait afin de réduire le nombre d'actions nécessaires du processeur pour copier le contenu de la structure et vous permet également de sauvegarder la RAM. Ainsi, au lieu de transmettre un ensemble de contenu dans les octets contenus dans la structure, un seul contenant l'adresse de la structure sera transmis. / * Nous écrivons dans le champ Gpio_Pin de la structure GPIO_INIT_SRUCT du numéro de sortie du port, que nous allons ajuster davantage * / Gpio_init_truct.gpio_pin \u003d gpio_pin_9; / * De même, remplissez le champ GPIO_Speed \u200b\u200b* / /* |
Presque tous les périphériques sont configurés de la même manière, les différences sont disponibles uniquement dans les paramètres et les commandes spécifiques spécifiques à chaque périphérique.
Maintenant, écrivez notre programme clignotant par le voyant en utilisant uniquement les fonctions de la bibliothèque.
|
// N'oubliez pas de connecter un fichier d'en-tête avec une description des registres du microcontrôleur #Include "stm32f10x.h" // déclarer la fonction du délai de programme annuler. Retard ( annuler.); // fonction de délai logiciel annuler. Retard ( annuler.) // notre fonction principale annuler. Principale ( annuler.) // Autoriser le tact du bus de port avec // déclarer la structure pour configurer le port // remplit la structure avec les valeurs initiales / * Nous écrivons dans le champ Gpio_Pin de la structure GPIO_INIT_SRUCT du numéro de sortie du port, que nous allons ajuster davantage * / // De même, remplissez les champs GPIO_SPEED et GPIO_MODE // transférer la structure complète pour effectuer des actions pour configurer des registres // notre principal cycle infini // Ajouter un délai de programme à la lueur LED pendant un moment // réinitialiser l'état de sortie 9 ports avec zéro logique // Ajouter un délai de programme à nouveau |
relier.
De l'exemple ci-dessus, on peut constater que l'utilisation de fonctions de bibliothèque de fonctionnement avec la périphérie vous permet d'apporter la rédaction des programmes pour le logiciel de microcontrôleur pour une programmation orientée objet et réduit également la nécessité d'une manipulation fréquente à la Datashet Pour lire la description des registres du microcontrôleur, mais l'utilisation de fonctions de bibliothèque nécessite une connaissance de la programmation plus élevée. Compte tenu de cela, pour que les personnes ne connaissent pas particulièrement étroitement avec la programmation, une version plus simple des programmes d'écriture sera une façon de rédiger des programmes sans utiliser de fonctions de bibliothèque, appelant directement des registres de microcontrôleur. Pour ceux qui connaissent bien le langage de programmation, mais mal démontés dans les microcontrôleurs, en particulier STM32, l'utilisation de fonctions de bibliothèque simplifiera considérablement le processus de rédaction de programmes.
Cette circonstance, ainsi que le fait que ST a pris soin du haut degré de compatibilité, à la fois dans le plan matériel et du logiciel, divers microcontrôleurs, contribue à l'étude plus simple, compte tenu du fait qu'il n'est pas nécessaire de plonger dans la Caractéristiques de la structure de divers contrôleurs La série STM32 et vous permet de sélectionner n'importe lequel du microcontrôleur de la ligne STM32 sous forme de microcontrôleur.
Manipulateur d'interruption
Les microcontrôles ont une capacité remarquable - d'arrêter l'exécution du programme principal sur un événement donné et de passer à l'exécution d'un sous-programme spécial - manipulateur d'interruption. En tant que sources d'interruptions, il peut y avoir des événements extérieurs - interruption des données recevant / transmettant des données via toute interface de transmission de données, ou une modification de l'état de sortie et du débordement de la minuterie interne, etc. La liste des sources possibles d'interruption pour les microcontrôleurs de La série STM32 est donnée dans Datashet " Manuel de référence RM0041."Dans le chapitre" 8 interruptions et événements».
Étant donné que le gestionnaire d'interruptions est également une fonction, il sera enregistré comme une fonction régulière, mais de sorte que le compilateur sait que cette fonction est un gestionnaire d'interruption défini, vous devez sélectionner des noms prédéterminés spécifiés par les redirections des vecteurs d'interruption. La liste des noms de ces fonctions avec une brève description est dans le fichier d'assembleur " startup_stm32f10x_md_vl.s." Un gestionnaire d'interruption peut avoir plusieurs sources d'appel, par exemple la fonction de gestionnaire d'interruption Usart1_irqhandler»Peut être causé en cas de fin de la réception et de la fin de la transmission d'octets, etc.
Pour commencer à travailler avec des interruptions, vous devez configurer et initialiser le contrôleur d'interruption NVIC. Dans l'architecture Cortex M3, chaque interruption peut être configurée son groupe prioritaire pour des cas lorsque plusieurs interruptions se produisent simultanément. Faites ensuite le réglage de la source d'interruption.
Dans le champ NVIC_IRQCHANNEL, il est indiqué quelle interruption nous souhaitons configurer. La constante USART1_IRQN indique un canal responsable des interruptions associées à USART1. Il est défini dans le fichier " stm32f10x.h.«Les autres constantes similaires sont définies là.
Les deux champs suivants indiquent la priorité des interruptions (les valeurs maximales de ces deux paramètres sont déterminées par le groupe prioritaire sélectionné). Le dernier champ, en fait, inclut l'utilisation de l'interruption.
En fonction Nvic_init.En outre, ainsi que lors de la configuration des ports, un pointeur est transmis à la structure pour appliquer les paramètres et les enregistrements aux registres appropriés du microcontrôleur.
Maintenant, dans les paramètres du module, vous devez définir les paramètres pour lesquels ce module générera une interruption. Pour commencer, vous devez activer les interruptions, cela se fait en appelant la fonction nom._Config ()Quel est le fichier d'en-tête du périphérique.
|
// Autoriser les interruptions à la fin du transfert d'octet par usart1 // Autoriser les interruptions à la fin de l'utilisation d'octet par usart1 |
La description des paramètres transmis aux fonctions peut être visualisée dans le fichier de code source du périphérique, légèrement au-dessus de l'emplacement de la fonction elle-même. Cette fonctionnalité permet ou interdit des interruptions sur divers événements à partir du module périphérique spécifié. Lorsque cette fonction est exécutée, le microcontrôleur sera capable de générer des interruptions aux événements nécessaires à nous.
Après avoir entré la fonction de traitement d'interruption, nous devons vérifier dans quel événement une interruption est arrivée, puis réinitialisez le drapeau, sinon le microcontrôleur décidera que nous n'avons pas traité l'interruption, car le drapeau d'interruption est toujours installé.
Pour effectuer divers, petits, répétitifs avec la période d'action exacte, dans les microcontrôleurs avec le noyau Cortex-M3, il existe une minuterie système spécialement conçue. La fonction de cette minuterie ne comprend qu'un appel d'appel via des intervalles de temps strictement spécifiés. En règle générale, dans l'interruption causée par cette minuterie, il existe un code permettant de mesurer la durée de divers processus. L'annonce de la fonction de configuration de la minuterie est située dans le fichier " cœur_ cm.3. h." En tant que fonction de l'argument transmissible, le nombre d'horloges de bus système entre la plage d'interruption du gestionnaire d'interruptions de la minuterie système est indiquée.
|
SYSTIK_CONFIG (CLK); |
Maintenant, triez avec des interruptions, réécrivez notre programme à l'aide d'une minuterie système en tant qu'élément de streaming. Depuis la minuterie " Systick."Il est systémique et ils peuvent utiliser divers blocs fonctionnels de notre programme, il sera raisonnable de rendre la fonction de traitement d'interruption de la minuterie système à un fichier distinct, de cette fonction aux fonctions d'appel pour chaque bloc de fonction séparément.
Un exemple de programme de fichiers "Main.c" pour les voyants clignotants à l'aide d'interruptions:
|
// Connectez un fichier d'en-tête avec une description des registres du microcontrôleur #Include "stm32f10x.h" non signé int. LED_TIMER; // fonction appelée à partir d'un gestionnaire d'interruptions de minuterie système annuler. Sstick_timer_main ( annuler.) // sinon, si moins ou égal à 1500, puis éteignez // Variable de DechRent LED_TIMER // ELI, la valeur de la variable est venue à zéro, définir la nouvelle valeur de 2000 // notre fonction principale annuler. Principale ( annuler.) // Autoriser le tact du bus de port avec // déclarer la structure pour configurer le port // remplit la structure avec les valeurs initiales / * Nous écrivons dans le champ Gpio_Pin de la structure GPIO_INIT_SRUCT du numéro de sortie du port, que nous allons ajuster davantage * / // De même, remplissez les champs GPIO_SPEED et GPIO_MODE // transférer la structure complète pour effectuer des actions pour configurer des registres // Sélectionnez un groupe prioritaire pour les interruptions // Configurez le fonctionnement de la minuterie système avec intervalle 1ms // notre principal cycle infini |
Partie du code source dans le fichier "stm32f10x_it.c":
|
… /** annuler. Systick_handler ( annuler.) |
Un exemple de programme de projet de travail pour les voyants clignotants utilisant une interruption peut être téléchargé par référence.
À ce sujet, mon histoire sur les bases des programmes de développement du microcontrôleur STM32 peut être envisagée. J'ai fourni toutes les informations nécessaires à la possibilité d'une nouvelle étude indépendante des microcontrôleurs STM32. Le matériau fourni est uniquement à partir, car une description complète du travail avec des microcontrôleurs est impossible à décrire dans n'importe quel article. En outre, il est impossible d'étudier les microcontrôleurs sans obtenir une expérience pratique et cette expérience vient progressivement au cours des années de travail, d'expériences, avec l'accumulation de divers logiciels et de divers développements matériels, ainsi que de lire divers articles et documentation pour les microcontrôleurs. Mais laissez-le ne pas vous faire peur, car les informations fournies dans l'article sont suffisamment suffisantes pour créer son premier appareil sur le microcontrôleur et vous pouvez acheter de nouvelles connaissances et expérimenter de manière indépendante, développer de plus en plus complexes et meilleurs appareils Et améliorer vos compétences.
J'espère que je pourrais vous intéresser à étudier les microcontrôleurs et au développement des appareils sur eux, et mon travail vous sera utile et intéressant.
Logiciel requis pour le développement. Dans cet article, je vais vous dire comment le configurer correctement et crier. Tous les environnements commerciaux tels que IAR Ewarm ou Keil UVision remplissent généralement cette intégration, mais dans notre cas, tout devra être ajusté à la main, passant beaucoup de temps. L'avantage est que vous ayez une chance de comprendre comment tout fonctionne de l'intérieur et dans le futur configure de manière flexible tout pour vous-même. Avant de commencer, considérez la structure de l'environnement dans lequel nous travaillerons:
Eclipse sera utilisé pour modifier facilement des fichiers de mise en œuvre de fonctions ( .c.c.), fichiers d'en-tête ( .h.), ainsi que des fichiers d'assembleur ( .S.s.). Sous la "commode", je comprends l'utilisation du code de code, la syntaxe en surbrillance, le refactoring, la navigation de navigation et leurs prototypes. Les fichiers seront automatiquement tirés par les compilateurs souhaités générant code d'objet (dans les fichiers .o.). Jusqu'à présent, ce code ne contient pas adresses absolues Variables et fonctions et cela ne convient pas à l'exécution. Les fichiers d'objets résultants sont collectés ensemble par le collecteur (lieur). Pour savoir quelles sections de l'espace d'adresses utilisent, le collecteur utilise un fichier spécial ( .ld), qui s'appelle un script de liaison. Il contient généralement la définition des sections et de leurs tailles (section de code affichée par Flash, la section Variables affichée sur la RAM, etc.).
À la fin, la liaison génère des fichiers (format exécutable et lié), qui contient en soi, à l'exception des instructions et des informations de débogage de données (informations de débogage) utilisées par le débogueur. Pour le programme habituel du micrologiciel VSPROG, ce format ne convient pas, car pour cela, vous avez besoin d'un fichier image de mémoire plus primitif (par exemple, Intel Hex - .hex). Pour le générer, il existe également un outil à partir de la série Sourcery CodeBench (ARM-NON-ABI-OBJCOPY), et il est parfaitement intégré à Eclipse à l'aide du plug-in installé.
Pour la mise en œuvre du débogueur lui-même, trois programmes sont utilisés:
- eclipse lui-même, qui donne au programmeur "visuellement" pour utiliser le débogage, marcher sur les lignes, le curseur du curseur de la souris aux variables pour afficher leurs valeurs et d'autres commodités
- aRM-Aucun-EABI-GDB - Client GDB - Un débogueur, qui est caché par les Eclips (via STDIN) comme une réaction aux actions spécifiées à la clause 1. À son tour, le GDB se connecte au serveur OPENOCD DEBUG, et toutes les commandes entrant dans l'entrée sont diffusées par le débogueur GDB dans les commandes qui sont claires pour OPENOCD. Canal gdb.<-> OpenocD est mis en œuvre par protocole TCP.
- OpenOCD est un serveur de débogage qui peut communiquer directement avec le programmeur. Il fonctionne avant le client et s'attend à une connexion TCP.
Ce système peut sembler très inutile pour vous: pourquoi utiliser le client et le serveur séparément et effectuer une nouvelle fois des commandes de diffusion, si tout cela pourrait être fait avec un débogueur? Le fait est que une telle architecture vous permet théoriquement de rendre interchangeement client et serveur. Par exemple, si vous devez utiliser un autre programmeur au lieu de Vershaloon, qui ne prendra pas en charge OpenOCD et prendra en charge un autre serveur de débogage spécial (par exemple, Texane / Stlink pour le programmateur StLink - qui se trouve dans le tableau de bord STM32VLDISCOVERY), puis vous Démarrer simplement le lancement OPENOCD exécutez le serveur souhaité et tout devrait fonctionner, sans aucune télévision supplémentaire. Dans le même temps, la situation inverse est possible: Voulons-nous utiliser Eclipse + CodeBench au lieu d'un paquet, mercredi IAR Ewarm avec Vershalon. IAR a son propre client de débogage intégré qui contactera avec succès OPENOCD et les dirigera, ainsi que de recevoir les données nécessaires en réponse. Toutefois, tout cela reste parfois en théorie, car les normes de communication client et de serveur ne sont pas réglementées, mais elles peuvent différer dans certains endroits, mais j'ai réussi à être résolue avec le st-link + Eclipse et IAR + Vershalon.
Habituellement, le client et le serveur sont démarrés sur une machine et la connexion au serveur se produit à l'adresse localhost: 3333.(Pour OPENOCD), ou localhost: 4242. (Pour Texane / Stlink St-Util). Mais personne ignore d'ouvrir le port 3333 ou 4242 (et nous rompons ce port sur le routeur dans le réseau externe) et vos collègues d'une autre ville pourront se connecter et déboguer votre morceau de fer. Cette astuce est souvent utilisée par les embardeurs travaillant sur des objets distants, l'accès auquel est limité.
Démarrer
Nous lancons Eclipse et sélectionnez le projet File-\u003e New-\u003e C, sélectionnez le type de projet ARM Linux GCC (Sorcyer G ++ Lite) et le nom "STM32_LD_VL" (Si vous avez STV32VLDiscovery, il sera plus logique d'appeler "STM32_MD_VL "):
Cliquez sur Terminer, pliez ou fermez la fenêtre de bienvenue. Donc, le projet est créé et le dossier STM32_LD_VL doit apparaître dans votre espace de travail. Maintenant, il doit être rempli avec les bibliothèques nécessaires.
Comme vous avez compris du nom du projet, je créerai un projet pour le type de ligne ligne de valeur à faible densité (Ld_vl). Pour créer un projet pour d'autres microcontrôleurs, vous devez remplacer tous les fichiers et définir-S dans le titre duquel est présent. _LD_VL (ou_LD_VL.) Car vous avez besoin, conformément au tableau:
| Type de ligne | La désignation | Les microcontrôleurs (X peuvent changer) |
| Ligne de valeur à faible densité | _LD_VL. | STM32F100X4 STM32F100x6. |
| Faible densité | _Ld | STM32F101X4 STM32F101X6. STM32F102X4 STM32F102X6. STM32F103X4 STM32F103X6. |
| Ligne de valeur moyenne densité | _MD_VL. | STM32F100x8 STM32F100XB. |
| Densité moyenne |
_Maryland. |
STM32F101X8 STM32F101XB. STM32F102X8 STM32F102XB. STM32F103X8 STM32F103XB. |
| Ligne de valeur haute densité | _Hd_vl. | STM32F100XC STM32F100XD STM32F100XE. |
| Haute densité | _HAUTE DÉFINITION. | STM32F101XC STM32F101XD STM32F101XE. STM32F103XC STM32F103XD STM32F103XE. |
| Xl-densité | _XL | STM32F101XF STM32F101XG. STM32F103XF STM32F103XXG. |
| Ligne de connectivité | _Cl | STM32F105XX et STM32F107XX |
Pour comprendre la logique de la table, vous devez connaître le marquage STM32. C'est-à-dire que si vous avez une Vldiscovery, vous devez remplacer tout ce qui concerne _LD_VL à _MD_VL, car le disque de disque conserve la puce STM32F100RB appartenant à la ligne de valeur de la densité moyenne.
Ajout aux projets de bibliothèques CMSIS et Bibliothèque de périphériques standard STM32F10X
Cmsis (Cortex Microcontroller Standard Standard Standard) - Bibliothèque normalisée de fonctionnement avec les microcontrôleurs du cortex, qui effectue le niveau de HAL (couche d'abstraction matérielle), c'est-à-dire vous permettant de résumer les détails de la collaboration avec des registres, de rechercher des adresses de registre sur les fiches techniques, etc. La bibliothèque est un ensemble de code source en C et ASM. La partie nucléaire (noyau) de la bibliothèque est la même pour tous les cortex (que ce soit ST, NXP, Atmel, TI ou une autre personne) et est développé par le bras. Une autre partie de la bibliothèque est responsable de la périphérie, qui est naturellement différente de différents fabricants. Par conséquent, finalement, la bibliothèque complète est toujours distribuée par le fabricant, bien que la partie nucléaire puisse toujours être téléchargée séparément sur le site Web des bras. La bibliothèque contient des définitions d'adresse, un code d'initialisation des générateurs d'horloge (de définition de manière commodément personnalisable-AMI) et de tout le reste qui élimine le programmeur de l'introduction manuelle à ses projets pour identifier les adresses de tous les registres de périphériques et identifier les bits des valeurs de ces registres.
Mais les gars de ST sont allés plus loin. En plus de soutenir les CMSI, ils fournissent une autre bibliothèque pour STM32F10X appelée Bibliothèque de périphériques standard(Spl), qui peut être utilisé en plus des CMSI. La bibliothèque fournit un accès plus rapide et pratique à la périphérie et des contrôles (dans certains cas) le bon fonctionnement de la périphérie. Par conséquent, ces bibliothèques sont souvent appelées ensemble de pilotes aux modules périphériques. Il est accompagné d'un ensemble d'exercices séparés par catégorie pour différents périphériques. La bibliothèque est également non seulement pour STM32F10X, mais également sous l'autre série.
Télécharger Toute la version SPL + CMSIS 3.5 peut être ici: STM32F10X_STDPERIPH_LIB_V3.5.0 ou ST. Décompresser les archives. Créez des dossiers CMSI et SPL dans le dossier de projet et commencez à copier des fichiers à votre projet:
| Que copier | Où copier (compte tenu |
Description du fichier |
| Bibliothèques / CMSIS / CM3 / Coreupport / core_cm3.c. |
sTM32_LD_VL / CMSIS / core_cm3.c. | Cortex M3 Kernel Description |
| Bibliothèques / CMSIS / CM3 / Coreupport / core_cm3.h. |
stm32_ld_vl / cmsis / core_cm3.h | Tonalité Description Headers |
St / STM32F10X / system_stm32f10x.c. |
sTM32_LD_VL / CMSIS /system_stm32f10x.c. | Fonctions d'initialisation I. Gestion des fréquences d'horloge |
| Bibliothèques / CMSIS / CM3 / DevicesPort / St / STM32F10X / system_stm32f10x.h. |
sTM32_LD_VL / CMSIS /system_stm32f10x.h. | En-têtes à ces fonctionnalités |
| Bibliothèques / CMSIS / CM3 / DevicesPort / St / STM32F10X / stm32f10x.h. |
sTM32_LD_VL / CMSIS /stm32f10x.h. | La description principale de la périphérie |
| Bibliothèques / CMSIS / CM3 / DevicesPort / St / STM32F10X / STARTUP / GCC_RIDE7 / startup_stm32f10x_ld_vl.s. |
sTM32_LD_VL / CMSIS /startup_stm32f10x_ld_vl.s. (!!! Extension de fichier de capital de l'attention) |
Fichier avec vecteurs de table Interruptions et init-ami sur ASM |
| Projet / STM32F10X_STDPERIPH_TEMPLATE / STM32F10X_CONF.H. |
sTM32_LD_VL / CMSIS / sTM32F10X_CONF.H. | Modèle pour la configuration modules périphériques |
Inc / * |
sTM32_LD_VL / SPL / INC / * | Fichiers de l'en-tête SPL |
| Bibliothèques / STM32F10X_STDPERIPH_DRIVER / Src / * |
sTM32_LD_VL / SPL / SRC / * | SPL Mise en œuvre |
.jpg)
Après la copie, allez à Eclipse et effectuez une actualisation dans le menu contextuel du projet. En conséquence, dans l'explorateur de projet, vous devez obtenir la même structure que sur la photo à droite.
Vous remarquerez peut-être que dans les bibliothèques / cmsis / cm3 / Dappelupport / ST / STM32F10X / ST / ST / STM32F10X / ST / ST / STM32F10X / STARTUP / Il existe des dossiers pour différents IDes (différents compilateurs sont utilisés dans idées différents). J'ai choisi l'IDE Ride7, car il utilise les outils GNU pour le compilateur intégré au bras, compatible avec notre code Sourcery CodeBench.
La bibliothèque entière est configurée à l'aide du préprocesseur (à l'aide de DEFINE-S), cela résoudra toutes les branches nécessaires au stade de la compilation (ou plutôt même devant elle) et évitera la charge dans l'œuvre du contrôleur lui-même (qui serait observée. Si la configuration a été effectuée en runtime). Par exemple, tout l'équipement est différent pour différents lineages et donc la bibliothèque "reconnaît" que la règle que vous souhaitez utiliser, vous êtes invité à être réduit dans le fichier stm32f10x.h. L'un des tests de définition (correspondant à votre ligne):
/ * #define stm32f10x_ld * / / *!< STM32F10X_LD: STM32 Low density devices */
/ * #define stm32f10x_ld_vl * / / *!< STM32F10X_LD_VL: STM32 Low density Value Line devices */
/ * #define stm32f10x_md * / / *!< STM32F10X_MD: STM32 Medium density devices */
Etc...
Mais je ne conseille pas cela. Fichiers de bibliothèque Nous ne toucherons pas encore et définirons que nous le ferons plus tard en utilisant les paramètres du compilateur à Eclipse. Et puis l'ESLIPSE appellera le compilateur avec la clé -D stm32f10x_ld_vlque pour le préprocesseur est absolument équivalent à la situation si vous avez été déchargé "#Define stm32f10x_ld_vl". Ainsi, nous ne changerons pas le code, dans l'enquête, si vous le souhaitez, un jour, vous pouvez créer la bibliothèque dans un répertoire distinct et ne pas copier dans le dossier de chaque nouveau projet.
Script de liaison
Dans le menu contextuel du projet, sélectionnez Nouveau-\u003e File-\u003e Autre-\u003e Général-\u003e Fichier, Suivant. Sélectionnez le dossier du projet racine (STM32_LD_VL). Entrez le nom du fichier "stm32f100c4.ld" (ou "STM32F100RB.LD" pour la découverte). Maintenant copier et insérer dans Eclipse:
Entrée (RESET_HANDLER) Mémoire (Flash (RX): Origine \u003d 0x08000000, Longueur \u003d 16K RAM (XRW): Origine \u003d 0x20000000, Longueur \u003d 4K) _ESTACK \u003d Origine (RAM) + Longueur (RAM); Min_heap_size \u003d 0; Min_stack_size \u003d 256; Sections (/ * Table de vecteur d'interruption * / .isr_vector: (. \u003d Align (4); garder (* (. ISR_Vector)). \u003d Align (4);)\u003e Flash / * Le code de programme et d'autres données passe en flash * / .text: (. \u003d Align (4); / * code * / * (. Texte) * (. Texte *) / * Constantes * / * (. Rodata *) / * Arm-\u003e Thumb Et Thumb-\u003e Code de colle ARM * / * (. GLUE_7) * (. GLUE_7T) Garder (* (init)) Conserver (* (. Fini)). \u003d Align (4); _Text \u003d.)\u003e Flash. Arm.extab: (* (. Arm.extab * .gnu.linkonce.armextab. *))\u003e Flash .arm: (__exidx_start \u003d.; * (. Arm.exidx *) __exidx_end \u003d.;)\u003e Flash .arm. Attributs: (. * (ARM.ATtributes))\u003e Flash .Preinit_array: (fournit_Choriden (__preinit_array_start \u003d); garder (* (* (preinit_array *)) fournit_horid (__preinit_array_end \u003d); ...)\u003e Flash .init_array: (__init_array_start \u003d.); Garder (* (Trier (.init_array. *))) Conserver (* (init_array *)) Fournissez_Choride (__init_array_end \u003d.);)\u003e Flash .Fini_array_start \u003d.); Garder (* (.Fini_array *)) Garder (* (trier (.fini_array. *))) Fournissez_Choride (__fini_array_end \u003d.); )\u003e Flash _sidata \u003d.; / * Données initialisées * / .Data: à (_sidata) (. \u003d Align (4); _sdata \u003d.; / * Créer un symbole global au début des données * / * (Data *). \u003d Aligner (4); _edata \u003d.; / * Définissez un symbole global à la fin de données * /)\u003e RAM / * Données non initialisées * /. \u003d Aligner (4); .bss: (/ * Ceci est utilisé par le démarrage afin d'initialiser les .bbs Secing * / _sbss \u003d.; / * Définissez un symbole global à BSS Démarrer * / __bss_start__ \u003d _SBSS; * (BSS) * (. BSS * ) * (Commun). \u003d Aligner (4); _ebss \u003d.; / * Définissez un symbole global à la fin de BSS * / __bss_end__ \u003d _ebss;)\u003e RAM fournit (fin \u003d _ebss); Fournir (_end \u003d _ebss); Fournir (__ tas_start \u003d _ebss); / * La section user_heap_stack, utilisée pour vérifier qu'il y a suffisamment de RAM Gauche * / ._user_heap_stack: (. \u003d Align (4) ;. \u003d. + Min_heap_size ;. \u003d Aligner (4);)\u003e RAM / Jeter /: (libc.a (*) libm.a (*) libgcc.a (*)))
Donné L. le script Inker sera destiné au contrôleur STM32F100C4 (qui dispose de 16 kb Flash et de 4 Ko RAM), si vous en avez une autre, vous devrez modifier les paramètres de la longueur dans les champs de Flash et de la RAM au début du fichier ( Pour STM32F100RB, qui dans la découverte: Flash 128K et RAM 8K).
Enregistrez le fichier.
Personnalisation de l'assemblage (C / C ++ Build)
Nous allons au projet-\u003e Propriétés-\u003e C / C ++ Build-\u003e Paramètres-\u003e Paramètres de l'outil et commencez à personnaliser les outils de montage:
1) précancheur ciblé
Nous choisissons de travailler exactement au compilateur COREX COREX.
- Processeur: Cortex-M3
.jpg)
2) Compiler Sourcer Sourcery Linux C compilateur CCC -\u003e Préprocesseur
Ajoutez deux définir-A en les envoyant via le compilateur Ke -D.
- STM32F10X_LD_VL - Définit une règle (à propos de cette définition-e que j'ai écrite ci-dessus)
- UTILISE_STDPERIPH_DRIVER - Spécification de la bibliothèque CMSIS qu'il doit utiliser le pilote SPL
.jpg)
3) Compiler Sourcer Sourcery GCC C Compiler -\u003e Répertoires
Ajoutez le chemin d'accès aux bibliothèques incluses.
- "$ (Workspace_Loc: / $ (projname) / cmsis)"
- "$ (Workspace_Loc: / $ (projname) / spl / inc)"
.jpg)
Maintenant, par exemple, si nous écrivons:
#include "stm32f10x.h.
Ensuite, le compilateur doit d'abord rechercher le fichier stm32f10x.h. Dans le répertoire de projet (il le fait toujours), il ne le trouvera pas là-bas et commencer à rechercher dans le dossier CMSIS, le chemin vers lequel nous avons souligné et le trouvera.
4) Compiler Sourcer Sourcery Linux GCC C -\u003e Optimisation
Inclure l'optimisation des fonctions et des données
- -Ffunction-sections
- -Fdata-sections
En conséquence, toutes les fonctions et éléments de données seront placés dans des sections distinctes et le collecteur sera capable de comprendre quelles sections ne sont pas utilisées et les jettent simplement.
5) Compiler Sourcer Sourcery Linux Compiler -\u003e Général
Ajoutez un chemin à notre script de liaison: "$ (Workspace_Loc: / $ (projname) /stm32f100c4.ld)" (ou comment il s'appelle-t-il).
Et définir les options:
- N'utilisez pas de fichiers de démarrage standard - N'utilisez pas de fichiers de démarrage standard.
- Supprimer les sections non utilisées - Supprimer des sections inutilisées
Tout, le réglage est terminé. D'ACCORD.
Depuis la création du projet, nous avons fait beaucoup de choses, et quelque chose d'Eclipse ne pouvait pas remarquer, nous devons lui dire de réviser la structure des fichiers de projet. Pour ce faire, du menu contextuel du projet, vous devez faire Index -\u003e Reconstruire.
Bonjour LED sur STM32
Il est temps de créer le fichier de projet principal: Fichier -\u003e Nouveau -\u003e C / C ++ -\u003e Fichier source. Suivant. Nom du fichier Fichier Source: Main.c.
Copiez et insérez les éléments suivants dans le fichier:
#Include "stm32f10x.h" uint8_t i \u003d 0; Int Main (void) (RCC-\u003e APB2ENR | \u003d RCC_APB2ENR_IOPBEN; // Activer l'horloge PORTB PERIPH RCC-\u003e APB1ENR_TIM2EN; // Activer TIM2 PERIPH HORLOGIE // Désactiver JTAG pour libérer PIN DE LED RCC-\u003e APB2ENR | \u003d RCC_APB2ENR_AFIOEN; AFIO-\u003e MAPR | \u003d AFIO_MAPR_SWJ_CFG_JTAGDISABLE; // CLEAR PB4 et PB5 Registre de contrôle BITS GPIOB-\u003e CRL & \u003d ~ (GPIO_CRL_MODE4 | GPIO_CRLL_CNF4 | GPIO_CRLL_MODE5 | GPIO_CRLL_CNF5 | GPIO_CRLL_CNF5); // Configurez PB.4 et PB.5 comme Push Pull Sortie à Max 10MHZ GPIOB-\u003e CRL | \u003d GPIO_CRL_MODE4_0 | GPIO_CRL_MODE5_0; TIM2-\u003e PSC \u003d SystemCorClock / 1000 - 1; // 1000 Tick / SEC TIM2-\u003e Ar \u003d 1000; // 1 interruption / 1 sec Tim2-\u003e Dier | \u003d TIM_DIER_UIE; // Activer TIM2 Interruption TIM2-\u003e CR1 | \u003d TIM_CR1_CEN; // Démarrer le compte nvic_enableirq (TIM2_IRQN); // Activer IRQ tandis que (1); // LOOP INFINITY) VOID TIM2_IRQHANDLER (VOID) (TIM2-\u003e SR & \u003d ~ TIM_SR_UIF ; // drapeau uif propre si (1 \u003d\u003d (i ++ & 0x1)) (GPIOB-\u003e BSRR \u003d GPIO_BSRRRR_BS4; // SET PB4 BIT GPIOB-\u003e BSRR \u003d GPIO_BSRRR_BR5; // Réinitialiser PB5 Bit) Autres (GPIOB-\u003e BSRR \u003d GPIO_BSRR_B. S5; // SET PB5 BIT GPIOB-\u003e BSRR \u003d GPIO_BSRRR_BR4; // réinitialiser le bit PB4))
Bien que nous ayons branché les bibliothèques SPL, il n'a pas été utilisé ici. Tous les appels aux champs tels que RCC-\u003e APB2ENR sont entièrement décrits dans les CMSI.
Vous pouvez effectuer un projet -\u003e construire tout. Si tout se passe, le fichier STM32_LD_VL.HEX doit apparaître dans le dossier de débogage du projet. Il a été généré automatiquement à partir d'outils intégrés ELF. Nous cloupons le fichier et voyons comment les voyants clignotent à une fréquence une fois par seconde:
Vsprog -sstm32f1 -ms -oe -owf -i /home/user/workspace/stm32_ld_vl/debug/stm32_ld_vl.hex -v "tvcc.set 3300"
Naturellement, au lieu d'accueil / Accueil / Utilisateur / Espace de travail / Vous devez entrer votre chemin vers l'espace de travail.
Pour STM32VLDISCOVERY.
Le code est légèrement différent de celui que j'ai donné ci-dessus pour ma carte de débogage. La différence réside dans les épingles, qui sont des voyants "suspendues". Si j'ai au plat, c'était PB4 et PB5, puis dans la découverte, il est PC8 et PC9.
#Include "stm32f10x.h" uint8_t i \u003d 0; Int Main (void) (RCC-\u003e APB2ENR | \u003d RCC_APB2ENR_IOPCEN; // Activer l'horloge PORTC PERIPH RCC-\u003e APB1ENR_TIM2EN; // Activer TIM2 PERIPH HORLOGE // CLEAR PC8 et PC9 Registre de contrôle BITS GPIOC-\u003e CRH & \u003d ~ (GPIO_CRH_MODE8 | GPIO_CRHH_CNF8 | GPIO_CRHH_MODE9 | GPIO_CRHH_MODE9 | GPIO_CRHH_CNF9); // Configurez PC8 et PC9 comme sortie de pull-push à partir de 10 MHz GPIOC-\u003e CRH | \u003d GPIO_CRH_MODE8_0 | TIM2-\u003e PSC \u003d SystemCoreclock / 1000 - 1, 1000 // TICK / SEC Tim2-\u003e arr \u003d 1000; // 1 interruption / sec (1000/100) Tim2-\u003e Dier | \u003d Tim_dier_uie; // Activer Tim2 Interruption TIM2-\u003e CR1 | \u003d TIM_CR1_CEN; // Démarrer le compte nvic_enableirq (TIM2_IRQN); // Activer IRQ tandis que (1); // LOOP INFINITY) NOID TIM2_IRQHANDLER (VOID) (TIM2-\u003e SR & \u003d ~ TIM_SR_UIF; // Nettoyez le drapeau UIF si (1 \u003d\u003d (i ++ & 0x1)) (GPIOC-\u003e BSRR \u003d GPIO_BSRRR_BS8; // SET PC8 BIT GPIOC-\u003e BSRR \u003d GPIO_BSRRR_BR9; // PC9 (GPIOC-\u003e BSRR \u003d GPIO_BSRRR_BS9; // SET PC9 BIT GPIOC-\u003e BSRR \u003d GPIO_BSRRR_BR8; // RESET PC8 BIT))
Sous Windows, Flash Le hexagone résultant (/workspace/stm32_md_vl/debug/stm32_md_vl.hex) peut être utile de ST.
Eh bien, sous Linux Utility ST-Flash. MAIS!!! L'utilitaire n'a pas de format hexagonal Intel Hex (généré par défaut), il est donc extrêmement important dans les paramètres de création de l'image flash, sélectionnez Format binaire:
L'extension de fichier ne change pas (restes hexagonales), mais le format de fichier changera. Et seulement après cela, vous pouvez effectuer:
ST-Flash Ecrire v1 /home/user/workspace/stm32_md_vl/debug/stm32_md_vl.hex 0x08000000
Au fait, sur l'extension et le format: Les fichiers binaires généralement sont marqués d'extension.bin, tandis que les fichiers de format Hex Intel sont appelés extension. Hex. La différence dans ces deux formats est plus technique que fonctionnelle: le format binaire contient simplement des octets d'instructions et de données qui seront simplement enregistrés dans le programmateur du contrôleur "tel quel". Intelhex n'a pas non plus de format binaire, mais texte: exactement les mêmes octets sont divisés par 4 bits et sont présentés dans un format ASCII en format ASCII, et seuls les caractères 0-9, AF (bacs et hex-Nubering Systems avec plusieurs bases sont utilisés, C'est-à-dire que 4 bits dans la corbeille peuvent être représentés par un chiffre dans Hex). Donc, le format IHEX est supérieur à 2 fois plus élevé que la taille d'un fichier binaire régulier (tous les 4 bits sont remplacés par des transferts de cordes d'octets + pour une lecture pratique), mais il peut être lu dans l'éditeur de texte habituel. Par conséquent, si vous allez envoyer ce fichier à quelqu'un ou l'utiliser dans d'autres programmes de programmeurs, il est conseillé de le renommer à STM32_MD_VL.BIN, afin de ne pas induire en erreur ceux qui vont regarder son nom.
Nous avons donc configuré l'assemblage du micrologiciel pour STM32. La prochaine fois que je vais vous dire comment
La liste des articles qui aideront à explorer le microcontrôleur STM32 encore débutant. En détail sur tout avec des exemples, allant du voyant clignotant avant de contrôler le moteur en vrac. Les exemples utilisent la bibliothèque SPL standard (bibliothèque périphérique standard).
Testez la carte STM32F103, programmeur ST-Link et logiciel pour le micrologiciel sous Windows et Ubuntu.
Vic (contrôleur d'interruption vectorisé non imbriqué) - Module de contrôle d'interruption. Régler et utiliser des interruptions. Interrompre les priorités. Interruptions investies.
ADC (convertisseur analogique-numérique). Circuit d'alimentation et exemples d'utilisation des ADC dans divers modes. Canaux réguliers et injectés. Utilisation de l'ADC avec DMA. Thermomètre interne. Watchdog analogique.
Moyers de destination générale. Interruption de génération à intervalles réguliers. Mesure du temps entre deux événements.
Signal de minuterie Capture sur l'exemple de travail avec le capteur à ultrasons HC-SR04
Utilisez la minuterie pour travailler avec le codeur.
Génération de pwm. Contrôle de la luminosité de LED. Serveuse de gestion (servo). Génération sonore.
Lorsque vous commencez simplement à programmer des microcontrôleurs ou que vous n'avez pas été engagé dans la programmation pendant une longue période, il est assez facile de comprendre le code de quelqu'un d'autre. Questions "Qu'est-ce que c'est?" Et d'où vient-il?" Il y a presque toutes les combinaisons de lettres et de chiffres. Et plus la compréhension de la logique vient de venir "quoi? Pourquoi? Et où?", Plus il est plus facile d'étudier le code de quelqu'un d'autre, y compris des exemples. Vrai, parfois, il n'y a pas un jour pour "sauter sur le code" et "manuels de polystay".
Tous les microcontrôleurs STM32F4XX ont quelques périphériques. Pour chaque périphérique périphérique, les microcontrôleurs sont fixés une zone de mémoire spécifique, particulière et non mémorable. Chaque zone de mémoire est composée de registres de mémoire, et ces registres peuvent être de 8 bits, 16 bits, 32 bits ou même comme dépend du microcontrôleur. Dans le microcontrôleur STM32F4, ces registres 32 bits et chaque registre ont son propre but et son adresse spécifique. Rien ne les empêche dans leurs programmes de les contacter directement, indiquant l'adresse. A quelle adresse est un ou un autre registre et à quel appareil périphérique il fait référence à la carte mémoire. Pour STM32F4, une telle carte mémoire est dans le document DM00031020.PDF, disponible sur le site ST.com. Le document est appelé
RM0090.
MANUEL DE RÉFÉRENCE.
STM32F405XX / 07XX, STM32F415XX / 17XX, STM32F42XXX et STM32F43XXXX MCUS 32 bits Bras basés sur les bras avancés
Au chapitre 2.3 Carte mémoire À la page 64, une table commence par des adresses de registres et de leurs accessoires au périphérique. La même table a un lien vers une section avec une distribution de mémoire plus détaillée pour chaque périphérie.
À gauche dans la table indique la plage d'adresses, au milieu du nom périphérique et dans la dernière colonne - où une description plus détaillée de l'allocation de mémoire est une description plus détaillée.
Ainsi, pour les ports d'E / S GPIO General OU / O dans la table de distribution de la mémoire, vous pouvez trouver les adresses de 0x4002 0000 pour eux. Le port d'E / S à usage général de la GPIAA prend la gamme d'adresses de 0x4002 000 à 0x4002 03FF. Le port GPIOB prend la gamme d'adresses 0x4002 400 - 0x4002 07FF. Etc.
Afin de voir une distribution plus détaillée dans la gamme elle-même, il vous suffit de passer par le lien.
Il y a aussi une table, mais déjà avec une carte mémoire pour la gamme d'adresses GPIO. Selon cette carte mémoire, les 4 premiers octets appartiennent au registre modéré, les 4 octets suivants appartiennent au registre OTPER et ainsi de suite. L'adresse des registres est considérée depuis le début de la plage appartenant au port GPIO spécifique. C'est-à-dire que chaque enregistrement GPIO a une adresse spécifique pouvant être utilisée dans le développement de programmes de microcontrôleur.
Mais l'utilisation d'adresses de registre pour une personne est inconfortable et amorcée avec un grand nombre d'erreurs. Par conséquent, les fabricants de microcontrôleurs créent des bibliothèques standard qui facilitent le fonctionnement avec les microcontrôleurs. Dans ces bibliothèques, les adresses physiques sont mises en ligne avec leur désignation des lettres. Pour STM32F4XX, ces correspondances sont spécifiées dans le fichier. stm32f4xx.h.. Déposer stm32f4xx.h. Croit bibliothèque Cmsis Et réside dans les bibliothèques \\ cmsis \\ st \\ stm32f4xx \\ incluent le dossier \\.
Voyons comme définis dans les bibliothèques portuaires GPIAA. De même, tout le reste est déterminé. Il suffit de comprendre le principe. Déposer stm32f4xx.h.assez gros et il est donc préférable d'utiliser la recherche ou les capacités que fournit votre boîte à outils.
Pour le port de GPIAA, nous trouvons la ligne dans laquelle le GPIAA_BASE est mentionné
Gpioa_base est définie via AHB1PERIPH_BASE
Ahb1periph_base à son tour est déterminé via PeriPH_Base
Et à son tour, PeriPH_Base est défini comme 0x4000 0000 0000. Si vous voyez la carte de la carte mémoire périphérique (dans la section 2.3 Carte mémoire À la page 64), nous verrons cette adresse au bas de la table. À partir de cette adresse, les registres de toute la périphérie du microcontrôleur STM32F4 commencent. C'est-à-dire que PeriPH_Base est l'adresse initiale de l'ensemble de la périphérie des microcontrôleurs STM32F4XX en général et le microcontrôleur STM32F407VG en particulier ..
AHB1PERIPH_BASE est défini comme la quantité (PERIPH_BASE + 0X00020000). (Voir Martinki Retour). Il s'agira d'une adresse 0x4002 0000. Dans la carte mémoire de cette adresse, commence les ports d'E / S GPIO General Ust.
Gpioa_base est définie comme (AHB1PerIPH_BASE + 0X0000), c'est-à-dire l'adresse initiale du groupe GPIA Port Registers.
Eh bien, le port Gpioa lui-même est défini comme une structure des registres, dont le placement de la mémoire commence par l'adresse Gpioa_Base (voir la chaîne Gpioa #define Gpioa ((GPIO_TYPEDEF *) GPIOA_BASE).
La structure de chaque port GPIO est définie comme le type GPIO_TYPEDF.
Ainsi, les bibliothèques standard, dans ce cas, le fichier stm32f4xx.h., nous supprimons simplement l'adressage de la machine. Si vous voyez l'enregistrement GpioA-\u003e ODR \u003d 1234, cela signifie que le nombre 1234. Gpioa sera enregistré à 0x40020014. Gpioa a l'adresse initiale de 0x40020000 et le registre ODR a une adresse 0x14 à partir du début de la gamme. Gpioa -\u003e ODR a une adresse 0x40020014.
Ou, par exemple, vous n'aimez pas l'enregistrement GpioA-\u003e ODR, vous pouvez déterminer #Define gpioa_odr ((uint32_t *) 0x40020014) et obtenir le même résultat en écrivant gpioa_odr \u003d 1234; Seulement dans quelle mesure est-il? Si vous voulez vraiment introduire mes propres désignations, il est préférable de simplement réaffecter la norme. Comment ça se fait, vous pouvez voir dans le fichier stm32f4_discovery.h. Par exemple, c'est ainsi que l'une des LED est déterminée:
#define LED4_PIN GPIO_PIN_12
#Define LED4_GPIO_PORT Giod.
#Define LED4_GPIO_CLK RCC_AHB1PERIPH_GIOD.
Une description plus détaillée de la périphérie des ports est dans stm32f4xx_gpio.h.
Bonjour à tous. Comment vous souvenez-vous du dernier article que nous avons configuré un progiciel pour travailler avec les microcontrôleurs STM32 et compilé le premier programme. Dans ce message, nous vous familiariserons avec l'architecture de ce conseil d'administration, du microcontrôleur et des bibliothèques existantes pour le travail.
Ci-dessous est le dessin du tableau STM32F3 Discovery. Où: 1 - Capteur MEMS. Gyroscope numérique à 3 axes L3GD20. 2 - MEMS System-B-Case contenant un accéléromètre linéaire numérique à 3 axes et un capteur numérique LSM303DLHC numérique à 3 axes. 4 - LD1 (PWR) - Alimentation 3.3V. 5 - LD2 - LED rouge / vert. La valeur par défaut est rouge. Vert signifie la liaison entre ST-Link / V2 (ou V2-B) et PC. J'ai ST-Link / V2-B, ainsi que des indications utilisateur ports USB. 6. -LD3 / 10 (rouge), LD4 / 9 (bleu), LD5 / 8 (orange) et LD6 / 7 (vert). Dans le dernier enregistrement, nous mugsd LED4 LED. 7. - Deux boutons: utilisateur personnalisé et réinitialisation de réinitialisation. 8. - Utilisateur USB avec connecteur mini-B.9 - Le débogueur / programmeur USB St-Link / v2. une 0. - Microcontrôleur STM32F303VCT6. 11. - Générateur externe haute fréquence de 8 MHz. 12. - Il devrait y avoir un générateur à basse fréquence, malheureusement non couché. 13. - SWD - interface. 14. - Jumpers Pour sélectionner la programmation des contrôleurs externes ou interne, dans le premier cas, doit être supprimé. 15 - Jumper JP3 - Jumper, conçu pour connecter un ammène, ce qui mesurerait la consommation du contrôleur. Il est clair s'il est supprimé, alors nos cailloux ne commenceront pas. 16. - STM32F103C8T6 Il y a une carte de débogage à ce sujet. 17. - Régulateur LD3985M33R avec baisse basse tension et niveau de bruit, 150 mA, 3,3b.
Maintenant, demandons-vous à l'architecture du microcontrôleur STM32F303VCT6. Sa caractéristique technique: étui LQFP-100, arme cortex-m4 noyau, fréquence maximale 72 noyaux MHz, mémoire logicielle 256 Ko, type de mémoire Flash Type de mémoire, SRAM 40 Ko logiciel, RAM 8 KB, Nombre d'entrées / sorties 87, Interfaces (CAN, ISK, IRDA, LIN, SPI, UART / USART, USB), Périphériques (DMA, I2S, por, PWM, WDT), ADC / DAC 4 * 12 bits / 2 * 12 bits, tension d'alimentation 2 ... 3,6 V, température de fonctionnement -40 ... ... + 85 C. Sur la figure Au-dessous de la pinèse, où nous voyons 87 ports d'E / S, 45 d'entre eux normaux I / OS (TC, TTA), 42 Tolérants Tolérants 5 volts (FT, FTF) - compatibles avec 5 V. (sur la planche les conclusions de 5V bonnes, laissés 3,3v). Chaque ligne d'E / S numérique peut effectuer la fonction de ligne Générale I / O 
affectation ou fonctionnalité alternative. Grâce à la promotion des projets, nous rencontrerons systématiquement la périphérie.
Considérez le diagramme de bloc ci-dessous. Le cœur est le bras de noyau 32 bits Cortex-M4, travaillant jusqu'à 72 MHz. Il possède une unité de protection de la mémoire flotatrice FPU intégrée et une unité de protection de la mémoire MPU intégrée, des cellules macro-macro-macro-méthodes intégrées (ETM), qui peuvent être utilisées pour surveiller le processus d'exécution du programme principal à l'intérieur du microcontrôleur. Ils sont capables de générer continuellement ces observations via des contacts ETM jusqu'à ce que le périphérique fonctionne. NVIC (contrôleur d'instructeur imbriqué) - Module de contrôle d'interruption. TPIU (unité d'interface de port de trace). Contient une mémoire Flash -256 KBYTE, SRAM 40 KB, RAM 8 KB. Entre le noyau et la mémoire se trouve la matrice de bus (matrice de pneus), ce qui vous permet de connecter directement des périphériques. En outre, nous voyons deux types de matrice de pneu AHB et APB, où le premier est plus productif et est utilisé pour communiquer des composants internes à grande vitesse et celui-ci pour la périphérie (périphériques d'E / S). Le contrôleur dispose d'ADC de 4-Series (ADC) (5 Mbps) et d'un capteur de température, 7 comparateurs (GP comparArateur1 ... 7), amplificateur de fonctionnement programmable à 4 RT (OPAMP1 ... 4) (PGA (gain programmable Array)), 2 12 canaux soufflés de DAC (CAD), RTC (horloge en temps réel), deux minuteries de surveillance sont indépendantes et fenêtre (WinWatchDog et Ind. WDG32K), 17 minuteries à usage général et multifonctions.
En termes généraux, nous avons examiné l'architecture du contrôleur. Envisagez maintenant des bibliothèques logicielles disponibles. La création d'un aperçu peut être sélectionnée comme suit: CMSIS, SPL et HAL. Considérer chacun appliqué dans exemple simple LED clignotant.
1). Cmsis (Standard de l'interface logicielle du microcontrôleur Cortex) - Bibliothèque standard pour Cortex®-M. Fournit une prise en charge des périphériques et simplifie les interfaces logicielles. CMSIS fournit cohérent et interfaces simples pour le noyau, sa périphérie et systèmes d'exploitation temps réel. Son utilisation est une manière professionnelle de programmes d'écriture, car Il suppose une entrée directe dans les registres et, en conséquence, il est nécessaire de lire et d'explorer constamment des fiches techniques. Indépendant du fabricant du matériel. 
CMSIS comprend les composants suivants:
- CMSIS-noyau: démarrage du système cohérent et accès périphérique (accès du système de démarrage et accès périphérique);
- CMSIS-RTOS: Exécution logicielle en temps réel déterministe (performance déterministe du logiciel en temps réel);
- CMSIS-DSP: Mise en œuvre rapide du traitement du signal numérique (vente rapide traitement numérique signaux);
- CMSIS-pilote: interfaces périphériques génériques pour le middleware et le code d'application (interfaces périphériques générales pour le logiciel intermédiaire et code d'application);
- CMSIS-PACK: Accès facile à des composants logiciels réutilisables (accès facile à plusieurs composants logiciels);
- CMSIS-SVD: vue cohérente sur le dispositif et les périphériques (présentation constante de dispositifs et périphériques);
- CMSIS-DAP: Connectivité au matériel d'évaluation à faible coût (capacité à se connecter à un équipement peu coûteux pour évaluation). En débogage.
Par exemple, nous écrivons le programme de programmation. Pour cela, nous aurons besoin de la documentation décrivant les registres. Dans mon cas RM0316 Manuel de référence STM32F303XB / C / D / E, STM32F303X6 / 8, STM32F328X8, STM32F358XC, STM32F398XE Advanced ARM ®-Based MCU, ainsi que la description de la jambe de Capreen pour ce qui est responsable DS9118.: FPU CORTEX®-M4 32B MCU + basé à Bras®, hauteur de 256 kb Flash + 48KB SRAM, 4 ADC, 2 Comp, 4 Comp, 4 PGA, TIMERS, 2.0-3. V. Pour commencer, dans le programme, nous allons tourner le port, car Par défaut, tout est désactivé que la consommation d'EURG réduite est atteinte. Ouvrez le manuel de référence et voir la section de contrôle de réinitialisation et de contrôle d'horloge suivante Carte de l'enregistrement RCC et regardez l'inclusion de l'enregistrement IOPEEEN
Passons à la description du tact de la retraite de ce registre Registre d'activation de l'horloge périphérique AHB (RCC_AHBENR)Où nous voyons que ce port est sous le 21ème. Allumer son RCC-\u003e Ahbenr | \u003d (1<<21) . Далее сконфигурируем регистры GPIO. Нас интересует три: GPIOE_MODER и GPIOx_ODR . C помощью них повторим программу с предыдущей статьи, затактируем PE8. Первый отвечает за конфигурацию входа выхода, выбираем 01: General purpose output mode. GPIOE->Moder | \u003d 0 × 1000. La seconde pour passer de niveau bas / haut sur la jambe. En dessous du programme:
#include "stm32f3xx.h. "// fichier d'en-tête de microcontrôleur
Non signé int i;
délai d'annulation () (
pour (i \u003d 0; i<500000;i++);
}
int main (vide) (
RCC-\u003e AHBENR | \u003d (1<<21);
Gpioe-\u003e moder | \u003d 0 × 10000;
Tandis que (1) (
retard ();
Gpioe-\u003e odr | \u003d 0 × 100;
retard ();
GPIOE-\u003e ODR & \u003d ~ (0 × 100);
} }
2). Spl Bibliothèque de périphériques standard) - Cette bibliothèque est destinée à combiner tous les processeurs ST Electronics. Il est conçu pour effectuer les codes prénatriquement et est principalement conçu pour un prunt de départ. ST a travaillé sur le remplacement de SPL appelé "couche laïque", compatible avec HAL. Les pilotes basse couche (LL) sont conçus pour fournir un niveau presque orienté source de la source, qui est plus proche de l'équipement que Hal. En plus de HAL, LL API est également disponible. Un exemple de programme Toye sur SPL.
#Inclure.
#Inclure.
#Inclure.
#Define LED GPIO_PIN_8.
INT MAIN () (
Long I;
Gpio_InittYpedef GPIO;
// LED bleue est connecté au port E, PIN 8 (bus AHB)
RCC_AHBPERIPHCLOCKCMD (RCC_AHBPERIPH_GPIOE, Activer);
// Configurez le port E (LED)
GPIO_SRUCTINIT (& GPIO); // déclarer et initialiser la structure de données variable
gpio.gpio_mode \u003d gpio_mode_out;
gpio.gpio_pin \u003d LED;
Gpio_init (GPIOE, & GPIO);
// LED clignotants.
Tandis que (1) (
// AU.
Gpio_setbits (GPioe, LED);
pour (i \u003d 0; i< 500000; i++);
// tous.
GPIO_RESETBITS (GPIOE, LED);
pour (i \u003d 0; i< 500000; i++);
} }
Chaque fonction est décrite dans la documentation technique. UM1581 Manuel d'utilisation Description de la bibliothèque périphérique standard STM32F30XX / 31XX. Vous connectez ici les trois fichiers d'en-tête contenant les fonctions de données, de structures, de réinitialisation et de synchronisation nécessaires, ainsi que pour la configuration des ports d'E / S.
3). Hal.- (niveau accessoire matériel, couche d'abstraction matérielle) - une autre bibliothèque générale pour le développement. Avec lequel le programme CUBEMX a été publié pour la configuration que nous avons utilisée dans le dernier article. Au même endroit, nous avons écrit un programme clignotant par la LED en utilisant cette bibliothèque. Comme vous pouvez le constater dans la figure ci-dessous, le cube génère des pilotes HAL et CMSIS. Eh bien, nous décrivons les fichiers utilisés de base:
- System_stm32f3x.c i. system_stm32f3x.h. - fournir des ensembles minimaux de fonctions pour la configuration du système d'horloge;
- core_cm4.h - donne accès aux registres principaux et à sa périphérie;
- STM32F3X.H - Fichier d'en-tête de microcontrôleur;
- Démarrage_system32f3x.s - Le code de démarrage contient une table des vecteurs d'interruption et d'autres.
#Include "main.h"
#include "stm32f3xx_hal.h"
void systemclock_config (nul); / * Déclarez les fonctions de configuration d'horloge * /
Void statique mx_gpio_init (vide); / * Initialisation d'entrée / sortie * /
int main (vide) (
/ * Réinitialisation de tous les périphériques, initialise l'interface flash et le systetick. * /
Hal_init ();
/ * Configurez l'horloge système * /
Systemclock_config ();
/ * Initialiser tous les périphériques configurés * /
Mx_gpio_init ();
Tandis que (1) (
Hal_gpio_togglepin (gpioe, gpio_pin_8); // commutateur l'état de la jambe
Hal_delay (100); )
}
Void systemclock_config (void){
Rcc_oscinittypedef rcc_oscinitstruct;
Rcc_clkinittypedef rcc_clkinitstruct;
RCC_OSCINISTRUCT.OSCILLATYPE \u003d RCC_OSCILCILTYPE_HSI;
Rcc_oscinitstruct.hsite \u003d rcc_hsi_on;
Rcc_oscinitstruct.hsicalibrationValue \u003d 16;
Rcc_oscinitstruct.pll.pllstate \u003d rcc_pll_none;
Si (HAL_RCC_OSCINCONFIG (& RCC_OSSCINIDITUCT)! \u003d HAL_OK){
}
/ ** Initialise les horloges des bus CPU, AHB et APB * /
Rcc_clkinitstruct.clocktype \u003d rcc_clocktype_hclk | rcc_clocktype_sysclk
| RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
Rcc_clkinitstruct.sysclksource \u003d rcc_sysclksource_hsi;
Rcc_clkinitstruct.ahbclkdivider \u003d rcc_sysclk_div1;
Rcc_clkinitstruct.apb1clkdivider \u003d rcc_hclk_div1;
Rcc_clkinitstruct.apb2clkdivider \u003d rcc_hclk_div1;
Si (hal_rcc_clkincconfig (& rcc_clkinitstruct, flash_latency_0)! \u003d Hal_ok){
_Error_Handler (__file__, __line__);
}
/ ** Configurez le temps d'interruption de Systick * /
Hal_systick_config (hal_rcc_gethclkfreq () / 1000);
/ ** Configurez le Systick * /
Hal_systick_clksourceconfig (systick_clksource_hclk);
/ * Configuration d'interruption Systick_IRQN * /
Hal_nvic_setpriority (systick_irqn, 0, 0);
}
/ ** Configurez les broches comme sortie d'entrée analogique Event_out Exti * /
Void statique mx_gpio_init (void){
Gpio_inittypedef gpio_inditstruct;
/ * GPIO Ports Horloge Activer * /
__Hal_rcc_gpioe_clk_enable ();
/ * Configurez le niveau de sortie GPIO PIN * /
Hal_gpio_writepin (gpioe, gpio_pin_8 | gpio_pin_9 | gpio_pin_10 | gpio_pin_11
| GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15, GPIO_PIN_RESET);
/ * Configurer GPIO PINS: PE8 PE9 PE10 PE11 PE12 PE12 PE13 PE14 PE15 * /
Gpio_initstruct.pin \u003d gpio_pin_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11
| GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;
Gpio_initstruct.mode \u003d gpio_mode_output_pp;
Gpio_initstruct.pull \u003d gpio_nopull;
Gpio_initstruct.speed \u003d gpio_speed_freq_low;
Hal_gpio_init (gpioe, & gpio_inditstructeur);
}
void _Error_Handler (char * fichier, ligne int){
Tandis que (1) (
}
}
#Ifdef utilise_full_assert.
Void ASSERT_FAILED (fichier uint8_t *, ligne uint32_t){
}
#Fin si
Ici, ainsi que dans l'exemple précédent, nous pouvons afficher la description de chaque fonction de la documentation, par exemple UM1786 Manuel d'utilisation Description des pilotes STM32F3 HAL et Low-couches.
Nous pouvons résumer que la première action, à l'aide de CMSI, est moins volumineuse. Chaque bibliothèque a une documentation. Dans les projets ultérieurs, nous utiliserons HAL et CMSI en utilisant le programme de la configuration STCUBE et, si possible, utilisez directement des registres, sans emballages de logiciels. C'est aujourd'hui et arrête. Dans le prochain article, nous examinerons les principes de base de la construction d'une maison intelligente. Jusqu'à présent.
