- Seriel kommunikation på STM8S103F3P6
- Seriel kommunikationsnål på STM8S103F3P6
- Kredsløbsdiagram for STM8S seriel kommunikation
- Opsætning af STVD til seriel kommunikation
- Programmering STM8S til seriel kommunikation
- Styring af LED fra seriel skærm
- STM8S serielt bibliotek dybere look
Programmering af en ny mikrocontroller tager ofte længere tid på grund af de nye registerhåndteringsmetoder og ikke at vide, hvilken bit der gør nøjagtigt hvad. Det samme gælder også for debugging uden at sige. Dette er grunden til, at programmører ofte bruger breakpoints i deres kode og går igennem den ved hjælp af en debugger. Men brug af en debugger har muligvis brug for ekstra hardware (oftest dyrt) og også ekstra tid. At være en Arduino fan-dreng, en ting, som vi alle er enige om, er at bruge serielle udskriftserklæringer til fejlfinding og forståelse af vores kode gør livet meget lettere. Hvad kan vi replikere det samme på STM8s med kosmisk C-compiler og SPL-biblioteker? Nå, det er meget muligt, og det er præcis, hvad vi skal gøre i denne tredje tutorial af vores tutorial-serie.Du kontrollerer også at komme i gang med STM8S (tutorial 1) og STM8S GPIO-kontrol (tutorial 2), hvis du er helt ny her. Vi har også undersøgt muligheden for at programmere STM8S med Arduino til hurtige startere. Alt det der er sagt, lad os komme ind i vejledningen.
Seriel kommunikation på STM8S103F3P6
Fra databladet til STM8S103F3P6 kan vi se, at vores 8-bit controller understøtter UART-kommunikation i mange forskellige tilstande. Controlleren har også en urudgangsstift til synkron UART-kommunikation og kan også understøtte SmarCard, IrDA og LIN. Men vi vil ikke undersøge noget af det i denne vejledning bare for at holde os væk fra kompleksitet. Vi lærer, hvordan man laver og skriver UART let.
Selvstudiet giver også en headerfil kaldet stm8s103 serial.h, hvor du kan udføre enkle UART-kommandoer som Seriel start, Serielæsning , seriel udskrivning osv. Dybest set vil du være i stand til at udskrive char, int og streng til den serielle skærm og læs også char fra den serielle skærm. I slutningen af denne vejledning vil du være i stand til at styre en LED fra den serielle skærm og få feedback om status for LED'en. Overskriftsfilen nævnt ovenfor afhænger af SPL-bibliotekerne, så sørg for at du har fulgt vejledningen om at komme i gang.
Seriel kommunikationsnål på STM8S103F3P6
Lad os starte fra hardwaresiden. Når vi kigger hurtigt på pinouts på STM8S103F3P6- mikrocontrolleren nedenfor, kan vi se, at ben 1, 2 og 3 vil blive brugt til UART-kommunikation.
Blandt de tre er pin 1 UART-uret, som kun bruges under synkron UART-kommunikation, så vi har ikke brug for det her. Stift 2 er UART-transmitterstiften, og pin 3 er UART-modtagerstiften. Bemærk, at disse ben også kan fordoble som en analog pin eller normal GPIO pin.
Kredsløbsdiagram for STM8S seriel kommunikation
Kredsløbsdiagrammet er meget simpelt her, vi skal forbinde vores ST-LINK 2 til programmering og en USB til TTL-konverter til læsning af serielle data. Bemærk, at vores STM8S-controller fungerer på 3.3V-logikniveau, så sørg for, at din USB til TTL-konverter også understøtter 3.3V-logik. Det komplette kredsløbsdiagram er vist nedenfor.
Du skal tilslutte din ST-link i en USB-port og USB til TTL-konverter i en anden USB-port på din bærbare computer, så du både kan programmere og overvåge data på samme tid. UART-forbindelsen er enkel, tilslut bare jorden og Rx / Tx-stiften på din STM8S-mikrocontroller til Tx / Rx-stifterne på USB til TTL-konverteren. Her har jeg forsynet controlleren med Vcc-stift på ST-Link og har ladet vss-stiften på TTL-konverter være åben, du kan også gøre det omvendt. Der er mange typer USB til TTL-konverter på markedet, bare sørg for at den kan fungere på 3,3 V logiske signaler og simpelt kigge efter Tx, Rx og GND-ben og oprette forbindelsen vist ovenfor. Min hardwareopsætning er vist nedenfor.
For at gøre en seriel kommunikation måde har vi leveret STM8S_Serial.h headerfilen. Ved hjælp af denne headerfil kan du udføre enkle Arduino-lignende funktioner til seriel kommunikation.
Du kan finde alle de nødvendige filer til dette projekt på vores STM8S103F3_SPL Github-side. Hvis du kun har brug for netop denne headerfil, kan du downloade den fra nedenstående link.
Download STM8S_Serial.h
Opsætning af STVD til seriel kommunikation
For at arbejde med seriel kommunikation bruger vi mange ved hjælp af STM8S_Serial.h headerfilfunktionen, som vi diskuterede tidligere. Men biblioteket har andre afhængigheder, mange SPL UART- og urrelaterede header og C-filer. Så fra dette tidspunkt er det bedre at inkludere alle header- og C-filer i vores projekt for at undgå en kompileringsfejl. Mit STVD-arbejdsmiljø ser sådan ud.
Sørg for, at du har inkluderet alle SPL-kildefiler og Inkluder fil som vi gjorde i vores første tutorial. Og sørg også for at du har tilføjet stm8s103_serial.h headerfilen. Der er ingen C-fil til denne overskrift.
Programmering STM8S til seriel kommunikation
Når STVD-projektopsætningen er klar, kan vi begynde at skrive vores kode i main.c- filen. Den komplette kode til denne vejledning kan findes nederst på denne side. Forklaringen er som følger.
Det første trin er at inkludere de nødvendige headerfiler, her har jeg tilføjet hovedhovedfilen (stm8s) og stm8s_103_serial headerfilen, som vi lige har downloadet.
// Påkrævede overskrifter # inkluderer "STM8S.h" # inkluderer "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3_SPL/blob/master/stm8s103%20Libraries/stm8s103_Serial.h
Dernæst bruger vi designmakroerne til at specificere input og output pins. Her styres kun den indbyggede LED, som er forbundet til pin5 i port B, så vi giver den et navn som test_LED .
#define test_LED GPIOB, GPIO_PIN_5 // test LED er forbundet til PB5
Når vi bevæger os inde i hovedfunktionen, definerer vi stiften som en output. Hvis du ikke er fortrolig med de grundlæggende GPIO-funktioner, skal du falde tilbage til STM8S GPIO-vejledningen.
// Pin defanitions // Erklær PB5 som push pull Output pin GPIO_Init (test_LED, GPIO_MODE_OUT_PP_LOW_SLOW);
Derefter initialiserer vi vores serielle kommunikationsporte til 9600 baudhastigheder. For dem, der er nye, er 9600 den hastighed, hvormed databitene overføres under kommunikation. Hvis du indstiller 9600 her, skal du også indstille det samme på overvågningssoftwaren. Derefter udskriver vi også en streng "Enter kommando" og går videre til næste linje.
Serial_begin (9600); // Initialiser seriel kommunikation ved 9600 baudrate Serial_print_string ("Indtast kommando"); // udskriv en streng Serial_newline (); // gå til næste linje
Når vi går videre til det uendelige mens sløjfe, bruger vi funktionen Serial_available til at kontrollere, om der er indgående serielle data. Hvis ja, vi læser og gemmer det i en variabel kaldet ch og udskriver det samme ved hjælp af Serial_print . Så hvis den modtagne værdi er 0, slukker vi lysdioden, og hvis den er 1, tænder vi lysdioden
hvis (Serial_available ()) {Serial_print_string ("Du har trykket på:"); ch = Seriel_læs_char (); Serial_print_char (ch); Seriel_nyhed (); hvis (ch == '0') GPIO_WriteHigh (test_LED); // LED OFF, hvis (ch == '1') GPIO_WriteLow (test_LED); // LED tændt}
Med dette er programmeringen til denne tutorial fuldført, bare upload koden, der er angivet nederst på denne side, og du skal være i stand til at styre LED'en fra den serielle skærm.
Styring af LED fra seriel skærm
Når du har uploadet koden, kan du åbne enhver seriel skærm til 9600 baudhastigheder. Jeg har brugt Arduino seriel skærm for at gøre det nemt at bruge den. Tryk på reset-knappen, og meddelelsen “Indtast en kommando” vises. Hvis du derefter indtaster 1 og trykker på enter, skal den indbyggede led tændes, ligeledes for 0, den skal slukke.
Det komplette arbejde kan findes i den linkede video nederst på denne side. Hvis du har spørgsmål, skal du lade dem være i kommentarfeltet. Du kan også bruge vores fora til at stille andre tekniske spørgsmål.
STM8S serielt bibliotek dybere look
For de nysgerrige sind, der ønsker at vide, hvad der faktisk sker inde i STM8S103F3_Serial header-fil, læs videre….
Denne header-fil fungerer godt til programmering på begynderniveau, men hvis du bruger en anden version af STM8S-controlleren eller leder efter nogle avancerede indstillinger, kan du tilpasse denne header lidt eller arbejde direkte med SPL-biblioteker. Jeg skrev denne headerfil lige som en moden fra UART1 header-filen, forklaringen på min header-fil er som følger.
Læser et tegn fra Serial Monitor
Denne funktion hjælper med at læse et enkelt tegn, der er sendt til mikrocontrolleren fra den serielle skærm.
char Serial_read_char (ugyldigt) {while (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); returnere (UART1_ReceiveData8 ()); }
Vi venter, indtil RXE-flaget er INDSTILLET for at afslutte modtagelsen og rydder derefter flaget for at bekræfte modtagelsen. Endelig sender vi de modtagne 8-bit data som resultat af denne funktion.
Udskrivning af et tegn til seriel skærm
Denne funktion overfører et enkelt tegn fra en mikrocontroller til den serielle skærm.
ugyldigt Serial_print_char (char værdi) {UART1_SendData8 (værdi); mens (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // vent på afsendelse}
Funktionen skriver simpelthen 8-bit-værdien og venter til transmissionen er færdig ved at kontrollere UART1_FLAG_TXE til SET
Initialisering af seriel kommunikation
Denne funktion initialiserer seriel kommunikation med den krævede 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 (); // Deinitialiser UART-periferiudstyr 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); }
Bortset fra baudhastigheden er der andre parametre, der skal indstilles til seriel kommunikation, som antallet af databits, antallet af stopbits, paritet osv. Den mest almindelige (ligner Arduino) er 8-bit data med et stopbit og ingen paritet, og det vil derfor være standardindstillingen. Du kan ændre det, hvis det kræves.
Udskrivning af et heltal til seriel skærm
Hvis vi bruger en seriel skærm til fejlretning eller overvågning, vil vi måske gerne udskrive en variabel af typen int til den serielle skærm. Denne funktion gør netop det
ugyldigt Serial_print_int (int-nummer) // Funktion til at udskrive int-værdi til seriel skærm {char count = 0; char ciffer = ""; mens (nummer! = 0) // del int til char array {ciffer = antal% 10; tælle ++; tal = antal / 10; } mens (count! = 0) // print char array i den rigtige retning {UART1_SendData8 (ciffer + 0x30); mens (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // vent på at sende tæller--; }}
Det tager et helt tal og konverterer det til tegnarray i den første while-loop, derefter i den anden while-loop sender vi hvert af de tegn, der ligner vores print char-funktion.
Udskrivning af en ny linje
Dette er en simpel funktion til at udskrive en ny linje. Hexværdien for at gøre det er "0x0a", vi sender det bare ved hjælp af 8-bit transmissionskommandoen.
ugyldig Serial_newline (ugyldig) {UART1_SendData8 (0x0a); mens (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // vent på afsendelse}
Udskrivning af en streng til seriel skærm
En anden nyttig funktion er faktisk at udskrive strenge på den serielle skærm.
ugyldig Serial_print_string (char string) {. char i = 0; mens (streng! = 0x00) {UART1_SendData8 (streng); mens (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); i ++; }}
Igen konverterer denne funktion også strengen til char array og sender hvert tegn. Som vi ved, vil alle strenge ende være nul. Så vi er bare nødt til at fortsætte med at krydse og transmittere tegnene, indtil vi når nul 0x00.
Kontrollerer, om serielle data er tilgængelige til læsning
Denne funktion kontrollerer, om der er serielle data i bufferen klar til læsning.
bool Serial_available () {if (UART1_GetFlagStatus (UART1_FLAG_RXNE) == TRUE) returner TRUE; ellers returnere FALSK; }
Det kontrollerer for flag UART1_FLAG_RXNE , hvis det er sandt, returnerer det sandt, og hvis det ikke er det, returnerer det falsk.