HOLTEK HT32 MCU UART Application Note Användarmanual

Introduktion

Den universella asynkrona mottagaren/sändaren – UART är ett brett använt seriellt överföringsgränssnitt som ger flexibel asynkron full-duplex dataöverföring. "Module_UART"-applikationskoden som tillhandahålls i denna applikationsnotis använder TX/RX-avbrott med mjukvaruringbuffertar för att implementera enkla UART-sändnings-/mottagningsfunktioner via API:er, vars relaterade funktioner beskrivs nedan. Detta kommer att förenkla hela dataöverföringsprocessen och tillåta användare att snabbt förstå och implementera UART-kommunikationsapplikationer.

• Sändnings-/mottagningsfunktioner: byteläsning, byteskrivning, buffertläsning, buffertskrivning, etc.
• Statusfunktioner: hämta buffertlängden, sändningsstatus, etc.

Detta dokument kommer först att introducera UART-kommunikationsprotokollet, som kommer att hjälpa användare att bättre förstå UART-kommunikationen från princip till applikation. Detta följs av nedladdning och förberedelse av de resurser som krävs för programkoden, inklusive firmwarebiblioteket, nedladdning av programkod, file och katalogkonfiguration samt en introduktion till terminalprogramvaran som används i applikationsanteckningen. I kapitlet Funktionsbeskrivning kommer applikationskodens katalogstruktur, parameterinställningar och API-beskrivning att introduceras. API-användningen kommer att beskrivas med hjälp av applikationskoden "Module_UART" och den Flash/RAM-resursförbrukning som krävs för API:erna kommer också att listas. Kapitlet Bruksanvisning vägleder användaren genom stegen för miljöförberedelse, sammanställning och test för att bekräfta att applikationskoden kommer att fungera korrekt. Den kommer sedan att ge instruktioner som förklarar hur man integrerar API:erna i användarens projekt och slutligen ger en referens för ändringar och vanliga problem som kan uppstå.

Använda förkortningar: 

• UART: Universal asynkron mottagare/sändare
• API: Applikationsprogrammeringsgränssnitt
• LSB: Minst betydande biten
• MSB: Mest betydelsefulla biten
• PC: Persondator
• SK: Startpaket, HT32 utvecklingskort
• ID: Integrerad utvecklingsmiljö

UART kommunikationsprotokoll

UART är en seriell kommunikationstyp av gränssnitt som implementerar parallell-till-seriell datakonvertering vid sin sändare och sedan kommunicerar seriellt med en liknande mottagare. Mottagaren utför sedan en seriell-till-parallell datakonvertering efter datamottagning. Figur 1 visar ett schematiskt diagram av seriell kommunikation som visar hur data överförs i bitvis ordning. För dubbelriktad kommunikation mellan sändare och mottagare krävs därför endast två ledningar, TX och RX, för att överföra data seriellt mellan varandra. TX är stiftet på vilket UART sänder seriella data och är ansluten till mottagarens RX-stift. Därför måste sändar- och mottagarenheterna korskoppla sina TX- och RX-stift för att utföra UART tvåvägskommunikation, som visas i Figur 2.

Figur 1. Seriell kommunikationsdiagram

Figur 2. UART-kretsdiagram

Under UART seriell kommunikation är dataöverföringen asynkron. Det betyder att det inte finns någon klocka eller annan synkroniseringssignal mellan sändaren och mottagaren. Här används en baudhastighet, som är den seriella dataöverförings-/mottagningshastigheten och som ställs in av båda sidor före dataöverföringar. Dessutom läggs speciella bitar som start- och stoppbitar till i början och slutet av datapaketet för att bilda ett komplett UART-datapaket. Figur 3 visar UART-datapaketstrukturen medan figur 4 visar ett UART 8-bitars datapaket utan paritetsbit.
Figur 3. UART-datapaketstruktur

Figur 4. UART 8-bitars datapaketformat

Varje del av UART-datapaketet introduceras i ordning nedan.

• Startbit: Detta indikerar starten på ett datapaket. UART TX-stiftet förblir vanligtvis på en hög logisk nivå innan överföringen startar. Om dataöverföringen startar kommer UART-sändaren att dra TX-stiftet från högt till lågt, dvs från 1 till 0, och sedan hålla det där under en klockcykel. UART-mottagaren kommer att börja läsa data när en hög till låg övergång har upptäckts på RX-stiftet.
• Data: Detta är den faktiska data som överförs, med en datalängd på 7, 8 eller 9 bitar. Data överförs vanligtvis med LSB först.
• Paritetsbit: Antalet logiska "1" i datan används för att avgöra om någon data har ändrats under överföringen. För jämn paritet bör det totala antalet logiska "1" i datan vara ett jämnt tal, omvänt bör det totala antalet logiska "1" i datan vara ett udda tal för udda paritet.
• Stop Bit: Detta indikerar slutet på ett datapaket, där UART-sändaren kommer att dra TX-stiftet från lågt till högt, dvs från 0 till 1, och sedan hålla det där under en 1 eller 2-bitars tidsperiod.

Som nämnts tidigare, eftersom det inte finns någon klocksignal i UART-kretsen, måste samma seriella datasändnings-/mottagningshastighet, som är känd som baudhastigheten, definieras mellan sändaren och mottagaren för att implementera felfri överföring. Baudhastigheten definieras av antalet bitar som överförs per sekund, i bps (bit per sekund). Vissa standard och vanligt använda baudhastigheter är 4800bps, 9600bps, 19200bps, 115200bps, etc. Motsvarande tid som krävs för att överföra en enskild databit visas nedan.
Tabell 1. Baud-hastighet vs. 1-bitars överföringstid 

Baudhastighet	1-bitars överföring Tid
4800 bps	208.33 µs
9600 bps	104.16 µs
19200 bps	52.08 µs
115200 bps	8.68 µs

Resursnedladdning och förberedelse

Det här kapitlet kommer att introducera applikationskoden och det programvaruverktyg som används, samt hur man konfigurerar katalogen och file väg.

Firmware bibliotek 

Se först till att Holtek HT32 firmware-biblioteket har laddats ner innan du använder applikationskoden. Nedladdningslänken visas nedan. Här finns två alternativ, HT32_M0p_Vyyyymmdd.zip för HT32F5xxxx-serien och HT32_M3_Vyyyymmdd.zip för HT32F1xxxx-serien. Ladda ner och packa upp önskad file.

Blixtlåset file innehåller flera mappar som kan klassificeras som dokument, firmwarebibliotek, verktyg och andra objekt, vars placeringsväg visas i figur 5. HT32 firmwarebibliotekets zip file med en file namnet på HT32_STD_xxxxx_FWLib_Vm.n.r_s.zip finns under mappen Firmware_Library.

Figur 5. HT32_M0p_Vyyyymmdd.zip Innehåll

Ansökningskod
Ladda ner applikationskoden från följande länk. Applikationskoden är förpackad i en zip file med en file namn på HT32_APPFW_xxxxx_APPCODENAME_Vm.n.r_s.zip. Ser Figur 6 för file namnkonventioner.

Figur 6. Applikationskod File Namn Introduktion 

Ladda ner länk: https://mcu.holtek.com.tw/ht32/app.fw/Module_UART/

File och Katalogkonfiguration
Eftersom applikationskoden inte innehåller HT32 firmware-biblioteket files, applikationskoden och firmwarebiblioteket packade upp files bör placeras på rätt väg innan kompileringen påbörjas. Applikationskoden zip file innehåller vanligtvis en eller flera mappar, såsom applikation och bibliotek, som visas i figur 7. Placera applikationsmappen under HT32 firmwarebibliotekets rotkatalog för att slutföra file sökvägskonfiguration, som visas i figur 8. Alternativt kan du packa upp programkoden och HT32-firmwarebiblioteket samtidigt i samma sökväg för att uppnå samma konfigurationsresultat.

Figur 7. HT32_APPFW_xxxxx_APPCODENAME_Vm.n.r_s.zip Innehåll

Figur 8. Dekompressionsväg

Terminalprogramvara
Applikationskoden kan överföra meddelanden via COM-porten för att implementera funktionsval eller statusvisning. Detta kräver att värdsidan har terminalprogramvaran installerad i förväg. Användare kan välja lämplig anslutningsprogramvara eller använda gratis licensierad programvara som Tera Term. I applikationskoden är UART-kanalen konfigurerad med en ordlängd på 8-bitar, ingen paritet, 1 stoppbit och en baudhastighet på 115200bps.

Funktionsbeskrivning

Det här kapitlet ger en funktionsbeskrivning för applikationskoden, inklusive information om katalogstrukturen, API-arkitektur, inställningsbeskrivning, etc.

Katalogstruktur
Ansökningskoden file innehåller en applikationsmapp. Nästa lager är mappen "Module_UART" som innehåller två applikationsprogram, "UART_Module_Example" och "UART_Bridge". Den relevanta files listas och beskrivs nedan.
Tabell 2. Programkodskatalogstruktur

Mapp / File Namn	Beskrivning
\\applikation\Module_UART\UART_Module_Example*1
_CreateProject.bat	Batchskript för att skapa projekt files
_ProjectSource.ini	Initiering file för att lägga till källkod till projekt
ht32_board_config.h	Inställning file relaterad till IC perifer I/O-tilldelning
ht32fxxxxx_01_it.c	Avbryt serviceprogram file
main.c	Huvudprogrammets källkod
\\applikation\Module_UART\UART_Bridge*2
_CreateProject.bat	Batchskript för att skapa projekt files
_ProjectSource.ini	Initiering file för att lägga till källkod till projekt
ht32_board_config.h	Inställning file relaterad till IC perifer I/O-tilldelning
ht32fxxxxx_01_it.c	Avbryt serviceprogram file
main.c	Källkoden för huvudprogrammet
uart_bridge.h uart_bridge.c	UART brohuvud file och källkod file
\\verktyg\mellanprogram
uart_module.h*3 uart_module.c*3	API-huvud file och källkod file
\\verktyg\vanligt
ringbuffer.h ring_buffer.c	Programvaruringbufferthuvud file och källkod file

Notera: 

1. I "UART_Module_Example” applikationskod, API:s läs- och skrivoperationer utförs på ett loopback-sätt, se “API Usage Examples" för mer information.
2.  I applikationskoden "UART_Bridge" aktiveras två UART-kanaler, UART CH0 och UART CH1, och anpassat kommunikationsprotokoll via COMMAND-strukturerna implementeras mellan de två UART-enheterna. För mer information, se "API Usage Examples” avsnitt.
3. Applikationskoden måste använda uart_module.c/h files som har ett krav på firmwarebiblioteksversion. Kravet kan ändras från tid till annan enligt uppdateringen. För att bekräfta det aktuella versionskravet för firmwarebiblioteket, se innehållet för beroendekontroll genom att söka efter nyckelordet "Dependency check" i main.c file. Om versionen av firmwarebiblioteket inte uppfyller kraven, ladda ner den senaste versionen från länken i avsnittet "Firmware Library".

API-arkitektur
Varje API har en viktig parameter CH, som är UART-kanalen. Detta bestämmer vilken UART-kanal som ska styras. För närvarande stöds upp till fyra UART-kanaler och därför definieras fyra konstanta symboler enligt följande. Dessa används som parametern CH som ger API:erna grunden för kontroll.

• UARTM_CH0: ingångsparameter – styr eller konfigurera UART CH0
• UARTM_CH1: ingångsparameter – styr eller konfigurera UART CH1
• UARTM_CH2: ingångsparameter – styr eller konfigurera UART CH2
• UARTM_CH3: ingångsparameter – styr eller konfigurera UART CH3

Minnesutrymme kommer inte att slösas bort om endast en UART-kanal används. Detta beror på att antalet UART-kanaler som stöds kan ställas in och den oanvända UART-kanalkoden kommer att tas bort av förprocessorn för att öka tillgängligt minnesutrymme. API-arkitekturen visas i Figur 9.

Figur 9. API-arkitekturblockdiagram

Varje API är sammansatt av fyra grupper av UART-kanalrelaterade inställningar eller kontroller så att användarna bara behöver mata in den önskade CH-parametern. För att konfigurera det relevanta API:et krävs det bara att ha en extra UART grundläggande konfigurationsparametertabell med strukturformuläret, USART_InitTypeDef. API:et kommer att implementera UART-baskonfigurationen enligt parameterinnehållet i tabellen. Se avsnittet "API-beskrivning" för tabellen över UARTs grundläggande konfigurationsstruktur.

Uart_module.c/.h files innehåller endast avbrott (CHx_IRQ) ​​och statustabell (CHx Status) för varje UART-kanal medan alla inställningar som krävs för UART-kommunikation tillhandahålls av ht32_board_config.h. De hårdvarurelaterade parametrarna i ht32_board_config.h file visas i tabellen nedan. Mer information finns i avsnittet "Inställningsbeskrivning".

De hårdvarurelaterade parametrarna i ht32_board_config.h inkluderar I/O-inställningar och fysiska UART-portinställningar, enligt följande.

Tabell 3. Definitionssymboler i ht32_board_config.h

Symbol	Beskrivning
HTCFG_UARTM_CH0	Fysiskt UART-portnamn; Example: UART0, UART1...
HTCFG_UARTM0_TX_GPIO_PORT	Definierar portnamnet för TX för CH0; Example: A, B, C...
HTCFG_UARTM0_TX_GPIO_PIN	Definierar pinnumret för TX för CH0; Example: 0~15
HTCFG_UARTM0_RX_GPIO_PORT	Definierar portnamnet för RX för CH0; Example: A, B, C...
HTCFG_UARTM0_RX_GPIO_PIN	Definierar pinnumret för TX för CH0; Example: 0~15
HTCFG_UARTM0_TX_BUFFER_SIZE	Definierar TX-buffertstorleken för CH0; Example: 128 XNUMX
HTCFG_UARTM0_RX_BUFFER_SIZE	Definierar RX-buffertstorleken för CH0; Example: 128 XNUMX

För att ändra UART-kanalens AFIO-konfiguration, se relevant enhetsdatablad. För närvarande träder endast I/O-definitionerna för UART CH0 i kraft eftersom endast UART CH0 har konfigurerats i ht32_board_config.h. För att lägga till UART CH1~3 måste deras I/O-definitioner kompletteras genom att referera till UART CH0-definitionen eller hänvisa till avsnittet "Inställningsändringar och vanliga frågor".

Det finns tre huvudfunktioner för API-arkitektur: 

1. Upp till fyra UART-kanaler stöds. Deras ingångsparametrar är UARTM_CH0, UARTM_CH1, UARTM_CH2 och UARTM_CH3.
2.  Antalet UART-kanaler kan ställas in och oanvända kanaler kommer inte att minska tillgängligt minnesutrymme.
3. Alla UART-inställningar och I/O-definitioner är helt separerade från API:erna. Detta ökar hanteringsbekvämligheten med att ställa in värden och minskar risken för felaktiga eller saknade inställningar.

Inställningsbeskrivning 

Det här avsnittet kommer att introducera parameterinställningarna i ht32_board_config.h och uart_module.h files.

1. ht32_board_config.h: Detta file används för stiftdefinitioner och relevanta inställningar för utvecklingskort, som inkluderar UART IP-kanalen (UART0, UART1, USART0...) som används av Starter Kit (SK), motsvarande TX/RX-stiftplatser och TX/RX-buffertstorlek. Figur 10 visar inställningsinnehållet i HT32F52352 Starter Kit. Beroende på den funktionella integrationen av utvecklingen kan användare hänvisa till avsnittet "Pin Assignment" i databladet för den använda enheten för att implementera pindefinitionerna. Mer information om inställningsändringar kommer att beskrivas i avsnittet "Inställningsändringar och vanliga frågor".
   Figur 10. ht32_board_config.h Inställningar (HT32F52352)
   
2. uart_module.h: Detta är API-huvudet file används av applikationskoden, som inkluderar relevanta standardinställningar, funktionsdefinitioner etc. Som visas i figur 11 kan standardinställningsinnehållet skrivas över av externa konfigurationer, såsom inställningarna i ht32_board_config.h file.
   Figur 11. Standardinställningar i uart_module.h
   

API-beskrivning

1. Beskrivning av datatyp för applikationskod.
   • USART_InitTypeDef
     Detta är UARTs grundläggande konfigurationsstruktur som är sammansatt av BaudRate, WordLength, StopBits, Parity och Mode-konfigurationer, som visas nedan.

     Variabel Namn	Typ	Beskrivning
     USART_BaudRate	u32	UART kommunikationsöverföringshastighet
     USART_WordLength	u16	UART kommunikationsordslängd: 7, 8 eller 9 bitar
     USART_StopBits	u16	UART kommunikationsstoppbitlängd: 1 eller 2 bitar
     USART_Paritet	u16	UART kommunikationsparitet: jämn, udda, markering, mellanslag eller ingen paritet
     USART_Mode	u16	UART kommunikationsläge; API:erna stöder endast normalt läge

2. Innan du använder API-funktionerna, slutför den grundläggande UART-konfigurationen i huvudprogrammet. Den grundläggande UART-konfigurationen för denna applikationskod visas i figur 12. Här är baudhastigheten 115200bps, ordlängden är 8-bitars, stoppbitens längd är 1-bitars och det finns ingen paritet.
   Figur 12. UART Basic Configuration
   
3. Figur 13 visar API-funktionerna deklarerade i uart_module.h file. Följande tabeller förklarar funktionen, inmatningsparametrarna och användningen av API-funktionerna.
   Figur 13. API-funktionsdeklarationer i uart_module.h 
   

Namn	void UARTM_Init(u32 CH, USART_InitTypeDef *pUART_Init, u32 uRxTimeOutValue)
Fungera	UART-modulinitiering
Input	CH	UART-kanal
	pUART_Init	UART grundläggande konfigurationsstrukturpekare
	uRxTimeOutValue	UART RX FIFO timeout-värde. När RX FIFO tar emot ny data kommer räknaren att återställas och starta om. När räknaren når det förinställda timeout-värdet och motsvarande timeout-avbrott har aktiverats, kommer ett timeout-avbrott att genereras.
Användande	UARTM_Init(UARTM_CH0, &USART_InitStructure, 40);//Kör UART grundläggande konfiguration//Se figur 12 för USART_InitStructure-konfiguration

Namn	u32 UARTM_WriteByte(u32 CH, u8 uData)
Fungera	UART-modulskrivbyteoperation (TX)
Input	CH	UART-kanal
	uData	Data som ska skrivas
Produktion	FRAMGÅNG	Framgångsrik
	FEL	Misslyckades
Användande	UARTM_WriteByte(UARTM_CH0, 'A'); //UART skriver 1 byte – 'A'

Namn	u32 UARTM_Write(u32 CH, u8 *pBuffer, u32 uLength)
Fungera	UART-modulskrivoperation (TX)
Input	CH	UART-kanal
	pBuffer	Buffertpekare
	uLängd	Längden på data som ska skrivas
Produktion	FRAMGÅNG	Framgångsrik
	FEL	Misslyckades
Användande	u8 Test[] = “Detta är test!\r\n”; UARTM_Write(UARTM_CH0, Test, sizeof(Test) -1); //UART skriver pBuffer-data

Namn	u32 UARTM_ReadByte(u32 CH, u8 *pData)
Fungera	UART-modul läs byte operation (RX)
Input	CH	UART-kanal
	pData	Adressen för att placera den lästa datan
Produktion	FRAMGÅNG	Framgångsrik
	FEL	Misslyckades (inga data)
Användande	u8 TempData; om (UARTM_ReadByte(UARTM_CH0, &TempData) == SUCCESS){UARTM_WriteByte(UARTM_CH0, TempData);}//Om UARTM_ReadByte() returnerar SUCCESS så skriver UART denna databyte

Namn	u32 UARTM_Read(u32 CH, u8 *pBuffer, u32 uLength)
Fungera	UART-modulens läsfunktion (RX)
Input	CH	UART-kanal
	pBuffer	Buffertpekare
	uLängd	Längden på data som ska läsas
Produktion	Läs räkning	Längden på data har lästs
Användande	u8 Test2[10]; u32 Len; Len = UARTM_Read(UARTM_CH0, Test2, 5);if (Len > 0){UARTM_Write(UARTM_CH0, Test2, Len);}//UARTM_Read() läser 5 byte med data och lagrar data i Test2, och tilldelar antalet lästa byte till Len//Skriv data från Test2

Namn	u32 UARTM_GetReadBufferLength(u32 CH)
Fungera	Få läsbuffertlängden (RX)
Input	CH	UART-kanal
Produktion	uLängd	Läs buffertlängden
Användande	UARTM_Init(UARTM_CH0, &USART_InitStructure, 40); //UART-modulinitiering while (UARTM_GetReadBufferLength(UARTM_CH0) < 5);//Vänta tills UARTM_ReadBuffer har tagit emot 5 byte med data

Namn	u32 UARTM_GetWriteBufferLength(u32 CH)
Fungera	Få skrivbuffertlängden (TX)
Input	CH	UART-kanal
Produktion	uLängd	Skriv buffertlängd

Namn	u8 UARTM_IsTxFinished(u32 CH)
Fungera	Få TX-status
Input	CH	UART-kanal
Produktion	SANN	TX status: klar
	FALSK	Sändningsstatus: ej klar
Användande	UARTM_WriteByte(UARTM_CH0, 'O'); #if 1 // “uart_module.c” SVN >= 525 requiredwhile (UARTM_IsTxFinished(UARTM_CH0) == FALSE) #elsewhile (1) #endif //Detta API kan användas för att kontrollera TX-status, som visas ovan; vänta tills UARTM_WriteByte() API har avslutats, dvs. TX-status är TRUE, och fortsätt sedan de efterföljande åtgärderna.//En begränsning läggs till eftersom denna funktion inte har lagts till förrän SVN-versionsnumret i uart_module.c är 525.

Namn	ogiltig UARTM_DiscardReadBuffer(u32 CH)
Fungera	Kasta data i läsbufferten
Input	CH	UART-kanal

API-användning Examples 

Det här avsnittet kommer att visa API-skriva och läsa examples av applikationskoden "Module_UART" med hjälp av initieringsprocessen och "UART_Module_Example” applikationskodprocessen. Innan du använder API:erna måste användarna inkludera API-huvudet file i huvudprogrammets källkod file (#inkludera "middleware/uart_module.h").

Som visas i figur 14, när du går in i initieringsprocessen, definiera först UARTs grundläggande konfigurationsstruktur. Konfigurera sedan UARTs grundläggande konfigurationsstrukturmedlemmar inklusive BaudRate, WordLength, StopBits, Parity och Mode. Anropa slutligen API-initieringsfunktionen, vars slutförande indikerar slutet på initieringsprocessen. Efter detta kan användare fortsätta skriv- och läsoperationerna baserat på den förinställda UART-grundkonfigurationen.

Figur 14. Initialiseringsflödesschema

"UART_Module_Example” applikationskod demonstrerar API:s läs- och skrivoperationer på ett återupptaktssätt. Flödesschemat för detta visas i figur 15. API-funktionerna som används inkluderar UARTM_WriteByte(), UARTM_Write(), UARTM_ReadByte(), UARTM_Read() och UARTM_GetReadBufferLength(). Deras beskrivning finns i avsnittet "API-beskrivning".

Figur 15. Flödesschema över Skriv och Läs Examples

Det finns en annan "UART_Bridge"-applikationskod under mappen "Module_UART" vars relaterade file beskrivningen introduceras i avsnittet "Katalogstruktur". "UART_Bridge"-applikationskoden aktiverar två UART-kanaler, UART CH0 och UART CH1, och anpassar sedan kommunikationsprotokollet mellan de två UART-enheterna genom COMMAND-strukturer, gCMD1 och gCMD2. Dessa definieras i uart_bridge.c, som visas nedan. UARTBridge_CMD1TypeDef gCMD1:

Variabel Namn	Typ	Beskrivning
uHeader	u8	Rubrik
uCmd	u8	Kommando
uData[3]	u8	Data

UARTBridge_CMD2TypeDef gCMD2:

Variabel Namn	Typ	Beskrivning
uHeader	u8	Rubrik
uCmdA	u8	Kommando A
uCmdB	u8	Kommando B
uData[3]	u8	Data

I "UART_Bridge"-applikationskoden, använd gCMD1 för att ta emot data som ett kommandopaket och analysera det sedan. Sedan enligt det anpassade kommunikationsprotokollet, ställ in gCMD2 som ett svarspaket och överför det. Följande är ett example av ett kommandopaket gCMD1) och ett svarspaket (gCMD2). Kommandopaket (UARTBridge_CMD1TypeDef gCMD1):

byte 0	byte 1	Byte 2 ~ Byte 4
uHeader	uCmd	uData [3]
"A"	"1"	"x, y, z"

Svarspaket (UARTBridge_CMD2TypeDef gCMD2):

byte 0	byte 1	byte 2	Byte 3 ~ Byte 5
uHeader	uCmdA	uCmdB	uData [3]
"B"	"a"	"1"	"x, y, z"

Resursockupation
Med HT32F52352 som ett example, resurserna som upptas av UART-modulen visas nedan.

	HT32F52352
ROM-storlek	946 byte
RAM-storlek	40*1 + 256*2 Bytes

Notera:

1. Globala variabler inklusive flaggor och status för en enda kanal upptar 40 byte RAM.
2.  Detta är för ett tillstånd där en enda kanal används och TX/RX-buffertstorleken är 128/128 byte. Buffertstorleken kan ställas in enligt applikationskraven.

Tabell 4. Applikationskod Resurssysselsättning 

• Kompileringsmiljö: MDK-Arm V5.36, ARMCC V5.06 uppdatering 7 (build 960)
• Optimera alternativ: Nivå 2 (-O2)

Bruksanvisning

Detta kapitel kommer att introducera miljöförberedelserna för "Module_UART"-applikationskoden, såväl som kompilerings- och teststegen.

Miljöförberedelse
Hårdvaran och mjukvaran som krävs för applikationskoden "Module_UART" listas nedan.
Tabell 5. Miljöförberedelser för hårdvara/programvara 

Hårdvara/mjukvara	Räkna	Notera
Startpaket	1	Denna applikationsanteckning använder HT32F52352 Starter Kit som ett example
USB-kabel	1	Micro USB, ansluten till PC
Ansökningskod	—	Nedladdningsvägen, file och katalogkonfiguration introduceras i avsnittet "Resursnedladdning och förberedelse". Sökväg: "\\application\Module_UART\UART_Module_Exampde"
Tera Term	—	Se avsnittet "Terminalprogramvara".
Keil IDE	—	Keil uVision V5.xx

Använd först HT32F52352 Starter Kit kombinerat med funktionen Virtual COM Port (VCP) i e-Link32 Lite för UART-applikationsintroduktionen. Detta kräver att följande miljöförberedelser genomförs:

1. Det finns två USB-gränssnitt på kortet. Använd USB-kabeln för att ansluta datorn och eLink32 Lite-gränssnittet på kortet som visas i figur 16-(a).
2. Eftersom applikationskoden måste använda funktionen e-Link32 Lite Virtual COM Port (VCP), se till att PAx*2 och DAP_Tx för UART Jumper-J2*1 har kortslutits med en bygel. J2-platsen indikeras av figur 16-(b).

Notera

1. J2 på startpaketet har två alternativ, PAx och DAP_Tx kortslutna eller PAx och RS232_Tx kortslutna. Se användarmanualen för Starter Kit för detaljerade inställningsfunktioner.
2. MCU UART RX-stiftets placering på olika startsatser är olika. Detta example använder PAx för att indikera RX-stiftet.

Figur 16. Blockdiagram för HT32 Starter Kit

Använd nu användarmålkortet i kombination med funktionen Virtual COM Port (VCP) i e-Link32 Pro för introduktion av UART-applikationen. Detta kräver att följande miljöförberedelser genomförs:

1. Ena sidan av e-Link32 Pro är ansluten till en PC med en Mini USB-kabel och den andra sidan är ansluten till användarens målkort via dess 10-bitars grå kabel. Anslutningen mellan SWD-gränssnitten för kabeln och målkortet implementeras med hjälp av Dupont-linjer, som visas i figur 17-(a).
2. De seriella kommunikationsstiften på e-Link32 Pro är Pin#7 VCOM_RXD och Pin#8-VCOM_TXD. Dessa ska anslutas till TX- och RX-stiften på användarmålkortet, som visas i figur 17-(b).
   Figur 17. Blockdiagram för e-Link32 Pro + User Target Board
   

Sammanställning och test
Det här avsnittet kommer att ta "application\Module_UART\UART_Module_Example” som example för att introducera kompilerings- och testprocesserna. Innan detta, se till att alla förberedelser som beskrivs i föregående avsnitt har implementerats och att Tera Term terminalprogramvaran har laddats ner.

De detaljerade operationsstegen sammanfattas nedan.
Steg 1. Starttest

Ställ in hårdvarumiljön enligt beskrivningen i föregående avsnitt. Efter påslagning kommer D9-strömlampan i nedre vänstra delen av startsatsen att tändas. D1 USB-lampan på e-Link32 Lite uppe till höger kommer att lysa efter att USB-uppräkningen har slutförts. Om D1 inte lyser efter en längre tid, kontrollera om USB-kabeln kan kommunicera. Om inte, ta bort den och sätt tillbaka den igen.

Steg 2. Skapa ett projekt
Öppna applikationen\Module_UART\UART_Module_Exampi mappen, klicka på _CreateProject.bat file för att generera ett projekt, som visas i figur 18. Eftersom denna applikationsanteckning använder HT32F52352 Starter Kit, öppnar du Keil IDE-projektet "Project_52352.uvprojx" som finns under mappen MDK_ARMv5.

Figur 18. Kör _CreateProject.bat för att generera projekt

Steg 3. Kompilera och programmera
Efter att projektet har öppnats, klicka först på "Bygg" (eller använd genvägen "F7"), klicka sedan på "Ladda ner" (eller använd genvägen "F8"). Efter detta kommer bygg- och nedladdningsresultaten att visas i fönstret Build Output. Se bild 19.

Figur 19. Skapa och ladda ner resultat

Steg 4. Öppna programvaran Tera Term och konfigurera serieporten
Öppna programvaran Tera Term och COM-porten. Var uppmärksam på om COM-portnumret som genereras av Starter Kit är korrekt eller inte. Klicka sedan på "Setup >> Serial Port" för att komma in i konfigurationsgränssnittet. UART-gränssnittskonfigurationen för "Module_UART"-applikationskoden beskrivs i avsnittet "Terminalprogramvara". Inställningsresultatet visas i figur 20.

Figur 20. Resultat för inställning av Tera Term seriell port

Steg 5. Återställ systemet och testa
Tryck på SK reset-knappen – B1 Reset. Efter detta, ett "ABCThis är test!" meddelande kommer att vara
sänds via API:et och kommer att visas i Tera Term-fönstret, som visas i Figur 21. När det gäller mottagningsfunktionen, när data skrivs in i Tera Term-fönstret, kommer relevant API att användas för att bestämma mottagningsbuffertlängden. När data som tas emot av PC når 5 byte, kommer de mottagna 5 byte med data att skickas ut sekventiellt. Som visas i figur 22 är data som matas in sekventiellt "1, 2, 3, 4, 5", som tas emot och bestäms genom API:n. Efter detta kommer data "1, 2, 3, 4, 5" att skrivas ut efter de fem ingångarna.

Figur 21. "Module_UART" Funktionstest för applikationskod – sändning

Figur 22. "Module_UART" Funktionstest för applikationskod – ta emot

Transplantationsinstruktioner
Det här avsnittet kommer att introducera hur man integrerar API:erna i användarens projekt.
Steg 1. Lägg till uart_module.c file in i projektet. Högerklicka på mappen Användare. Välj "Lägg till befintliga Files till Group 'User'...", välj sedan uart_module.c file och klicka på "Lägg till", som visas i figur 23. Se avsnittet "Katalogstruktur" för file vägbeskrivning.

Figur 23. Lägg till uart_module.c File att projicera

Steg 2. Lägg till ring_buffer.c file in i projektet. Högerklicka på mappen Användare. Välj "Lägg till befintliga Files till Group 'User'...", välj sedan ring_buffer.c file och klicka på "Lägg till", som visas i figur 24.\ Se avsnittet "Katalogstruktur" för file vägbeskrivning.
Figur 24. Lägg till ring_buffer.c File att projicera 

Steg 3. Inkludera API-huvudet file i början av main.c, som visas i figur 25. (Ext: #include “middleware/uart_module.h”)
Figur 25. Inkludera API Header File till main.c

Steg 4. Implementera inställningarna som krävs för UART-kommunikationen med hjälp av ht32_board_config.h file. Detta introduceras i detalj i avsnitten "Inställningsbeskrivning" och "Ändring av inställningar och vanliga frågor".

Ändring av inställningar och vanliga frågor 

Det här avsnittet kommer att introducera hur du ändrar UART-inställningarna och förklarar några vanliga frågor som uppstår under användning.

Ändra UART-stifttilldelning 

1. Med hänvisning till HT32F52352-databladet "Pin Assignment"-kapitlet, slå upp tabellen Alternativa funktionsmappning som listar AFIO-funktionerna för enhetstypen. För UART-relevanta stift, se kolumnen "AF6 USART/UART", som visas i figur 26.
   Figur 26. HT32F52352 Tabell för alternativ funktionsmappning
   
   
2. Detta steg kommer att vägleda användare att hitta motsvarande UART-stift med hjälp av tabellen ovan. HT32F52352 example använder USART1 som standardkanal. Här är TX- och RX-stiften USR1_TX och USR1_RX och är placerade på PA4 respektive PA5. Figur 27 visar stiftöverensstämmelsen såväl som stiftdefinitionerna i "ht32_board_config.h". De tomma fälten för "Paket" i pintilldelningstabellen betyder att det inte finns några relevanta GPIO:er i detta paket. För att modifiera UART-stiften, hitta målstiftsplatserna och omdefiniera stiften med hjälp av "ht32_board_config.h" file.
   Figur 27. Pin-korrespondens och inställningsändring
   
   

Lägg till en UART-kanal
Med HT32F52352 HTCFG_UARTM_CH1 som ett example, här beskrivs hur man lägger till en ny UART-kanal.

Ändra ht32_board_config.h file
Med hänvisning till HT32F52352-databladet "Pin Assignment"-kapitlet, slå upp tabellen Alternativa funktionsmappning som listar AFIO-funktionerna för enhetstypen. Eftersom USART1 har använts som HTCFG_UARTM_CH0, kan den nyligen tillagda HTCFG_UARTM_CH1 välja USART0. Här är TX- och RX-stiften placerade på PA2 respektive PA3, som visas i den övre halvan av figur 28. Motsvarande modifieringar är implementerade med hjälp av kodraderna 120~126 i ht32_board_config.h, som visas av den röda prickade rutan i figuren 28.

Figur 28. Lägg till en UART-kanal

Vanliga frågor
Q: I steg 5 i avsnittet Kompilering och test är sändningsfunktionstestet normalt. Här, "ABCThis är test!" meddelandet har visats framgångsrikt, men för mottagningsfunktionen, varför de fem ingångsvärdena inte returneras och visas?
A: Kontrollera om MCU UART RX- och DAP_Tx-stiften på UART Jumper-J2 har kortslutits med en bygel. Eftersom applikationskoden "Module_UART" måste använda den virtuella COM-porten (VCP) i e-Link32 Lite, bör kortslutningsinställningen tillämpas på de två vänstra stiften på UART Jumper-J2, som visas i figur 29.

Figur 29. UART Jumper-J2-inställning

F: Efter exekvera "Build" (eller genvägen "F7"), visas ett felmeddelande som indikerar att firmware-biblioteksversionen är äldre än den som krävs? Se bild 30.
A: Implementeringen av "Module_UART"-applikationskoden måste inkludera uart_module.c/h files som har ett krav på en viss firmware-biblioteksversion. När ett sådant felmeddelande visas betyder det att det för närvarande använda firmwarebiblioteket är en äldre version. Därför är det nödvändigt att ladda ner den senaste versionen via länken i avsnittet "Firmware Library".

Figur 30. Felmeddelande om version av firmwarebibliotek

Slutsats

Detta dokument har tillhandahållit en grundläggande introduktion för att hjälpa användare med en bättre förståelse av applikationskoden "Module_UART" och UART-kommunikationsprotokoll. Detta följdes av resursnedladdning och förberedelse. Kapitlet Funktionsbeskrivning introducerade file katalogstruktur, API-arkitekturen, API-beskrivning och API-användning examples. Kapitlet med bruksanvisningar demonstrerade miljöförberedelser, sammanställning och testning av applikationskoden "Module_UART". Den gav också instruktioner för kodtransplantation och modifieringsinställningar samt förklarade några vanliga problem som kan uppstå. Allt detta tillsammans kommer att göra det möjligt för användare att snabbt förstå hur man använder API:erna och därefter minska tiden för att komma igång.

Referensmaterial

För mer information, se Holtek webwebbplats: www.holtek.com

Versioner och ändringsinformation

Datum	Författare	Släppa	Ändringsinformation
2022.04.30	蔡期育(Chi-Yu Tsai)	V1.00	Första versionen

Ansvarsfriskrivning

All information, varumärken, logotyper, grafik, videor, ljudklipp, länkar och andra föremål som visas på denna webwebbplatsen ('Information') är endast för referens och kan ändras när som helst utan föregående meddelande och enligt Holtek Semiconductor Inc. och dess närstående företag (hädanefter 'Holtek', 'företaget', 'oss', ' vi' eller 'vår'). Medan Holtek strävar efter att säkerställa riktigheten av informationen om detta webwebbplats, lämnas ingen uttrycklig eller underförstådd garanti av Holtek för informationens riktighet. Holtek tar inget ansvar för eventuella felaktigheter eller läckage.
Holtek ansvarar inte för några skador (inklusive men inte begränsat till datavirus, systemproblem eller dataförlust) som uppstår vid användning eller i samband med användningen av detta webwebbplats av någon part. Det kan finnas länkar i detta område som gör att du kan besöka webandra företags webbplatser.
Dessa webwebbplatser kontrolleras inte av Holtek. Holtek tar inget ansvar och ingen garanti för någon som helst information som visas på sådana webbplatser. Hyperlänkar till andra webwebbplatser sker på egen risk.

Ansvarsbegränsning

Holtek Limited ska under inga omständigheter vara ansvarigt gentemot någon annan part för någon förlust eller skada som helst eller hur som helst som orsakas direkt eller indirekt i samband med din åtkomst till eller användning av detta webwebbplats, innehållet på den eller några varor, material eller tjänster.

Gällande lag
Ansvarsfriskrivningen som finns i webwebbplatsen ska styras av och tolkas i enlighet med lagarna i Republiken Kina. Användare kommer att underkasta sig den icke-exklusiva jurisdiktionen för Republiken Kinas domstolar.

Uppdatering av ansvarsfriskrivning
Holtek förbehåller sig rätten att uppdatera ansvarsfriskrivningen när som helst med eller utan föregående meddelande, alla ändringar träder i kraft omedelbart efter att de publicerats till webplats.

Dokument/resurser

HOLTEK HT32 MCU UART Applikationsanmärkning [pdf] Användarmanual HT32 MCU, UART Application Note, HT32 MCU UART, Application Note, HT32, MCU UART Application Note, HT32 MCU UART Application Note

Referenser

• Användarmanual