Manuel d'utilisation de la note d'application HOLTEK HT32 MCU UART

Introduction

Le récepteur/émetteur asynchrone universel - UART est une interface de transmission série largement utilisée qui fournit une transmission de données asynchrone flexible en duplex intégral. Le code d'application "Module_UART" fourni dans cette note d'application utilise des interruptions TX/RX avec des tampons en anneau logiciels pour implémenter des fonctions simples de transmission/réception UART via des API, dont les fonctions associées sont décrites ci-dessous. Cela simplifiera l'ensemble du processus de transmission de données et permettra aux utilisateurs de comprendre et de mettre en œuvre rapidement les applications de communication UART.

• Fonctions de transmission/réception : lecture d'octets, écriture d'octets, lecture de tampon, écriture de tampon, etc.
• Fonctions d'état : obtenir la longueur de la mémoire tampon, l'état TX, etc.

Ce document présentera d'abord le protocole de communication UART, qui aidera les utilisateurs à mieux comprendre la communication UART du principe à l'application. Ceci est suivi du téléchargement et de la préparation des ressources requises pour le code d'application, y compris la bibliothèque du micrologiciel, le téléchargement du code d'application, file et la configuration du répertoire ainsi qu'une introduction à l'outil logiciel du terminal utilisé dans la note d'application. Dans le chapitre Description fonctionnelle, la structure du répertoire du code d'application, les réglages des paramètres et la description de l'API seront présentés. L'utilisation de l'API sera décrite à l'aide du code d'application "Module_UART" et la consommation de ressources Flash/RAM requise pour les API sera également répertoriée. Le chapitre Instructions d'utilisation guidera l'utilisateur à travers les étapes de préparation de l'environnement, de compilation et de test pour confirmer que le code d'application fonctionnera correctement. Il fournira ensuite des instructions expliquant comment intégrer les API dans les projets de l'utilisateur et fournira enfin une référence pour les modifications et les problèmes courants pouvant être rencontrés.

Abréviations utilisées : 

• UART: Récepteur/émetteur asynchrone universel
• API: Interface de programmation d'application
• LSB : Bit le moins significatif
• MSB : Bit le plus significatif
• PC: Ordinateur personnel
• SK: Kit de démarrage, carte de développement HT32
• IDE: Environnement de développement intégré

Protocole de communication UART

L'UART est un type d'interface de communication série qui implémente la conversion de données parallèle-série au niveau de son émetteur, puis communique en série avec un récepteur similaire. Le récepteur effectue ensuite une conversion de données série-parallèle après la réception des données. La figure 1 montre un diagramme schématique d'une communication série montrant comment les données sont transférées dans un ordre binaire. Par conséquent, pour une communication bidirectionnelle entre l'émetteur et le récepteur, seuls deux fils, TX et RX, sont nécessaires pour transférer les données en série entre eux. TX est la broche sur laquelle l'UART transmet les données série et est connectée à la broche RX du récepteur. Par conséquent, les appareils émetteur et récepteur doivent interconnecter leurs broches TX et RX pour effectuer une communication bidirectionnelle UART, comme indiqué dans Chiffre 2.

Figure 1. Schéma de communication série

Figure 2. Schéma de circuit UART

Pendant la communication série UART, la transmission de données est asynchrone. Cela signifie qu'il n'y a pas d'horloge ou autre signal de synchronisation entre l'émetteur et le récepteur. Ici, un débit en bauds est utilisé, qui est la vitesse de transmission/réception de données série et qui est défini par les deux côtés avant les transferts de données. De plus, des bits spéciaux tels que des bits de démarrage et d'arrêt sont ajoutés au début et à la fin du paquet de données pour former un paquet de données UART complet. La figure 3 montre la structure du paquet de données UART tandis que la figure 4 montre un paquet de données UART 8 bits sans bit de parité.
Figure 3. Structure des paquets de données UART

Figure 4. Format de paquet de données UART 8 bits

Chaque partie du paquet de données UART est présentée dans l'ordre ci-dessous.

• Bit de départ : Ceci indique le début d'un paquet de données. La broche UART TX reste généralement à un niveau logique élevé avant le début de la transmission. Si la transmission de données commence, l'émetteur UART tirera la broche TX de haut en bas, c'est-à-dire de 1 à 0, puis la maintiendra là pendant un cycle d'horloge. Le récepteur UART commencera à lire les données lorsqu'une transition haut vers bas a été détectée sur la broche RX.
• Données: Il s'agit des données réelles transférées, avec une longueur de données de 7, 8 ou 9 bits. Les données sont généralement transférées avec le LSB en premier.
• Bit de parité : Le nombre de « 1 » logiques dans les données est utilisé pour déterminer si des données ont changé pendant la transmission. Pour une parité paire, le nombre total de "1" logiques dans les données doit être un nombre pair, inversement, le nombre total de "1" logiques dans les données doit être un nombre impair pour une parité impaire.
• Bit d'arrêt : Cela indique la fin d'un paquet de données, où l'émetteur UART tire la broche TX de bas en haut, c'est-à-dire de 0 à 1, puis la maintient pendant une période de temps de 1 ou 2 bits.

Comme mentionné précédemment, puisqu'il n'y a pas de signal d'horloge dans le circuit UART, la même vitesse de transmission/réception de données série, appelée débit en bauds, doit être définie entre l'émetteur et le récepteur pour mettre en œuvre une transmission sans erreur. Le débit en bauds est défini par le nombre de bits transférés par seconde, en bps (bit par seconde). Certains débits en bauds standard et couramment utilisés sont 4800bps, 9600bps, 19200bps, 115200bps, etc. Le temps correspondant requis pour transférer un seul bit de données est indiqué ci-dessous.
Tableau 1. Débit en bauds par rapport au temps de transmission 1 bit 

Débit en bauds	Transmission 1 bit Temps
4800 bps	208.33 µs
9600 bps	104.16 µs
19200 bps	52.08 µs
115200 bps	8.68 µs

Téléchargement et préparation des ressources

Ce chapitre présentera le code de l'application et l'outil logiciel utilisé, ainsi que la configuration de l'annuaire et file chemin.

Bibliothèque de micrologiciels 

Tout d'abord, assurez-vous que la bibliothèque du micrologiciel Holtek HT32 a été téléchargée avant d'utiliser le code d'application. Le lien de téléchargement est indiqué ci-dessous. Ici, il y a deux options, HT32_M0p_Vyyyymmdd.zip pour la série HT32F5xxxx et HT32_M3_Vyyyymmdd.zip pour la série HT32F1xxxx. Téléchargez et décompressez le fichier souhaité file.

La fermeture éclair file contient plusieurs dossiers qui peuvent être classés en tant que document, bibliothèque de micrologiciels, outils et autres éléments, dont le chemin de placement est illustré à la figure 5. Le zip de la bibliothèque de micrologiciels HT32 file avec un file nom de HT32_STD_xxxxx_FWLib_Vm.n.r_s.zip se trouve sous le dossier Firmware_Library.

Figure 5. Contenu de HT32_M0p_Vyyyymmdd.zip

Code d'application
Téléchargez le code d'application à partir du lien suivant. Le code de l'application est emballé dans un zip file avec un file nom de HT32_APPFW_xxxxx_APPCODENAME_Vm.n.r_s.zip. Voir Figure 6 pour le file convention de nom.

Illustration 6. Code d'application File Présentation du nom 

Lien de téléchargement : https://mcu.holtek.com.tw/ht32/app.fw/Module_UART/

File et configuration du répertoire
Comme le code d'application ne contient pas la bibliothèque du firmware HT32 files, le code d'application et la bibliothèque de firmware décompressés files doivent être placés dans le bon chemin avant de commencer la compilation. Le code postal de l'application file contient généralement un ou plusieurs dossiers, tels que l'application et la bibliothèque, comme illustré à la Figure 7. Placez le dossier de l'application sous le répertoire racine de la bibliothèque du micrologiciel HT32 pour terminer la file configuration du chemin d'accès, comme illustré à la Figure 8. Vous pouvez également décompresser le code d'application et la bibliothèque du micrologiciel HT32 simultanément dans le même chemin pour obtenir les mêmes résultats de configuration.

Figure 7. Contenu de HT32_APPFW_xxxxx_APPCODENAME_Vm.n.r_s.zip

Figure 8. Chemin de décompression

Logiciel de terminal
Le code d'application peut transférer des messages via le port COM pour implémenter la sélection de fonction ou l'affichage d'état. Cela nécessite que le côté hôte ait installé le logiciel du terminal à l'avance. Les utilisateurs peuvent choisir le logiciel de connexion approprié ou utiliser un logiciel sous licence gratuit tel que Tera Term. Dans le code d'application, le canal UART est configuré avec une longueur de mot de 8 bits, sans parité, 1 bit d'arrêt et un débit en bauds de 115200 XNUMX bps.

Description fonctionnelle

Ce chapitre fournira une description fonctionnelle du code d'application, y compris des informations sur la structure du répertoire, l'architecture de l'API, la description des paramètres, etc.

Structure du répertoire
Le code d'application file contient un dossier d'application. La couche suivante est le dossier "Module_UART" qui contient deux programmes d'application, "UART_Module_Example » et « UART_Bridge ». Le pertinent files sont répertoriés et décrits ci-dessous.
Tableau 2. Structure du répertoire des codes d'application

Dossier / File Nom	Description
\\application\Module_UART\UART_Module_Example*1
_Créer un projet.bat	Scripts batch pour créer un projet files
_ProjectSource.ini	Initialisation file pour ajouter du code source aux projets
ht32_board_config.h	Installation file lié à l'affectation d'E / S de périphérique IC
ht32fxxxx_01_it.c	Programme de service d'interruption file
principal c	Code source du programme principal
\\application\Module_UART\UART_Bridge*2
_Créer un projet.bat	Scripts batch pour créer un projet files
_ProjectSource.ini	Initialisation file pour ajouter du code source aux projets
ht32_board_config.h	Installation file lié à l'affectation d'E / S de périphérique IC
ht32fxxxx_01_it.c	Programme de service d'interruption file
principal c	Code source du programme principal
uart_bridge.h uart_bridge.c	Tête de pont UART file et le code source file
\\utilitaires\middleware
uart_module.h*3 uart_module.c*3	En-tête d'API file et le code source file
\\utilitaires\commun
ringbuffer.h ring_buffer.c	En-tête de mémoire tampon en anneau logiciel file et le code source file

Note: 

1. Dans le "UART_Module_Example" code d'application, les opérations de lecture et d'écriture de l'API sont effectuées en boucle, reportez-vous à la section "API Usage Examples » pour plus de détails.
2.  Dans le code d'application "UART_Bridge", deux canaux UART, UART CH0 et UART CH1, sont activés, et un protocole de communication personnalisé via les structures COMMAND est mis en œuvre entre les deux dispositifs UART. Pour plus d'informations, reportez-vous à la section « API Usage Exampsection ".
3. Le code de l'application doit utiliser le uart_module.c/h files qui ont une exigence de version de bibliothèque de micrologiciel. L'exigence peut changer de temps en temps en fonction de la mise à jour. Pour confirmer la configuration requise pour la version actuelle de la bibliothèque du micrologiciel, reportez-vous au contenu de la vérification des dépendances en recherchant le mot-clé « Vérification des dépendances » dans main.c file. Si la version de la bibliothèque de micrologiciels ne répond pas aux exigences, téléchargez la version la plus récente à partir du lien fourni dans la section « Bibliothèque de micrologiciels ».

Architecture des API
Chaque API a un paramètre important CH, qui est le canal UART. Ceci détermine quel canal UART doit être contrôlé. Actuellement, jusqu'à quatre canaux UART sont pris en charge et, par conséquent, quatre symboles constants sont définis comme suit. Ceux-ci sont utilisés comme paramètre CH fournissant aux API la base du contrôle.

• UARTM_CH0 : paramètre d'entrée - contrôler ou configurer UART CH0
• UARTM_CH1 : paramètre d'entrée - contrôler ou configurer UART CH1
• UARTM_CH2 : paramètre d'entrée - contrôler ou configurer UART CH2
• UARTM_CH3 : paramètre d'entrée - contrôler ou configurer UART CH3

L'espace mémoire ne sera pas gaspillé si un seul canal UART est utilisé. En effet, le nombre de canaux UART pris en charge peut être défini et le code de canal UART inutilisé sera supprimé par le préprocesseur pour augmenter l'espace mémoire disponible. L'architecture de l'API est illustrée dans Figure 9.

Figure 9. Schéma fonctionnel de l'architecture de l'API

Chaque API est composée de quatre groupes de paramètres ou de commandes liés au canal UART afin que les utilisateurs n'aient qu'à saisir le paramètre CH souhaité. Pour configurer l'API pertinente, il suffit d'avoir une table de paramètres de configuration de base UART supplémentaire avec la forme de structure, USART_InitTypeDef. L'API implémentera la configuration de base UART en fonction du contenu des paramètres dans le tableau. Reportez-vous à la section « Description de l'API » pour le tableau de la structure de configuration de base de l'UART.

Le uart_module.c/.h files ne contiennent que l'interruption (CHx_IRQ) ​​et la table d'état (CHx Status) de chaque canal UART tandis que tous les paramètres requis pour la communication UART sont fournis par ht32_board_config.h. Les paramètres matériels pertinents dans ht32_board_config.h file sont indiqués dans le tableau ci-dessous. Plus de détails sont fournis dans la section "Description des paramètres".

Les paramètres matériels pertinents dans ht32_board_config.h incluent les paramètres d'E/S et les paramètres de port UART physique, comme suit.

Tableau 3. Symboles de définition dans ht32_board_config.h

Symbole	Description
HTCFG_UARTM_CH0	Nom du port UART physique ; Example : UART0, UART1…
HTCFG_UARTM0_TX_GPIO_PORT	Définit le nom du port de TX pour CH0 ; Example : A, B, C…
HTCFG_UARTM0_TX_GPIO_PIN	Définit le numéro de broche de TX pour CH0 ; Exampniveau : 0~15
HTCFG_UARTM0_RX_GPIO_PORT	Définit le nom du port de RX pour CH0 ; Example : A, B, C…
HTCFG_UARTM0_RX_GPIO_PIN	Définit le numéro de broche de TX pour CH0 ; Exampniveau : 0~15
HTCFG_UARTM0_TX_BUFFER_SIZE	Définit la taille du tampon TX pour CH0 ; Exampfichier: 128
HTCFG_UARTM0_RX_BUFFER_SIZE	Définit la taille du tampon RX pour CH0 ; Exampfichier: 128

Pour modifier la configuration AFIO du canal UART, reportez-vous à la fiche technique de l'appareil concerné. Actuellement, seules les définitions d'E/S pour UART CH0 prennent effet car seul UART CH0 a été configuré dans ht32_board_config.h. Pour ajouter UART CH1 ~ 3, leurs définitions d'E / S doivent être complétées en se référant à la définition UART CH0 ou en se référant à la section "Modification des paramètres et FAQ".

Il existe trois caractéristiques principales de l'architecture de l'API : 

1. Jusqu'à quatre canaux UART sont pris en charge. Leurs paramètres d'entrée sont UARTM_CH0, UARTM_CH1, UARTM_CH2 et UARTM_CH3.
2.  Le nombre de canaux UART peut être défini et les canaux inutilisés ne réduiront pas l'espace mémoire disponible.
3. Tous les paramètres UART et les définitions d'E/S sont complètement séparés des API. Cela augmente la commodité de gestion des valeurs de réglage et réduit la possibilité de paramètres incorrects ou manquants.

Description du paramètre 

Cette section présentera les réglages des paramètres dans ht32_board_config.h et uart_module.h files.

1. ht32_board_config.h : ceci file est utilisé pour les définitions de broches et les paramètres pertinents de la carte de développement, qui incluent le canal IP UART (UART0, UART1, USART0…) utilisé par le kit de démarrage (SK), les emplacements de broches TX/RX correspondants et la taille de la mémoire tampon TX/RX. La figure 10 montre le contenu des paramètres du kit de démarrage HT32F52352. Selon l'intégration fonctionnelle du développement, les utilisateurs peuvent se référer à la section "Affectation des broches" de la fiche technique de l'appareil utilisé pour implémenter les définitions des broches. Plus de détails sur la modification des paramètres seront décrits dans la section "Modification des paramètres et FAQ".
   Figure 10. Paramètres ht32_board_config.h (HT32F52352)
   
2. uart_module.h : Ceci est l'en-tête de l'API file utilisé par le code d'application, qui inclut les paramètres par défaut pertinents, les définitions de fonctions, etc. Comme le montre la figure 11, le contenu des paramètres par défaut peut être remplacé par des configurations externes, telles que les paramètres dans ht32_board_config.h file.
   Figure 11. Paramètres par défaut dans uart_module.h
   

Description de l'API

1. Description du type de données du code d'application.
   • USART_InitTypeDef
     Il s'agit de la structure de configuration de base UART qui est composée des configurations BaudRate, WordLength, StopBits, Parity et Mode, comme indiqué ci-dessous.

     Variable Nom	Taper	Description
     USART_BaudRate	u32	Débit en bauds de communication UART
     USART_WordLength	u16	Longueur du mot de communication UART : 7, 8 ou 9 bits
     USART_StopBits	u16	Longueur du bit d'arrêt de la communication UART : 1 ou 2 bits
     USART_Parité	u16	Parité de communication UART : paire, impaire, marque, espace ou pas de parité
     Mode_USART	u16	Mode de communication UART ; les API ne prennent en charge que le mode normal

2. Avant d'utiliser les fonctions API, terminez la configuration de base UART dans le programme principal. La configuration de base UART pour ce code d'application est illustrée à la Figure 12. Ici, le débit en bauds est de 115200 8 bps, la longueur du mot est de 1 bits, la longueur du bit d'arrêt est de XNUMX bit et il n'y a pas de parité.
   Figure 12. Configuration de base UART
   
3. La figure 13 montre les fonctions API déclarées dans uart_module.h file. Les tableaux suivants expliquent la fonction, les paramètres d'entrée et l'utilisation des fonctions API.
   Figure 13. Déclarations de fonction API dans uart_module.h 
   

Nom	annuler UARTM_Init(u32 CH, USART_InitTypeDef *pUART_Init, u32 uRxTimeOutValue)
Fonction	Initialisation du module UART
Saisir	CH	Canal UART
	pUART_Init	Pointeur de structure de configuration de base UART
	uRxTimeOutValue	Valeur de temporisation UART RX FIFO. Lorsque le RX FIFO reçoit de nouvelles données, le compteur se réinitialise et redémarre. Une fois que le compteur atteint la valeur de temporisation prédéfinie et que l'interruption de temporisation correspondante a été activée, une interruption de temporisation sera générée.
Usage	UARTM_Init(UARTM_CH0, &USART_InitStructure, 40);//Exécutez la configuration de base UART//Reportez-vous à la Figure 12 pour la configuration USART_InitStructure

Nom	u32 UARTM_WriteByte (u32 CH, u8 uData)
Fonction	Opération d'écriture d'octet de module UART (TX)
Saisir	CH	Canal UART
	uDonnées	Les données à écrire
Sortir	SUCCÈS	Réussi
	ERREUR	Échoué
Usage	UARTM_WriteByte(UARTM_CH0, 'A'); // UART écrit 1 octet - 'A'

Nom	u32 UARTM_Write(u32 CH, u8 *pBuffer, u32 uLongueur)
Fonction	Opération d'écriture du module UART (TX)
Saisir	CH	Canal UART
	pTampon	Pointeur de tampon
	uLongueur	La longueur des données à écrire
Sortir	SUCCÈS	Réussi
	ERREUR	Échoué
Usage	u8 Test[] = "C'est un test !\r\n" ; UARTM_Write(UARTM_CH0, Test, sizeof(Test) -1); // UART écrit les données pBuffer

Nom	u32 UARTM_ReadByte (u32 CH, u8 *pData)
Fonction	Opération d'octet de lecture du module UART (RX)
Saisir	CH	Canal UART
	pDonnées	L'adresse où placer les données lues
Sortir	SUCCÈS	Réussi
	ERREUR	Échec (pas de données)
Usage	u8 TempData ; if (UARTM_ReadByte(UARTM_CH0, &TempData) == SUCCESS){UARTM_WriteByte(UARTM_CH0, TempData);}//If UARTM_ReadByte() renvoie SUCCESS alors UART écrit cet octet de données

Nom	u32 UARTM_Read(u32 CH, u8 *pBuffer, u32 uLongueur)
Fonction	Opération de lecture du module UART (RX)
Saisir	CH	Canal UART
	pTampon	Pointeur de tampon
	uLongueur	La longueur des données à lire
Sortir	Nombre de lectures	La longueur des données a été lue
Usage	u8 Test2[10] ; u32 Len; Len = UARTM_Read(UARTM_CH0, Test2, 5);if (Len > 0){UARTM_Write(UARTM_CH0, Test2, Len);}//UARTM_Read() lit 5 octets de données et stocke les données dans Test2, et attribue le nombre d'octets lus à Len//Ecrire les données provenant de Test2

Nom	u32 UARTM_GetReadBufferLength(u32 CH)
Fonction	Obtenir la longueur du tampon de lecture (RX)
Saisir	CH	Canal UART
Sortir	uLongueur	Lire la longueur du tampon
Usage	UARTM_Init(UARTM_CH0, &USART_InitStructure, 40); //Initialisation du module UART while (UARTM_GetReadBufferLength(UARTM_CH0) < 5);//Attendre que UARTM_ReadBuffer ait reçu 5 octets de données

Nom	u32 UARTM_GetWriteBufferLength(u32 CH)
Fonction	Obtenir la longueur du tampon d'écriture (TX)
Saisir	CH	Canal UART
Sortir	uLongueur	Longueur du tampon d'écriture

Nom	u8 UARTM_IsTxFinished(u32 CH)
Fonction	Obtenir le statut TX
Saisir	CH	Canal UART
Sortir	VRAI	Statut TX : terminé
	FAUX	Statut TX : non terminé
Usage	UARTM_WriteByte(UARTM_CH0, 'O'); #if 1 // "uart_module.c" SVN >= 525 requiredwhile (UARTM_IsTxFinished(UARTM_CH0) == FALSE) #elsewhile (1) #endif //Cette API peut être utilisée pour vérifier l'état TX, comme indiqué ci-dessus ; attendez que l'API UARTM_WriteByte() soit terminée, c'est-à-dire que le statut TX est TRUE, puis continuez les actions suivantes.//Une restriction est ajoutée car cette fonction n'a pas été ajoutée tant que le numéro de version SVN dans uart_module.c est 525.

Nom	vide UARTM_DiscardReadBuffer(u32 CH)
Fonction	Supprimer les données dans le tampon de lecture
Saisir	CH	Canal UART

Exemple d'utilisation de l'APIamples 

Cette section démontrera l'écriture et la lecture de l'API exampfichiers du code d'application "Module_UART" en utilisant le processus d'initialisation et le "UART_Module_Example » processus de code d'application. Avant d'utiliser les API, les utilisateurs doivent inclure l'en-tête de l'API file dans le code source du programme principal file (#include "middleware/uart_module.h").

Comme le montre la Figure 14, lorsque vous entrez dans le processus d'initialisation, définissez d'abord la structure de configuration de base de l'UART. Configurez ensuite les membres de la structure de configuration de base UART, y compris BaudRate, WordLength, StopBits, Parity et Mode. Enfin, appelez la fonction d'initialisation de l'API, dont l'achèvement indique la fin du processus d'initialisation. Après cela, les utilisateurs peuvent continuer les opérations d'écriture et de lecture en fonction de la configuration de base UART prédéfinie.

Figure 14. Organigramme d'initialisation

Le "UART_Module_Example" le code d'application illustre les opérations de lecture et d'écriture de l'API en boucle. L'organigramme correspondant est illustré à la Figure 15. Les fonctions API utilisées incluent UARTM_WriteByte(), UARTM_Write(), UARTM_ReadByte(), UARTM_Read() et UARTM_GetReadBufferLength(). Leur description est fournie dans la section "Description de l'API".

Figure 15. Organigramme de Write et Read Examples

Il existe un autre code d'application "UART_Bridge" sous le dossier "Module_UART" dont file description est introduite dans la section « Structure des répertoires ». Le code d'application "UART_Bridge" active deux canaux UART, UART CH0 et UART CH1, puis personnalise le protocole de communication entre les deux dispositifs UART via les structures COMMAND, gCMD1 et gCMD2. Ceux-ci sont définis dans uart_bridge.c, comme indiqué ci-dessous. UARTBridge_CMD1TypeDef gCMD1 :

Variable Nom	Taper	Description
uEn-tête	u8	En-tête
uCmd	u8	Commande
uDonnées[3]	u8	Données

UARTBridge_CMD2TypeDef gCMD2 :

Variable Nom	Taper	Description
uEn-tête	u8	En-tête
uCmdA	u8	Commande A
uCmdB	u8	Commande B
uDonnées[3]	u8	Données

Dans le code d'application "UART_Bridge", utilisez gCMD1 pour recevoir des données sous forme de paquet de commande, puis analysez-les. Ensuite, selon le protocole de communication personnalisé, définissez gCMD2 comme paquet de réponse et transmettez-le. Ce qui suit est un example d'un paquet de commande gCMD1) et d'un paquet de réponse (gCMD2). Paquet de commande (UARTBridge_CMD1TypeDef gCMD1) :

Octet 0	Octet 1	Octet 2 ~ Octet 4
uEn-tête	uCmd	uDonnées [3]
"UN"	« 1 »	"x, y, z"

Paquet de réponse (UARTBridge_CMD2TypeDef gCMD2) :

Octet 0	Octet 1	Octet 2	Octet 3 ~ Octet 5
uEn-tête	uCmdA	uCmdB	uDonnées [3]
« B »	"un"	« 1 »	"x, y, z"

Occupation des ressources
Prendre le HT32F52352 comme example, les ressources occupées par le module UART sont indiquées ci-dessous.

	HT32F52352
Taille de la ROM	946 octets
Taille de la RAM	40*1 + 256*2 Octets

Note:

1. Les variables globales, y compris les drapeaux et l'état d'un seul canal, occupent 40 octets de RAM.
2.  Il s'agit d'une condition où un seul canal est utilisé et la taille du tampon TX/RX est de 128/128 octets. La taille de la mémoire tampon peut être définie en fonction des exigences de l'application.

Tableau 4. Code d'application Ressource Occupation 

• Environnement de compilation : MDK-Arm V5.36, ARMCC V5.06 mise à jour 7 (build 960)
• Option d'optimisation : Niveau 2 (-O2)

Mode d'emploi

Ce chapitre présentera la préparation de l'environnement pour le code de l'application "Module_UART", ainsi que les étapes de compilation et de test.

Préparation environnementale
Le matériel et les logiciels requis pour le code d'application "Module_UART" sont répertoriés ci-dessous.
Tableau 5. Préparation de l'environnement matériel/logiciel 

Matériel/Logiciel	Compter	Note
Kit de démarrage	1	Cette note d'application utilise le kit de démarrage HT32F52352 comme example
Câble USB	1	Micro USB, connecté au PC
Code d'application	—	Le chemin de téléchargement, file et la configuration du répertoire sont présentées dans la section "Téléchargement et préparation des ressources". Chemin : "\\application\Module_UART\UART_Module_Examples"
Terme Tera	—	Reportez-vous à la section « Logiciel du terminal »
KeilIDE	—	Keil uVision V5.xx

Tout d'abord, utilisez le kit de démarrage HT32F52352 combiné à la fonction de port COM virtuel (VCP) d'e-Link32 Lite pour l'introduction de l'application UART. Cela nécessite la mise en œuvre de la préparation environnementale suivante :

1. Il y a deux interfaces USB sur la carte. Utilisez le câble USB pour connecter le PC et l'interface eLink32 Lite sur la carte, comme illustré à la Figure 16-(a).
2. Comme le code d'application doit utiliser la fonction de port COM virtuel (VCP) e-Link32 Lite, assurez-vous que le PAx*2 et le DAP_Tx de l'UART Jumper-J2*1 ont été court-circuités à l'aide d'un cavalier. L'emplacement J2 est indiqué par la Figure 16-(b).

Note

1. J2 sur le kit de démarrage a deux options, PAx et DAP_Tx court-circuités ou PAx et RS232_Tx court-circuités. Reportez-vous au manuel d'utilisation du kit de démarrage pour les fonctions de réglage détaillées.
2. L'emplacement de la broche MCU UART RX sur différents kits de démarrage est différent. Cet exampLe fichier utilise PAx pour indiquer la broche RX.

Figure 16. Schéma fonctionnel du kit de démarrage HT32

Utilisez maintenant la carte cible utilisateur combinée à la fonction Virtual COM Port (VCP) de l'e-Link32 Pro pour l'introduction de l'application UART. Cela nécessite la mise en œuvre de la préparation environnementale suivante :

1. Un côté de e-Link32 Pro est connecté à un PC à l'aide d'un câble mini USB et l'autre côté est connecté à la carte cible de l'utilisateur via son câble gris 10 bits. La connexion entre les interfaces SWD du câble et la carte cible est implémentée à l'aide de lignes Dupont, comme illustré à la Figure 17-(a).
2. Les broches de communication série de l'e-Link32 Pro sont la broche #7 VCOM_RXD et la broche #8-VCOM_TXD. Ceux-ci doivent être connectés aux broches TX et RX de la carte cible utilisateur, comme illustré à la Figure 17-(b).
   Figure 17. e-Link32 Pro + schéma fonctionnel de la carte cible utilisateur
   

Compilation et test
Cette section prendra le "application\Module_UART\UART_Module_Example" en tant qu'example pour introduire les processus de compilation et de test. Avant cela, assurez-vous que toutes les préparations décrites dans la section précédente ont été mises en œuvre et que le logiciel du terminal Tera Term a été téléchargé.

Les étapes de fonctionnement détaillées sont résumées ci-dessous.
Étape 1. Test de mise sous tension

Configurez l'environnement matériel comme décrit dans la section précédente. Après la mise sous tension, le voyant d'alimentation D9 en bas à gauche du kit de démarrage s'allume. Le voyant USB D1 sur l'e-Link32 Lite en haut à droite s'allume une fois l'énumération USB terminée. Si D1 ne s'allume pas après une longue période, vérifiez si le câble USB est capable de communiquer. Si ce n'est pas le cas, retirez-le et réinsérez-le à nouveau.

Étape 2. Générer un projet
Ouvrez l'application\Module_UART\UART_Module_Example dossier, cliquez sur le _CreateProject.bat file pour générer un projet, comme illustré à la Figure 18. Étant donné que cette note d'application utilise le kit de démarrage HT32F52352, ouvrez le projet Keil IDE "Project_52352.uvprojx" situé sous le dossier MDK_ARMv5.

Figure 18. Exécutez _CreateProject.bat pour générer le projet

Étape 3. Compiler et programmer
Une fois le projet ouvert, cliquez d'abord sur "Construire" (ou utilisez le raccourci "F7"), puis cliquez sur "Télécharger" (ou utilisez le raccourci "F8"). Après cela, les résultats de construction et de téléchargement seront affichés dans la fenêtre de sortie de construction. Voir Figure 19.

Figure 19. Générer et télécharger les résultats

Étape 4. Ouvrez le logiciel Tera Term et configurez le port série
Ouvrez le logiciel Tera Term et le port COM. Vérifiez si le numéro de port COM généré par le kit de démarrage est correct ou non. Cliquez ensuite sur "Configuration >> Port série" pour entrer dans l'interface de configuration. La configuration de l'interface UART du code d'application "Module_UART" est décrite dans la section "Logiciel du terminal". Le résultat de la configuration est illustré à la Figure 20.

Figure 20. Résultat de la configuration du port série Tera Term

Étape 5. Réinitialisez le système et testez
Appuyez sur la touche de réinitialisation SK – B1 Reset. Après cela, un "ABCThis is test!" le message sera
transmis via l'API et sera affiché dans la fenêtre Tera Term, comme illustré à la Figure 21. En ce qui concerne la fonction de réception, lors de la saisie de données dans la fenêtre Tera Term, l'API pertinente sera utilisée pour déterminer la longueur du tampon de réception. Lorsque les données reçues par le PC atteignent 5 octets, les 5 octets de données reçus seront envoyés séquentiellement. Comme le montre la Figure 22, les données saisies séquentiellement sont "1, 2, 3, 4, 5", qui sont reçues et déterminées via l'API. Après cela, les données "1, 2, 3, 4, 5" seront imprimées après les cinq entrées.

Figure 21. Test fonctionnel du code d'application "Module_UART" - Transmission

Figure 22. Test fonctionnel du code d'application "Module_UART" - Réception

Instructions de transplantation
Cette section présentera comment intégrer les API dans les projets de l'utilisateur.
Étape 1. Ajouter le uart_module.c file dans le projet. Faites un clic droit sur le dossier Utilisateur. Sélectionnez "Ajouter Files au groupe 'Utilisateur'… », puis sélectionnez le uart_module.c file et cliquez sur « Ajouter », comme illustré à la Figure 23. Reportez-vous à la section « Structure des répertoires » pour file descriptif du chemin.

Figure 23. Ajouter uart_module.c File projeter

Étape 2. Ajouter le ring_buffer.c file dans le projet. Faites un clic droit sur le dossier Utilisateur. Sélectionnez "Ajouter Files au groupe 'Utilisateur'… », puis sélectionnez le ring_buffer.c file et cliquez sur « Ajouter », comme illustré à la Figure 24.\ Reportez-vous à la section « Structure des répertoires » pour la file descriptif du chemin.
Figure 24. Ajouter ring_buffer.c File projeter 

Étape 3. Inclure l'en-tête de l'API file au début de main.c, comme illustré à la Figure 25. (Ext : #include "middleware/uart_module.h")
Figure 25. Inclure l'en-tête de l'API File à main.c

Étape 4. Implémentez les paramètres requis pour la communication UART à l'aide de ht32_board_config.h file. Ceci est présenté en détail dans les sections "Description des paramètres" et "Modification des paramètres et FAQ".

Modification des paramètres et FAQ 

Cette section présentera comment modifier les paramètres UART et expliquera certaines questions courantes rencontrées lors de l'utilisation.

Modifier l'affectation des broches UART 

1. En vous référant au chapitre « Affectation des broches » de la fiche technique HT32F52352, recherchez le tableau de mappage des fonctions alternatives qui répertorie les fonctions AFIO du type d'appareil. Pour les broches UART pertinentes, reportez-vous à la colonne "AF6 USART/UART", comme illustré à la Figure 26.
   Figure 26. Tableau de mappage des fonctions alternatives HT32F52352
   
   
2. Cette étape guidera les utilisateurs pour localiser les broches UART correspondantes à l'aide du tableau ci-dessus. Le HT32F52352 exampLe fichier utilise USART1 comme canal par défaut. Ici, les broches TX et RX sont USR1_TX et USR1_RX et sont situées respectivement sur PA4 et PA5. La Figure 27 montre la correspondance des broches ainsi que les définitions des broches dans « ht32_board_config.h ». Les champs vides de "Package" dans le tableau d'affectation des broches signifient qu'il n'y a pas de GPIO pertinent dans ce package. Pour modifier les broches UART, recherchez les emplacements des broches cibles et redéfinissez les broches à l'aide de "ht32_board_config.h". file.
   Figure 27. Correspondance des broches et modification des paramètres
   
   

Ajouter un canal UART
Prenant le HT32F52352 HTCFG_UARTM_CH1 comme example, il est décrit ici comment ajouter un nouveau canal UART.

Modifier le ht32_board_config.h file
En vous référant au chapitre « Affectation des broches » de la fiche technique HT32F52352, recherchez le tableau de mappage des fonctions alternatives qui répertorie les fonctions AFIO du type d'appareil. Comme USART1 a été utilisé comme HTCFG_UARTM_CH0, le HTCFG_UARTM_CH1 nouvellement ajouté peut choisir USART0. Ici, les broches TX et RX sont situées respectivement sur PA2 et PA3, comme illustré dans la moitié supérieure de la figure 28. Les modifications correspondantes sont implémentées à l'aide des lignes de code 120 à 126 dans ht32_board_config.h, comme indiqué par la case en pointillé rouge sur la figure. 28.

Figure 28. Ajouter un canal UART

FAQ
Q: À l'étape 5 de la section Compilation et test, le test fonctionnel de transmission est normal. Ici, le "ABCThis is test!" message a été affiché avec succès, mais pour la fonction de réception, pourquoi les cinq valeurs d'entrée ne sont-elles pas renvoyées et affichées ?
A: Vérifiez si les broches MCU UART RX et DAP_Tx de UART Jumper-J2 ont été court-circuitées à l'aide d'un cavalier. Comme le code d'application "Module_UART" doit utiliser le port COM virtuel (VCP) de e-Link32 Lite, le réglage de court-circuit doit être appliqué aux deux broches de gauche du cavalier UART-J2, comme illustré à la Figure 29.

Figure 29. Réglage du cavalier UART-J2

Q :Après exécutant "Build" (ou raccourci "F7"), un message d'erreur apparaît indiquant que la version de la bibliothèque du firmware est plus ancienne que celle requise ? Voir Figure 30.
A: L'implémentation du code d'application "Module_UART" doit inclure le uart_module.c/h files qui nécessite une certaine version de la bibliothèque de micrologiciels. Lorsqu'un tel message d'erreur apparaît, cela signifie que la bibliothèque de micrologiciels actuellement utilisée est une version plus ancienne. Il est donc nécessaire de télécharger la version la plus récente via le lien fourni dans la section « Bibliothèque de micrologiciels ».

Figure 30. Message d'erreur de version de la bibliothèque de micrologiciels

Conclusion

Ce document a fourni une introduction de base pour aider les utilisateurs à mieux comprendre le code d'application "Module_UART" et le protocole de communication UART. Cela a été suivi par le téléchargement et la préparation des ressources. Le chapitre Description fonctionnelle a présenté les file la structure du répertoire, l'architecture de l'API, la description de l'API et l'utilisation de l'API examples. Le chapitre Instructions d'utilisation a démontré la préparation de l'environnement, la compilation et le test du code d'application "Module_UART". Il a également fourni des instructions pour la transplantation de code et le réglage de la modification, ainsi qu'une explication de certains problèmes courants pouvant être rencontrés. Tout cela combiné permettra aux utilisateurs de comprendre rapidement comment utiliser les API et de réduire par la suite le temps de démarrage.

Documents de référence

Pour plus d'informations, reportez-vous au Holtek webSite : www.holtek.com

Versions et informations sur les modifications

Date	Auteur	Libérer	Informations sur les modifications
2022.04.30	蔡期育(Chi-Yu Tsai)	V1.00	Première version

Clause de non-responsabilité

Toutes les informations, marques, logos, graphiques, vidéos, clips audio, liens et autres éléments apparaissant sur ce web(« Informations ») sont fournies à titre indicatif uniquement et peuvent être modifiées à tout moment sans préavis et à la discrétion de Holtek Semiconductor Inc. et de ses sociétés affiliées (ci-après « Holtek », « la société », « nous », « nous' ou 'notre'). Bien que Holtek s'efforce d'assurer l'exactitude des informations sur ce website, aucune garantie expresse ou implicite n'est donnée par Holtek quant à l'exactitude des informations. Holtek décline toute responsabilité en cas d'erreur ou de fuite.
Holtek ne sera pas responsable des dommages (y compris, mais sans s'y limiter, les virus informatiques, les problèmes de système ou la perte de données) résultant de l'utilisation ou en relation avec l'utilisation de ce website par toute partie. Il peut y avoir des liens dans cette zone, qui vous permettent de visiter le websites d'autres sociétés.
Ces webles sites ne sont pas contrôlés par Holtek. Holtek n'assume aucune responsabilité et aucune garantie quant aux informations affichées sur ces sites. Des hyperliens vers d'autres websites sont à vos risques et périls.

Limitation de responsabilité

En aucun cas, Holtek Limited ne pourra être tenu responsable envers toute autre partie pour toute perte ou tout dommage, quel qu'il soit, causé directement ou indirectement en relation avec votre accès ou votre utilisation de ce website, son contenu ou tout bien, matériel ou service.

Loi applicable
La clause de non-responsabilité contenue dans le website est régi et interprété conformément aux lois de la République de Chine. Les utilisateurs se soumettront à la juridiction non exclusive des tribunaux de la République de Chine.

Mise à jour de la clause de non-responsabilité
Holtek se réserve le droit de mettre à jour la clause de non-responsabilité à tout moment avec ou sans préavis, toutes les modifications entrent en vigueur dès leur publication sur le website.

Documents / Ressources

Note d'application HOLTEK HT32 MCU UART [pdf] Manuel de l'utilisateur MCU HT32, Note d'application UART, HT32 MCU UART, Note d'application, HT32, Note d'application MCU UART, Note d'application HT32 MCU UART

Références

• Manuel d'utilisation