- Préparation du matériel
- Comprendre les brochages GPIO sur STM8S103F
- Description du brochage et astuces pour la sélection GPIO STM8S103F
- Programmation du STM8S pour l'entrée et la sortie GPIO à l'aide de SPL
- Téléchargement et test du programme
Pour les microcontrôleurs, un programme de clignotement des LED équivaut au programme «hello world». Dans notre tutoriel précédent, nous avons appris comment démarrer avec la carte de développement STM8S103F3 et comment configurer l'EDI et le compilateur pour programmer nos contrôleurs STM8S. Nous avons également appris à utiliser les bibliothèques de périphériques standard et à compiler et télécharger le code dans notre microcontrôleur. Avec toutes les bases couvertes, commençons à écrire du code. Dans ce tutoriel, nous allons apprendre à exécuter des fonctions GPIO générales sur les contrôleurs STM8S. La carte a déjà une LED intégrée connectée à la broche 5 du port B, nous allons apprendre à faire clignoter cette LED et également ajouter une LED externe et la contrôler avec un bouton poussoir. Si vous êtes complètement nouveau, il est fortement recommandé de lire le tutoriel précédent avant de continuer.
Préparation du matériel
Avant de plonger dans le programme, préparons les connexions matérielles. Comme mentionné précédemment, nous utiliserons ici deux LED, l'une est une LED intégrée qui clignotera en continu et l'autre est une LED externe qui sera basculée avec un bouton poussoir. L'idée est d'apprendre toutes les fonctionnalités GPIO dans une configuration simple. La Led embarquée est déjà connectée à PB5 (pin5 de PORTB), je viens donc de connecter une LED à PA3 et un bouton poussoir à PA2, comme vous pouvez le voir sur le schéma ci-dessous.
Mais, de toutes les broches de sortie disponibles sur notre contrôleur, pourquoi ai-je sélectionné PA3 pour la sortie et PA2 pour l'entrée? Les questions sont valables et je vous l'expliquerai plus tard dans cet article. Ma configuration matérielle pour ce didacticiel est indiquée ci-dessous. Comme vous pouvez le voir, j'ai également connecté mon programmeur ST-link à des broches de programmation qui non seulement programmeront notre carte, mais serviront également de source d'alimentation.
Comprendre les brochages GPIO sur STM8S103F
Revenons maintenant à la question, pourquoi PA2 pour l'entrée et pourquoi PA3 pour la sortie? Pour comprendre cela, examinons de plus près le brochage du microcontrôleur qui est illustré ci-dessous.
Selon le schéma de brochage, nous avons quatre ports sur notre microcontrôleur, à savoir, PORT A, B, C et D désignés respectivement par PA, PB, PC et PD. Chaque broche GPIO est également dotée d'autres fonctionnalités spéciales. Par exemple, le PB5 (broche 5 du PORT B) peut non seulement fonctionner comme broche GPIO mais aussi comme broche SDA pour la communication I2C et comme broche de sortie du temporisateur 1. Donc, si nous utilisons cette broche à des fins GPIO simples comme la connexion d'une LED, nous ne pourrons pas utiliser I2C et la LED en même temps. Malheureusement, la LED embarquée est connectée à cette broche, donc nous n'avons pas beaucoup de choix ici, et dans ce programme, nous n'allons pas utiliser I2C, donc ce n'est pas vraiment un problème.
Description du brochage et astuces pour la sélection GPIO STM8S103F
À vrai dire, cela ne ferait pas de mal d'utiliser PA1 une broche d'entrée et cela ne ferait que travailler la broche. Mais j'ai délibérément soulevé cela pour me donner l'occasion de vous montrer quelques pièges courants dans lesquels vous pourriez tomber lors de la sélection des broches GPIO sur un nouveau microcontrôleur. Le mieux pour éviter les pièges est de lire les détails des broches et la description des broches fournis dans la fiche technique du STM8S103F3P6. Pour la description des broches du microcontrôleur STM8S103F3P6, les détails mentionnés dans la fiche technique sont indiqués ci-dessous.
Les broches d'entrée de notre microcontrôleur peuvent être flottantes ou faibles et les broches de sortie peuvent être Open Drain ou Push-pull. La différence entre les broches de sortie Open Drain et Push-Pull Output est déjà discutée, nous n'entrerons donc pas dans les détails. Pour faire simple, une broche de sortie Open Drain peut rendre la sortie aussi basse pas aussi élevée, tandis qu'une broche de sortie push-pull peut rendre la sortie aussi élevée que élevée.
En dehors de cela dans le tableau ci-dessus, vous pouvez également remarquer qu'une broche de sortie peut être une sortie rapide (10 Mhz) ou une sortie lente (2 MHz). Cela détermine la vitesse GPIO, si vous souhaitez basculer vos broches GPIO entre haut et bas très rapidement, nous pouvons choisir la sortie rapide.
Certaines broches GPIO de notre contrôleur prennent en charge le True Open Drain (T) et le High Sink Current (HS), comme mentionné dans l'image ci-dessus. Une différence considérable entre Open Drain et True Open Drain est que la sortie connectée au drain ouvert ne peut pas être tirée plus haut que la tension de fonctionnement du microcontrôleur (Vdd) tandis qu'une véritable broche de sortie à drain ouvert peut être tirée plus haut que Vdd. Les broches avec une capacité de puits élevée signifient qu'il peut absorber plus de courant. Le courant de source et de puits de toute broche GPIO HS est de 20 mA, tandis que la ligne électrique peut consommer jusqu'à 100 mA.
En regardant de plus près l'image ci-dessus, vous remarquerez que presque toutes les broches GPIO sont de type High Sink Current (HS) à l'exception des PB4 et PB5 qui sont de type True Open Drain (T). Cela signifie que ces broches ne peuvent pas être rendues hautes, elles ne pourront pas fournir 3,3 V même lorsque la broche est rendue haute. C'est pourquoi la led embarquée est connectée à un 3.3V et mise à la terre via PB5 au lieu de l'alimenter directement à partir de la broche GPIO.
Reportez-vous à la page 28 de la fiche technique pour la description détaillée des broches. Comme mentionné dans l'image ci-dessus, PA1 est automatiquement configuré comme un pull-up faible et il n'est pas recommandé de l'utiliser comme broche de sortie. Quoi qu'il en soit, il peut être utilisé comme une broche d'entrée avec un bouton-poussoir, mais j'ai décidé d'utiliser PA2 juste pour essayer d'activer la sortie du programme. Ce ne sont que quelques éléments de base qui seront utiles lorsque nous écrivons des programmes beaucoup plus compliqués. Pour l'instant, ce n'est pas grave si beaucoup de choses rebondissent sur votre tête, nous y entrerons dans d'autres tutoriels.
Programmation du STM8S pour l'entrée et la sortie GPIO à l'aide de SPL
Créez un espace de travail et un nouveau projet comme nous l'avons vu dans notre premier tutoriel. Vous pouvez soit ajouter tous les fichiers d'en-tête et source, soit ajouter uniquement les fichiers gpio, config et stm8s. Ouvrez le fichier main.c et commencez à écrire votre programme.
Assurez-vous d'avoir inclus les fichiers d'en-tête comme indiqué dans l'image ci-dessus. Ouvrez le fichier main.c et démarrez le code. Le code main.c complet se trouve au bas de cette page et vous pourrez également télécharger le fichier de projet à partir de là. L'explication du code est la suivante, vous pouvez également vous référer au manuel de l'utilisateur SPL ou à la vidéo liée au bas de cette page si vous êtes confus au sujet de la partie de codage.
Désinitialisation du port requis
Nous commençons notre programme par la désinitialisation des ports requis. Comme nous l'avons vu précédemment, chaque broche GPIO sera associée à de nombreuses autres fonctions autres que le simple fonctionnement d'une entrée et d'une sortie normales. Si ces broches ont déjà été utilisées pour d'autres applications, elles doivent être désinitialisées avant de les utiliser. Ce n'est pas obligatoire, cependant, c'est une bonne pratique. Les deux lignes de code suivantes sont utilisées pour désinitialiser le port A et le port B. Utilisez simplement la syntaxe GPIO_DeInit (GPIOx); et mentionnez le nom du port à la place de x.
GPIO_DeInit (GPIOA); // prépare le port A pour le travail GPIO_DeInit (GPIOB); // prépare le port B pour le travail
Déclaration GPIO d'entrée et de sortie
Ensuite, nous devons déclarer quelles broches seront utilisées comme entrée et lesquelles comme sortie. Dans notre cas, la broche PA2 sera utilisée comme entrée, nous déclarerons également cette broche avec Pull-up interne afin de ne pas avoir à en utiliser une en externe. La syntaxe est GPIO_Init (GPIOx, GPIO_PIN_y, GPIO_PIN_MODE_z); . Où x est le nom du port, y est le numéro de broche et z est le mode GPIO Pin.
// Déclarer PA2 comme broche de tirage d'entrée GPIO_Init (GPIOA, GPIO_PIN_2, GPIO_MODE_IN_PU_IT);
Ensuite, nous devons déclarer les broches PA3 et PB5 comme sortie. Encore une fois, de nombreux types de déclaration de sortie sont possibles mais nous utiliserons "GPIO_MODE_OUT_PP_LOW_SLOW" ce qui signifie que nous le déclarerons comme une broche de sortie de type push-pull à vitesse lente. Et par défaut, la valeur sera faible. La syntaxe sera la même.
GPIO_Init (GPIOA, GPIO_PIN_3, GPIO_MODE_OUT_PP_LOW_SLOW); // Déclarer PB5 comme push pull Broche de sortie GPIO_Init (GPIOB, GPIO_PIN_5, GPIO_MODE_OUT_PP_LOW_SLOW);
L'image ci-dessous du manuel de l'utilisateur SPL mentionne tous les modes GPIO possibles (z).
Boucle while infinie
Après la déclaration de la broche, nous devons créer une boucle infinie à l'intérieur de laquelle nous continuerons de faire clignoter la LED pour toujours et de surveiller l'état du bouton-poussoir pour basculer la LED. La boucle infinie peut être créée avec un while (1) ou avec un for (;;) . Ici, j'ai utilisé while (1).
tandis que (1) {}
Vérification de l'état de la broche d'entrée
Nous devons vérifier l'état de la broche d'entrée, la syntaxe pour le faire est GPIO_ReadInputPin (GPIOx, GPIO_PIN_y); où x est le nom du port et y est le numéro de broche. Si la broche est haute, nous obtiendrons «1» et si la broche est basse, nous obtiendrons un «0». Nous avons utilisé une boucle if pour vérifier si la broche est haute ou basse.
if (GPIO_ReadInputPin (GPIOA, GPIO_PIN_2)) // si le bouton est enfoncé
Rendre une broche GPIO haute ou basse
Pour rendre une broche GPIO High ou Low, nous pouvons utiliser GPIO_WriteHigh (GPIOx, GPIO_PIN_y); et GPIO_WriteLow (GPIOx, GPIO_PIN_y); respectivement. Ici, nous avons fait allumer la LED si le bouton est enfoncé et s'éteindre si le bouton n'est pas enfoncé.
if (GPIO_ReadInputPin (GPIOA, GPIO_PIN_2)) // si le bouton est enfoncé GPIO_WriteLow (GPIOA, GPIO_PIN_3); // LED allumée sinon GPIO_WriteHigh (GPIOA, GPIO_PIN_3); // LED éteinte
Activer ou désactiver une broche GPIO
Pour basculer une broche GPIO, nous avons GPIO_WriteReverse (GPIOx, GPIO_PIN_y); l'appel de cette fonction changera l'état de la broche de sortie. Si la broche est haute, elle sera changée en basse, et si elle est basse, elle sera changée en haute. Nous utilisons cette fonction pour faire clignoter la LED intégrée sur le PB5.
GPIO_WriteReverse (GPIOB, GPIO_PIN_5);
Fonction de retard
Contrairement à Arduino, le compilateur cosmique n'a pas de fonction de retard prédéfinie. Nous devons donc en créer un par nous-mêmes. Ma fonction de retard est donnée ci-dessous. La valeur doe le délai sera reçue dans la variable ms et nous en utiliserons deux pour la boucle à tenir ou l'exécution du programme. Comme _asm («nop») est une instruction d'assemblage qui signifie aucune opération. Cela signifie que le contrôleur effectuera une boucle dans la boucle for sans effectuer aucune opération, créant ainsi un retard.
void delay (int ms) // Définition de fonction {int i = 0; int j = 0; pour (i = 0; i <= ms; i ++) {pour (j = 0; j <120; j ++) // Nop = Fosc / 4 _asm ("nop"); // N'effectuer aucune opération // code d'assemblage}}
Téléchargement et test du programme
Maintenant que notre programme est prêt, nous pouvons le télécharger et le tester. Une fois téléchargé, mon matériel fonctionnait comme prévu. La LED rouge intégrée clignotait toutes les 500 millisecondes et la LED verte externe s'allumait chaque fois que j'appuyais sur l'interrupteur.
Le travail complet peut être trouvé dans la vidéo ci-dessous. Une fois que vous avez atteint ce point, vous pouvez essayer de connecter le commutateur et la LED à différentes broches et réécrire le code pour comprendre le concept. Vous pouvez également jouer avec le temps de retard pour vérifier si vous avez bien compris les concepts.
Si vous avez des questions, veuillez les laisser dans la section commentaires ci-dessous et pour d'autres questions techniques, vous pouvez utiliser nos forums. Merci d'avoir suivi, à bientôt dans le prochain tutoriel.