- Seriekommunikasjon på STM8S103F3P6
- Serielle kommunikasjonspinner på STM8S103F3P6
- Kretsdiagram for STM8S seriell kommunikasjon
- Sette opp STVD for seriell kommunikasjon
- Programmering STM8S for seriell kommunikasjon
- Kontrollerer LED fra seriell skjerm
- STM8S Serial Library Deeper Look
Programmering av en ny mikrokontroller tar ofte lengre tid på grunn av de nye metodene for registerhåndtering og ikke å vite hvilken bit som gjør nøyaktig hva. Det samme gjelder for feilsøking også uten å si. Dette er grunnen til at programmerere ofte bruker brytpunkter i koden og går gjennom den ved hjelp av en feilsøkingsprogram. Men å bruke en feilsøking kan trenge ekstra maskinvare (mest kostbare) og også ekstra tid. Å være en Arduino-fan gutt, en ting vi alle kan være enige i er å bruke serielle utskriftsuttalelser for feilsøking og forstå koden vår, gjør livet mye lettere. Hva kan vi replikere det samme på STM8s med kosmisk C-kompilator og SPL-biblioteker? Vel, det er veldig mye mulig, og det er akkurat det vi skal gjøre i denne tredje opplæringen av opplæringsserien vår.Du sjekker også komme i gang med STM8S (tutorial 1) og STM8S GPIO control (tutorial 2) hvis du er helt ny her. Vi har også undersøkt muligheten for å programmere STM8S med Arduino for rask start. Alt som blir sagt, la oss komme inn i veiledningen.
Seriekommunikasjon på STM8S103F3P6
Fra databladet til STM8S103F3P6 kan vi se at 8-bits kontrolleren vår støtter UART-kommunikasjon i mange forskjellige moduser. Kontrolleren har også en klokkeutgangspinne for synkron UART-kommunikasjon og kan også støtte SmarCard, IrDA og LIN. Men vi vil ikke utforske noe av det i denne opplæringen bare for å holde oss borte fra kompleksitet. Vi vil lære å gjøre enkle UART-lesing og -skriving.
Opplæringen gir også en overskriftsfil kalt stm8s103 serial.h ved hjelp av hvilken du kan utføre enkle UART-kommandoer som Seriell start, Seriell lesing, seriell utskrift, etc. I utgangspunktet vil du kunne skrive ut char, int og streng til seriell skjerm og les også røye fra den serielle skjermen. På slutten av denne opplæringen vil du kunne styre en LED fra den serielle skjermen og få tilbakemelding om LED-statusen. Overskriftsfilen som er nevnt ovenfor, avhenger av SPL-bibliotekene, så sørg for at du har fulgt veiledningen for å komme i gang.
Serielle kommunikasjonspinner på STM8S103F3P6
La oss starte fra maskinvaresiden. Når vi tar en rask titt på pinouts på STM8S103F3P6 mikrokontroller gitt nedenfor, kan vi se at pinnene 1, 2 og 3 vil bli brukt til UART-kommunikasjon.
Blant de tre er pin 1 UART-klokken som bare skal brukes under synkron UART-kommunikasjon, så vi trenger ikke det her. Pin 2 er UART-transmitterpinnen og Pin 3 er UART-mottakerpinnen. Vær oppmerksom på at disse pinnene også kan fungere som en analog pin eller normal GPIO pin.
Kretsdiagram for STM8S seriell kommunikasjon
Kretsskjemaet er veldig enkelt her, vi må koble ST-LINK 2 for programmering og en USB til TTL-omformer for å lese seriell data. Vær oppmerksom på at STM8S-kontrolleren vår fungerer på 3.3V-logikknivå, så sørg for at USB til TTL-omformeren også støtter 3.3V-logikk. Hele kretsskjemaet er vist nedenfor.
Du må koble ST-linken din til en USB-port og USB til TTL-omformer i en annen USB-port på den bærbare datamaskinen, slik at du både kan programmere og overvåke data samtidig. UART-tilkoblingen er enkel, bare koble bakken og Rx / Tx-pinnen på STM8S-mikrokontrolleren din til Tx / Rx-pinnene på USB til TTL-omformeren. Her har jeg drevet kontrolleren med Vcc-pinnen til ST-Link og har latt vss-pinnen på TTL-omformeren være åpen, du kan også gjøre dette omvendt. Det er mange typer USB til TTL-omformere i markedet, bare sørg for at den kan fungere på 3,3 V logiske signaler og enkelt se etter Tx-, Rx- og GND-pinner og lage forbindelsen vist ovenfor. Min maskinvareoppsett er vist nedenfor.
For å lage en seriell kommunikasjon, har vi gitt STM8S_Serial.h topptekstfil. Ved å bruke denne headerfilen kan du utføre enkle Arduino-lignende funksjoner for seriell kommunikasjon.
Du finner alle nødvendige filer for dette prosjektet på vår STM8S103F3_SPL Github-side. Hvis du bare trenger denne spesielle toppfilen, kan du laste den ned fra lenken nedenfor.
Last ned STM8S_Serial.h
Sette opp STVD for seriell kommunikasjon
For å jobbe med seriell kommunikasjon, vil vi bruke mange ved å bruke STM8S_Serial.h headerfilfunksjonen som vi diskuterte tidligere. Men biblioteket har andre avhengigheter, mange SPL UART- og klokkerelaterte header og C-filer. Så fra dette punktet er det bedre å inkludere alle header- og C-filene i prosjektet vårt for å unngå en kompileringsfeil. STVD-arbeidsmiljøet mitt ser slik ut.
Forsikre deg om at du har tatt med alle SPL-kildefilene og inkluder filen som vi gjorde i vår første opplæring. Og sørg også for at du har lagt til stm8s103_serial.h topptekstfilen. Det er ingen C-fil for denne overskriften.
Programmering STM8S for seriell kommunikasjon
Når STVD-prosjektoppsettet er klart, kan vi begynne å skrive koden vår i main.c- filen. Den komplette koden for denne veiledningen finner du nederst på denne siden. Forklaringen er som følger.
Det første trinnet er å inkludere de nødvendige headerfilene, her har jeg lagt til hovedhodefilen (stm8s) og stm8s_103_serial headerfilen som vi nettopp lastet ned.
// Nødvendige overskrifter # inkluderer "STM8S.h" # inkluderer "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3_SPL/blob/master/stm8s103%20Libraries/stm8s103_Serial.h
Deretter bruker vi designmakroene til å spesifisere inngangs- og utgangspinnene. Her vil bare styre den innebygde LED-en som er koblet til pin5 i port B, så vi gir den et navn som test_LED .
#define test_LED GPIOB, GPIO_PIN_5 // test LED er koblet til PB5
Fortsatt inne i hovedfunksjonen vil vi definere pinnen som en utgang. Hvis du ikke er kjent med grunnleggende GPIO-funksjoner, kan du gå tilbake til STM8S GPIO-opplæringen.
// Pin defanitions // Declare PB5 as push pull Output pin GPIO_Init (test_LED, GPIO_MODE_OUT_PP_LOW_SLOW);
Deretter initialiserer vi serielle kommunikasjonsporter til 9600 baudhastigheter. For de som er nye, er 9600 hastigheten som databitene vil overføres under kommunikasjon. Hvis du setter 9600 her, må du også stille det samme på overvåkingsprogramvaren. Deretter skriver vi også ut en streng "Enter kommando" og går videre til neste linje.
Serial_begin (9600); // Initialiser seriekommunikasjon ved 9600 baudrate Serial_print_string ("Enter command"); // skriv ut en streng Serial_newline (); // gå til neste linje
Når vi går videre til den uendelige mens sløyfen bruker vi Serial_available- funksjonen for å sjekke om det er innkommende serielle data. Hvis ja, vi leser og lagrer den i en variabel kalt ch og skriver også ut den samme ved hjelp av Serial_print . Så hvis den mottatte verdien er 0, slår vi av LED-en, og hvis den er 1, vil vi slå på LED-en
hvis (Serial_available ()) {Serial_print_string ("Du har trykket på:"); ch = Serial_read_char (); Serial_print_char (ch); Serial_newline (); hvis (ch == '0') GPIO_WriteHigh (test_LED); // LED AV hvis (ch == '1') GPIO_WriteLow (test_LED); // LED PÅ}
Med dette er programmeringen for denne opplæringen fullført, bare last opp koden som er oppgitt nederst på denne siden, og du bør være i stand til å kontrollere lysdioden fra den serielle skjermen.
Kontrollerer LED fra seriell skjerm
Når du har lastet opp koden, kan du åpne hvilken som helst seriell skjerm til 9600 baudhastigheter. Jeg har brukt Arduino seriell skjerm for å gjøre det enkelt å bruke den. Trykk på tilbakestillingsknappen, og meldingen “Skriv inn en kommando” vises. Så hvis du skriver inn 1 og trykker på enter, skal den innebygde ledningen slås på, tilsvarende for 0, den skal slås av.
Komplett arbeid finner du i videoen som er lenket nederst på denne siden. Hvis du har spørsmål, kan du legge dem igjen i kommentarfeltet. Du kan også bruke forumene våre til å legge ut andre tekniske spørsmål.
STM8S Serial Library Deeper Look
For de nysgjerrige hodene som vil vite hva som faktisk skjer inne i STM8S103F3_Serial header-filen, les videre…
Denne headerfilen fungerer bra for programmering på nybegynnernivå, men hvis du bruker en annen versjon av STM8S-kontrolleren eller leter etter noen avanserte alternativer, vil du kanskje tilpasse denne headeren litt eller direkte jobbe med SPL-biblioteker. Jeg skrev denne headerfilen akkurat som en moden fra UART1-headerfilen, forklaringen på headerfilen min er som følger.
Lese et tegn fra Serial Monitor
Denne funksjonen hjelper deg å lese et enkelt tegn som er sendt til mikrokontrolleren fra den serielle skjermen.
char Serial_read_char (void) {while (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); retur (UART1_ReceiveData8 ()); }
Vi venter til RXE-flagget er SETT for å fullføre mottaket og tømmer deretter flagget for å bekrefte mottakelsen. Til slutt sender vi mottatte 8-biters data som resultat av denne funksjonen.
Skrive ut et tegn til Serial Monitor
Denne funksjonen overfører et enkelt tegn fra en mikrokontroller til den serielle skjermen.
ugyldig Serial_print_char (char verdi) {UART1_SendData8 (verdi); mens (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // vent på sending}
Funksjonen skriver ganske enkelt 8-bits verdien og venter til overføringen er fullført ved å sjekke UART1_FLAG_TXE til SET
Initialiserer seriell kommunikasjon
Denne funksjonen initialiserer seriell kommunikasjon med ønsket baudrate.
ugyldig 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 (); // Deinitialisere UART-periferiutstyr 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 fra baudhastigheten, er det andre parametere som må stilles inn for seriell kommunikasjon, som antall databiter, antall stoppbiter, paritet osv. Den vanligste (ligner på Arduino) er 8-bits data med en stoppbit og ingen paritet, og dermed vil det være standardinnstillingen. Du kan endre det om nødvendig.
Skrive ut et heltall til seriell skjerm
Hvis vi bruker en seriell skjerm for feilsøking eller overvåking, vil vi kanskje skrive ut en variabel av typen int til den serielle skjermen. Denne funksjonen gjør akkurat det
ugyldig Serial_print_int (int-nummer) // Funksjon for å skrive ut int-verdi til seriell skjerm {char count = 0; char-siffer = ""; mens (tall! = 0) // deler int til char array {sifre = nummer% 10; telle ++; tall = tall / 10; } mens (count! = 0) // skriv ut char array i riktig retning {UART1_SendData8 (siffer + 0x30); mens (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // vent på sending teller--; }}
Det tar inn en heltallverdi og konverterer den til tegnsett i den første mens sløyfen, deretter i den andre mens sløyfen, vil vi sende hvert av tegnene som ligner på vår utskriftsfunksjon.
Skrive ut en ny linje
Dette er en enkel funksjon for å skrive ut en ny linje. Hexverdien for å gjøre det er "0x0a", vi sender den bare over ved hjelp av 8-biters sendekommandoen.
ugyldig Serial_newline (ugyldig) {UART1_SendData8 (0x0a); mens (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // vent på sending}
Skriver ut en streng til seriell skjerm
En annen nyttig funksjon er å faktisk skrive ut strenger på den serielle skjermen.
ugyldig Serial_print_string (char string) {. char i = 0; mens (streng! = 0x00) {UART1_SendData8 (streng); mens (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); i ++; }}
Igjen konverterer denne funksjonen også strengen til char array og sender hvert tegn. Som vi vet vil alle strengene være null. Så vi må bare fortsette å krysse og overføre tegnene til vi når null 0x00.
Kontrollerer om serielle data er tilgjengelige å lese
Denne funksjonen sjekker om det er serielle data i bufferen som er klare til å leses.
bool Serial_available () {if (UART1_GetFlagStatus (UART1_FLAG_RXNE) == TRUE) returner TRUE; ellers returnere FALSE; }
Den sjekker for flagget UART1_FLAG_RXNE , hvis det er sant, returnerer det sant, og hvis det ikke er det, returnerer det falskt.