Communication UART série sur STM8 en utilisant Cosmic C et STVD

La programmation d'un nouveau microcontrôleur prend souvent plus de temps en raison des nouvelles méthodes de gestion des registres et du fait de ne pas savoir quel bit fait exactement quoi. Il en va de même pour le débogage sans le dire. C'est pourquoi les programmeurs utilisent assez souvent des points d'arrêt dans leur code et les parcourent à l'aide d'un débogueur. Mais l'utilisation d'un débogueur peut nécessiter du matériel supplémentaire (la plupart du temps coûteux) et également du temps supplémentaire. En tant que fan de Arduino, nous pouvons tous convenir d'utiliser des instructions d'impression en série pour le débogage et la compréhension de notre code rend la vie beaucoup plus facile. Que pouvons-nous répliquer sur les STM8 avec le compilateur cosmique C et les bibliothèques SPL? Eh bien, c'est tout à fait possible, et c'est exactement ce que nous allons faire dans ce troisième tutoriel de notre série de tutoriels.Vous vérifiez également la mise en route avec STM8S (tutoriel 1) et le contrôle GPIO STM8S (tutoriel 2) si vous êtes complètement nouveau ici. En outre, nous avons également exploré la possibilité de programmer STM8S avec Arduino pour des démarrages rapides. Tout cela étant dit, entrons dans le tutoriel.

Communication série sur STM8S103F3P6

À partir de la fiche technique du STM8S103F3P6, nous pouvons voir que notre contrôleur 8 bits prend en charge la communication UART dans de nombreux modes différents. Le contrôleur dispose également d'une broche de sortie d'horloge pour la communication UART synchrone et peut également prendre en charge SmarCard, IrDA et LIN. Mais nous n'explorerons rien de tout cela dans ce tutoriel juste pour rester à l'écart de la complexité. Nous allons apprendre à faire de la lecture et de l'écriture UART simples.

Le didacticiel fournit également un fichier d'en-tête appelé stm8s103 serial.h à l' aide duquel vous pouvez exécuter des commandes UART simples telles que Serial begin, Serial read, serial print, etc. En gros, vous pourrez imprimer char, int et string sur le moniteur série et aussi lire le caractère du moniteur série. À la fin de ce didacticiel, vous serez en mesure de contrôler une LED à partir du moniteur série et d'obtenir des commentaires sur l'état de la LED. Le fichier d'en-tête mentionné ci-dessus dépend des bibliothèques SPL, assurez-vous donc d'avoir suivi le didacticiel de mise en route.

Broches de communication série sur STM8S103F3P6

Commençons par le côté matériel. En jetant un coup d'œil aux brochages du microcontrôleur STM8S103F3P6 ci-dessous, nous pouvons voir que les broches 1, 2 et 3 seront utilisées pour la communication UART.

Parmi les trois, la broche 1 est la broche d'horloge UART qui ne sera utilisée que pendant la communication UART synchrone, nous n'en aurons donc pas besoin ici. La broche 2 est la broche de l'émetteur UART et la broche 3 est la broche du récepteur UART. Notez que ces broches peuvent également servir de broche analogique ou de broche GPIO normale.

Schéma de circuit pour la communication série STM8S

Le schéma de circuit est très simple ici, nous devons connecter notre ST-LINK 2 pour la programmation et un convertisseur USB vers TTL pour la lecture des données série. Notez que notre contrôleur STM8S fonctionne au niveau logique 3,3 V, alors assurez-vous que votre convertisseur USB vers TTL prend également en charge la logique 3,3 V. Le schéma de circuit complet est illustré ci-dessous.

Vous devez connecter votre ST-link dans un port USB et un convertisseur USB vers TTL dans un autre port USB de votre ordinateur portable, afin de pouvoir à la fois programmer et surveiller les données en même temps. La connexion UART est simple, il suffit de connecter la terre et la broche Rx / Tx de votre microcontrôleur STM8S aux broches Tx / Rx du convertisseur USB vers TTL. Ici, j'ai alimenté le contrôleur avec la broche Vcc de ST-Link et j'ai laissé la broche vss du convertisseur TTL ouverte, vous pouvez également le faire dans l'autre sens. Il existe de nombreux types de convertisseur USB vers TTL sur le marché, assurez-vous simplement qu'il peut fonctionner sur des signaux logiques 3,3 V et recherchez simplement les broches Tx, Rx et GND et effectuez la connexion indiquée ci-dessus. Ma configuration matérielle est illustrée ci-dessous.

Pour créer un moyen de communication série, nous avons fourni le fichier d'en-tête STM8S_Serial.h . En utilisant ce fichier d'en-tête, vous pouvez exécuter des fonctions simples comme Arduino pour la communication série.

Vous pouvez trouver tous les fichiers requis pour ce projet sur notre page STM8S103F3_SPL Github. Si vous n'avez besoin que de ce fichier d'en-tête particulier, vous pouvez le télécharger à partir du lien ci-dessous.

Télécharger STM8S_Serial.h

Configuration de STVD pour la communication série

Pour travailler avec la communication série, nous en utiliserons beaucoup en utilisant la fonction de fichier d'en-tête STM8S_Serial.h dont nous avons discuté précédemment. Mais la bibliothèque a d'autres dépendances, de nombreux fichiers d'en-tête et C liés à SPL UART et Clock. Donc à partir de ce point, il est préférable d'inclure tous les fichiers d'en-tête et C dans notre projet pour éviter une erreur de compilation. Mon environnement de travail STVD ressemble à ceci.

Assurez-vous d'avoir inclus tous les fichiers source SPL et inclure le fichier comme nous l'avons fait dans notre premier tutoriel. Et assurez-vous également d'avoir ajouté le fichier d'en-tête stm8s103_serial.h . Il n'y a pas de fichier C pour cet en-tête.

Programmation du STM8S pour la communication série

Une fois la configuration du projet STVD prête, nous pouvons commencer à écrire notre code dans le fichier main.c. Le code complet de ce didacticiel se trouve au bas de cette page. L'explication est la suivante.

La première étape consiste à inclure les fichiers d'en-tête requis, ici j'ai ajouté le fichier d'en-tête principal (stm8s) et le fichier d'en-tête stm8s_103_serial que nous venons de télécharger.

// En-têtes obligatoires #include "STM8S.h" #include "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3_SPL/blob/master/stm8s103%20Libraries/stm8s103_Serial.h

Ensuite, nous utilisons les macros de conception pour spécifier les broches d'entrée et de sortie. Ici ne contrôlera que la LED embarquée qui est connectée à la pin5 du port B, nous lui donnons donc un nom comme test_LED .

#define test_LED GPIOB, GPIO_PIN_5 // La LED de test est connectée au PB5

En passant à l'intérieur de la fonction principale, nous définirons la broche comme une sortie. Si vous n'êtes pas familiarisé avec les fonctions GPIO de base, revenez au didacticiel GPIO STM8S.

// Défanitions des broches // Déclarer PB5 comme push pull Broche de sortie GPIO_Init (test_LED, GPIO_MODE_OUT_PP_LOW_SLOW);

Ensuite, nous initialisons nos ports de communication série à 9600 bauds. Pour ceux qui sont nouveaux, 9600 est la vitesse à laquelle les bits de données seront transférés pendant la communication. Si vous définissez 9600 ici, vous devez également définir la même chose sur le logiciel de surveillance. Ensuite, nous imprimons également une chaîne «Entrez la commande» et passons à la ligne suivante.

Serial_begin (9600); // Initialise la communication série à un débit de 9600 bauds Serial_print_string ("Enter command"); // affiche une chaîne Serial_newline (); // passe à la ligne suivante

Passant à la boucle while infinie, nous utilisons la fonction Serial_available pour vérifier s'il y a des données série entrantes. Si oui, nous la lisons et la sauvegardons dans une variable appelée ch et l'imprimons également en utilisant Serial_print . Ensuite, si la valeur reçue est 0, nous éteindrons la LED et si elle est 1, nous allumerons la LED

if (Serial_available ()) {Serial_print_string ("Vous avez appuyé sur:"); ch = Serial_read_char (); Serial_print_char (ch); Serial_newline (); if (ch == '0') GPIO_WriteHigh (test_LED); // LED éteinte si (ch == '1') GPIO_WriteLow (test_LED); //CONDUIT SUR }

Avec cela, la programmation de ce tutoriel est terminée, il vous suffit de télécharger le code donné en bas de cette page et vous devriez pouvoir contrôler la LED depuis le moniteur série.

Contrôle de la LED à partir du moniteur série

Une fois que vous avez téléchargé le code, vous pouvez ouvrir n'importe quel moniteur série à des débits de 9600 bauds. J'ai utilisé le moniteur série Arduino lui-même pour la facilité d'utilisation. Appuyez sur le bouton de réinitialisation et vous devriez voir le message «Entrez une commande». Ensuite, si vous entrez 1 et appuyez sur Entrée, la LED intégrée doit s'allumer, de même pour 0, elle doit s'éteindre.

Le travail complet peut être trouvé dans la vidéo liée au bas de cette page. Si vous avez des questions, veuillez les laisser dans la section commentaires. Vous pouvez également utiliser nos forums pour publier d'autres questions techniques.

Présentation approfondie de la bibliothèque série STM8S

Pour les esprits curieux qui veulent savoir ce qui se passe réellement dans le fichier d'en-tête STM8S103F3_Serial lisez la suite….

Ce fichier d'en-tête fonctionne bien pour la programmation de niveau débutant, mais si vous utilisez une version différente du contrôleur STM8S ou recherchez des options avancées, vous voudrez peut-être modifier un peu cet en-tête ou travailler directement avec les bibliothèques SPL. J'ai écrit ce fichier d'en-tête juste comme un mûr du fichier d'en-tête UART1, l'explication de mon fichier d'en-tête est la suivante.

Lire un personnage depuis Serial Monitor

Cette fonction permet de lire un seul caractère qui a été envoyé au microcontrôleur à partir du moniteur série.

char Serial_read_char (void) {while (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); return (UART1_ReceiveData8 ()); }

Nous attendons que le drapeau RXE soit réglé pour terminer la réception, puis effacez le drapeau pour accuser réception de la réception. Enfin, nous envoyons les données 8 bits reçues à la suite de cette fonction.

Impression d'un caractère sur Serial Monitor

Cette fonction transmet un seul caractère d'un microcontrôleur au moniteur série.

void Serial_print_char (valeur de caractère) {UART1_SendData8 (valeur); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // attendre l'envoi}

La fonction écrit simplement la valeur 8 bits et attend que la transmission soit terminée en vérifiant le UART1_FLAG_TXE à SET

Initialisation de la communication série

Cette fonction initialise la communication série à la vitesse de transmission requise.

void Serial_begin (uint32_t baud_rate) {GPIO_Init (GPIOD, GPIO_PIN_5, GPIO_MODE_OUT_PP_HIGH_FAST); GPIO_Init (GPIOD, GPIO_PIN_6, GPIO_MODE_IN_PU_NO_IT); UART1_DeInit (); // Désinitialiser les périphériques UART UART1_Init (baud_rate, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO, UART1_SYNCMODE_CLOCK_DISABLE, UART1_MODE_TXRX_ENABLE); // (BaudRate, Wordlegth, StopBits, Parity, SyncMode, Mode) UART1_Cmd (ENABLE); }

Outre le débit en bauds, il existe d'autres paramètres qui doivent être définis pour la communication série, comme le nombre de bits de données, le nombre de bits d'arrêt, la parité, etc. Le plus courant (similaire à Arduino) est les données 8 bits avec un bit d'arrêt et aucune parité et donc ce sera le paramètre par défaut. Vous pouvez le modifier si nécessaire.

Impression d'un entier sur le moniteur série

La plupart du temps, si nous utilisons un moniteur série pour le débogage ou la surveillance, nous pourrions vouloir imprimer une variable de type int sur le moniteur série. Cette fonction fait exactement cela

void Serial_print_int (int number) // Fonction pour imprimer la valeur int sur le moniteur série {char count = 0; caractère de caractère = ""; while (number! = 0) // divise le tableau int en char array {digit = number% 10; count ++; nombre = nombre / 10; } while (count! = 0) // affiche le tableau de caractères dans la bonne direction {UART1_SendData8 (digit + 0x30); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // attendre l'envoi de count--; }}

Il prend une valeur entière et le convertit en tableau de caractères dans la première boucle while, puis dans la seconde boucle while, nous enverrons chacun des caractères similaires à notre fonction print char.

Impression d'une nouvelle ligne

C'est une fonction simple pour imprimer une nouvelle ligne. La valeur hexadécimale pour ce faire est «0x0a», nous l'envoyons simplement via la commande de transmission 8 bits.

void Serial_newline (void) {UART1_SendData8 (0x0a); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // attendre l'envoi}

Impression d'une chaîne sur un moniteur série

Une autre fonction utile consiste à imprimer des chaînes sur le moniteur série.

void Serial_print_string (chaîne de caractères) {. char i = 0; while (chaîne! = 0x00) {UART1_SendData8 (chaîne); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); i ++; }}

Encore une fois, cette fonction convertit également la chaîne en tableau de caractères et envoie chaque caractère. Comme nous le savons, toutes les chaînes de fin seront nulles. Nous devons donc continuer à parcourir et à transmettre les caractères jusqu'à ce que nous atteignions le zéro 0x00.

Vérifier si les données série sont disponibles pour la lecture

Cette fonction vérifie si des données série dans le tampon sont prêtes à être lues.

booléen Serial_available () {if (UART1_GetFlagStatus (UART1_FLAG_RXNE) == TRUE) renvoie TRUE; sinon retourne FALSE; }

Il vérifie l'indicateur UART1_FLAG_RXNE , s'il est vrai, il renvoie vrai et si ce n'est pas le cas, il renvoie faux.