- Seriekommunikation på STM8S103F3P6
- Seriella kommunikationsnålar på STM8S103F3P6
- Kretsschema för STM8S seriell kommunikation
- Ställa in STVD för seriell kommunikation
- Programmering STM8S för seriell kommunikation
- Kontrollerar LED från seriell bildskärm
- STM8S Serial Library Deeper Look
Programmering av en ny mikrokontroller tar ofta längre tid på grund av de nya registerhanteringsmetoderna och inte vet vilken bit som gör exakt vad. Detsamma gäller även felsökning utan att säga. Det är därför som programmerare ofta använder brytpunkter i sin kod och går igenom den med en felsökare. Men att använda en felsökare kan behöva ytterligare hårdvara (oftast dyra) och också ytterligare tid. Att vara en Arduino-fanpojke, en sak som vi alla kan komma överens om är att använda serietrycksuttalanden för att felsöka och förstå vår kod gör livet mycket enklare. Vad kan vi replikera detsamma på STM8s med kosmisk C-kompilator och SPL-bibliotek? Tja, det är väldigt mycket möjligt, och det är precis vad vi ska göra i denna tredje handledning i vår handledningsserie.Du kontrollerar också att komma igång med STM8S (tutorial 1) och STM8S GPIO-kontroll (tutorial 2) om du är helt ny här. Vi har också undersökt möjligheten att programmera STM8S med Arduino för snabbstart. Allt som sägs låt oss gå in i handledningen.
Seriekommunikation på STM8S103F3P6
Från databladet för STM8S103F3P6 kan vi se att vår 8-bitars styrenhet stöder UART-kommunikation i många olika lägen. Styrenheten har också en klockutgångsstift för synkron UART-kommunikation och kan också stödja SmarCard, IrDA och LIN. Men vi kommer inte att utforska något av det i den här handledningen bara för att hålla oss borta från komplexitet. Vi lär oss att göra enkla UART-läsningar och -skrivningar.
Självstudien tillhandahåller också en rubrikfil som heter stm8s103 serial.h med vilken du kan utföra enkla UART-kommandon som Seriell början, Seriell läsning, Seriell utskrift osv. I grund och botten kommer du att kunna skriva ut char, int och sträng till seriell bildskärm och läs även char från den seriella bildskärmen. I slutet av denna handledning kommer du att kunna styra en lysdiod från den seriella bildskärmen och få feedback om status för lysdioden. Rubrikfilen som nämns ovan beror på SPL-biblioteken, så se till att du har följt handboken för att komma igång.
Seriella kommunikationsnålar på STM8S103F3P6
Låt oss börja från hårdvarusidan. Om vi tar en snabb titt på uttagen på STM8S103F3P6- mikrokontrollern nedan kan vi se att stift 1, 2 och 3 kommer att användas för UART-kommunikation.
Bland de tre är stift 1 UART-klockstiftet som endast kommer att användas under synkron UART-kommunikation, så vi behöver inte det här. Stift 2 är UART-sändarstiftet och stift 3 är UART-mottagarstiftet. Observera att dessa stift också kan fungera som en analog stift eller normal GPIO-stift.
Kretsschema för STM8S seriell kommunikation
Kretsschemat är väldigt enkelt här, vi måste ansluta vår ST-LINK 2 för programmering och en USB till TTL-omvandlare för att läsa seriell data. Observera att vår STM8S-kontroller fungerar på 3.3V-logiknivå, så se till att din USB till TTL-omvandlare också stöder 3.3V-logik. Det fullständiga kretsschemat visas nedan.
Du måste ansluta din ST-länk i en USB-port och USB till TTL-omvandlare i en annan USB-port på din bärbara dator, så att du både kan programmera och övervaka data samtidigt. UART-anslutningen är enkel, anslut bara marken och Rx / Tx-stift på din STM8S-mikrokontroller till Tx / Rx-stiften på USB till TTL-omvandlaren. Här har jag drivit styrenheten med Vcc-stiftet på ST-Link och har lämnat vss-stiftet på TTL-omvandlaren öppen, du kan också göra det tvärtom. Det finns många typer av USB till TTL-omvandlare på marknaden, se bara till att den kan fungera på 3,3 V logiska signaler och enkelt leta efter Tx-, Rx- och GND-stift och göra anslutningen som visas ovan. Min hårdvaruuppsättning visas nedan.
För att skapa ett seriekommunikationssätt har vi tillhandahållit rubrikfilen STM8S_Serial.h . Med hjälp av denna rubrikfil kan du utföra enkla Arduino-liknande funktioner för seriell kommunikation.
Du hittar alla filer som krävs för detta projekt på vår STM8S103F3_SPL Github-sida. Om du bara behöver den här rubrikfilen kan du ladda ner den från länken nedan.
Ladda ner STM8S_Serial.h
Ställa in STVD för seriell kommunikation
För att arbeta med seriekommunikation använder vi många med hjälp av STM8S_Serial.h-rubrikfilfunktionen som vi diskuterade tidigare. Men biblioteket har andra beroenden, många SPL UART- och klockrelaterade sidhuvud och C-filer. Så från denna punkt är det bättre att inkludera alla rubriker och C-filer i vårt projekt för att undvika ett kompileringsfel. Min STVD-arbetsmiljö ser ut så här.
Se till att du har inkluderat alla SPL-källfiler och inkludera filen som vi gjorde i vår första handledning. Och se till att du har lagt till rubrikfilen stm8s103_serial.h . Det finns ingen C-fil för denna rubrik.
Programmering STM8S för seriell kommunikation
När STVD-projektinställningen är klar kan vi börja skriva vår kod i main.c- filen. Den fullständiga koden för denna handledning finns längst ner på denna sida. Förklaringen är som följer.
Det första steget är att inkludera de nödvändiga rubrikfilerna, här har jag lagt till huvudhuvudfilen (stm8s) och stm8s_103_serial rubrikfilen som vi just laddade ner.
// Obligatoriska rubriker # inkludera "STM8S.h" # inkludera "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3_SPL/blob/master/stm8s103%20Libraries/stm8s103_Serial.h
Därefter använder vi designmakron för att specificera in- och utgångsstift. Här kommer endast styrning av den inbyggda lysdioden som är ansluten till pin5 i port B, så vi ger den ett namn som test_LED .
#define test_LED GPIOB, GPIO_PIN_5 // test LED är ansluten till PB5
När vi går vidare inuti huvudfunktionen definierar vi stiftet som en utgång. Om du inte känner till grundläggande GPIO-funktioner kan du återgå till STM8S GPIO-handledning.
// Pin defanitions // Deklarera PB5 som push pull Utgångsstift GPIO_Init (test_LED, GPIO_MODE_OUT_PP_LOW_SLOW);
Sedan initialiserar vi våra seriella kommunikationsportar till 9600 baudhastigheter. För dem som är nya är 9600 den hastighet med vilken databitarna kommer att överföras under kommunikationen. Om du ställer in 9600 här måste du också ställa in samma på övervakningsprogrammet. Sedan skriver vi också ut en sträng "Enter command" och går vidare till nästa rad.
Serial_begin (9600); // Initiera seriekommunikation vid 9600 baudhastighet Serial_print_string ("Enter command"); // skriva ut en sträng Serial_newline (); // flytta till nästa rad
När vi går vidare till det oändliga under slingan använder vi funktionen Serial_available för att kontrollera om det finns några inkommande seriell data. Om ja, läser vi och sparar det i en variabel som heter ch och skriver också ut samma med Serial_print . Om det mottagna värdet är 0 stänger vi sedan av lysdioden och om det är 1 slår vi på lysdioden
if (Serial_available ()) {Serial_print_string ("Du har tryckt på:"); ch = Serial_read_char (); Serial_print_char (ch); Serial_newline (); om (ch == '0') GPIO_WriteHigh (test_LED); // LED OFF om (ch == '1') GPIO_WriteLow (test_LED); // LED PÅ}
Med detta är programmeringen för den här självstudien klar, ladda bara upp koden som ges längst ner på den här sidan och du borde kunna styra lysdioden från den seriella skärmen.
Kontrollerar LED från seriell bildskärm
När du har laddat upp koden kan du öppna valfri seriell bildskärm till 9600 baudhastigheter. Jag har använt Arduino seriell bildskärm själv för att det ska vara enkelt att använda den. Tryck på återställningsknappen så visas meddelandet ”Ange ett kommando”. Om du sedan anger 1 och trycker på enter, ska den inbyggda ledningen tändas, på samma sätt för 0, den ska stängas av.
Hela arbetet finns i den länkade videon längst ner på denna sida. Om du har några frågor, vänligen lämna dem i kommentarsektionen. Du kan också använda våra forum för att skicka andra tekniska frågor.
STM8S Serial Library Deeper Look
För de nyfikna sinnen som vill veta vad som faktiskt händer i STM8S103F3_Serial-rubrikfilen läs vidare…
Denna rubrikfil fungerar bra för programmering på nybörjarnivå, men om du använder en annan version av STM8S-kontrollenheten eller letar efter några avancerade alternativ, kanske du vill justera den här rubriken lite eller direkt arbeta med SPL-bibliotek. Jag skrev den här rubrikfilen precis som en mognad från UART1-rubrikfilen, förklaringen på min rubrikfil är följande.
Läser en karaktär från Serial Monitor
Denna funktion hjälper till att läsa ett enda tecken som har skickats till mikrokontrollern från den seriella bildskärmen.
char Serial_read_char (void) {while (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); returnera (UART1_ReceiveData8 ()); }
Vi väntar tills RXE-flaggan är SET för att slutföra mottagningen och rensar sedan flaggan för att bekräfta mottagningen. Slutligen skickar vi mottagen 8-bitars data som resultat av denna funktion.
Skriva ut ett tecken till Serial Monitor
Denna funktion överför ett tecken från en mikrokontroller till den seriella bildskärmen.
ogiltigt Serial_print_char (char-värde) {UART1_SendData8 (värde); medan (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // vänta på att skicka}
Funktionen skriver helt enkelt 8-bitarsvärdet och väntar tills överföringen är klar genom att kontrollera UART1_FLAG_TXE till SET
Initierar seriekommunikation
Denna funktion initierar seriell kommunikation med den önskade baudhastigheten.
ogiltig 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 (); // Avinitiera UART-kringutrustning 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); }
Bortsett från baudhastigheten finns det andra parametrar som måste ställas in för seriekommunikation, som antalet databitar, antalet stoppbitar, paritet etc. Den vanligaste (liknar Arduino) är 8-bitars data med en stoppbit och ingen paritet och därmed kommer det att vara standardinställningen. Du kan ändra det om det behövs.
Skriva ut ett heltal till seriell bildskärm
För det mesta, om vi använder en seriell bildskärm för felsökning eller övervakning, kanske vi vill skriva ut en variabel av typen int till den seriella bildskärmen. Denna funktion gör exakt det
ogiltigt Serial_print_int (int-nummer) // Funktion för att skriva ut int-värde till seriell bildskärm {char count = 0; char digit = ""; medan (nummer! = 0) // delar int till char array {siffran = nummer% 10; räkna ++; antal = antal / 10; } medan (count! = 0) // skriv ut char array i rätt riktning {UART1_SendData8 (siffra + 0x30); medan (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // vänta på att skicka räkning--; }}
Det tar in ett heltal och konverterar det till teckenuppsättning i den första medan slingan, sedan i den andra medan slingan, kommer vi att skicka vart och ett av tecknen som liknar vår utskrift char funktion.
Skriva ut en ny rad
Detta är en enkel funktion för att skriva ut en ny rad. Hexvärdet för att göra det är "0x0a", vi skickar det bara med hjälp av 8-bitars sändningskommandot.
ogiltig Serial_newline (ogiltig) {UART1_SendData8 (0x0a); medan (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // vänta på att skicka}
Skriva ut en sträng till seriell bildskärm
En annan användbar funktion är att faktiskt skriva ut strängar på den seriella bildskärmen.
ogiltig Serial_print_string (char string) {. char i = 0; medan (sträng! = 0x00) {UART1_SendData8 (sträng); medan (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); i ++; }}
Återigen konverterar den här funktionen också strängen till char array och skickar varje tecken. Som vi vet kommer alla strängar att vara noll. Så vi måste bara fortsätta att korsa och överföra karaktärerna tills vi når noll 0x00.
Kontrollerar om seriell data finns att läsa
Denna funktion kontrollerar om det finns några seriella data i bufferten redo att läsas.
bool Serial_available () {if (UART1_GetFlagStatus (UART1_FLAG_RXNE) == TRUE) returnerar SANT; annars returnerar FALSE; }
Den söker efter flaggan UART1_FLAG_RXNE , om den är sant, returnerar den sant och om den inte är, returnerar den falskt.