- Zaporedna komunikacija na STM8S103F3P6
- Zaporedni komunikacijski zatiči na STM8S103F3P6
- Shema vezja za serijsko komunikacijo STM8S
- Nastavitev STVD za serijsko komunikacijo
- Programiranje STM8S za serijsko komunikacijo
- Upravljanje LED s serijskega monitorja
- Poglobljen videz serijske knjižnice STM8S
Programiranje novega mikrokrmilnika pogosto traja dlje časa zaradi novih načinov obdelave registrov in ne vedenja, kateri bit točno naredi kaj. Enako velja tudi za odpravljanje napak, ne da bi rekli. To je razlog, zakaj programerji v svoji kodi pogosto uporabljajo mejne točke in skozinjo prehajajo z razhroščevalnikom. Toda uporaba razhroščevalnika bo morda potrebovala dodatno strojno opremo (največkrat drago) in tudi dodaten čas. Kot oboževalec Arduina se lahko vsi strinjamo, da za odpravljanje napak uporabljamo serijske izjave za tiskanje in razumevanje naše kode zelo olajša življenje. Kaj lahko enako ponovimo na STM8 s kozmičnim prevajalnikom C in knjižnicami SPL? No, zelo je mogoče, in točno to bomo storili v tej tretji vadnici naše vadnice.Začetne korake preverite tudi s STM8S (vadnica 1) in STM8S GPIO control (vadnica 2), če ste tu povsem novi. Prav tako smo raziskali tudi možnost programiranja STM8S z Arduinom za hitre začetnike. Povedano, pojdimo v vadnico.
Zaporedna komunikacija na STM8S103F3P6
Iz podatkovnega lista STM8S103F3P6 lahko vidimo, da naš 8-bitni krmilnik podpira komunikacijo UART v številnih različnih načinih. Krmilnik ima tudi izhodni zatič za sinhrono UART komunikacijo in lahko podpira tudi SmarCard, IrDA in LIN. Toda v tej vadnici ne bomo raziskovali ničesar od tega, da bi se izognili kompleksnosti. Naučili se bomo preprostega branja in pisanja UART.
Vadnica ponuja tudi datoteko z glavo, imenovano stm8s103 serial.h, s pomočjo katere lahko izvajate preproste ukaze UART, kot so Serial start , Serial read, serial print itd. V bistvu boste lahko na serijski monitor tiskali char, int in string. in tudi preberite char s serijskega monitorja. Na koncu te vadnice boste lahko upravljali LED s serijskega monitorja in dobili povratne informacije o stanju LED. Zgoraj omenjena datoteka glave je odvisna od knjižnic SPL, zato se prepričajte, da ste upoštevali vadnico za začetek.
Zaporedni komunikacijski zatiči na STM8S103F3P6
Začnimo s strojne strani. Če na hitro pogledamo spodaj podane izrezke na mikrokrmilniku STM8S103F3P6, lahko ugotovimo, da bodo nožice 1, 2 in 3 uporabljene za komunikacijo UART.
Med tremi je pin 1 ura UART, ki se bo uporabljal samo med sinhrono UART komunikacijo, zato ga tukaj ne bomo potrebovali. Zatič 2 je zatič oddajnika UART, zatič 3 pa zatič sprejemnika UART. Upoštevajte, da se ti zatiči lahko podvojijo tudi kot analogni ali običajni GPIO zatič.
Shema vezja za serijsko komunikacijo STM8S
Shema vezij je tukaj zelo preprosta, za programiranje moramo povezati ST-LINK 2 in pretvornik USB v TTL za branje serijskih podatkov. Upoštevajte, da naš krmilnik STM8S deluje na 3.3V logični ravni, zato poskrbite, da vaš pretvornik USB v TTL podpira tudi 3.3V logiko. Celoten diagram vezja je prikazan spodaj.
Povezati morate ST-link v eno vrata USB, pretvornik USB v TTL pa v druga vrata USB vašega prenosnika, da lahko hkrati programirate in spremljate podatke. Povezava UART je preprosta, samo ozemljitev in Rx / Tx zatič mikrokrmilnika STM8S priključite na zatiče Tx / Rx pretvornika USB v TTL. Tu sem krmilnik napajal z Vcc zatičem ST-Link in pustil vss zatič pretvornika TTL odprt, to lahko storite tudi obratno. Na trgu obstaja veliko vrst pretvornikov USB v TTL, samo poskrbite, da lahko deluje na 3.3V logične signale in preprosto poiščite Tx, Rx in GND nožice ter vzpostavite zgoraj prikazano povezavo. Moja nastavitev strojne opreme je prikazana spodaj.
Za serijsko komunikacijo smo priložili glavo STM8S_Serial.h . S to glavo datoteke lahko izvajate preproste funkcije, podobne Arduinu, za serijsko komunikacijo.
Vse potrebne datoteke za ta projekt najdete na naši strani STM8S103F3_SPL Github. Če potrebujete samo to določeno datoteko z glavo, jo lahko prenesete s spodnje povezave.
Prenesite STM8S_Serial.h
Nastavitev STVD za serijsko komunikacijo
Za delo s serijsko komunikacijo bomo veliko uporabili s funkcijo datoteke glave STM8S_Serial.h, o kateri smo že govorili. Toda knjižnica ima druge odvisnosti, veliko datotek glave in C, povezane s SPL UART in Clock. Od tega trenutka je bolje, da v naš projekt vključite vse datoteke glave in C, da se izognete napaki pri prevajanju. Moje delovno okolje STVD je videti tako.
Prepričajte se, da ste vključili vse izvorne datoteke SPL in datoteko Include, kot smo to storili v naši prvi vadnici. Prav tako se prepričajte, da ste dodali datoteko glave stm8s103_serial.h . Za to glavo ni datoteke C.
Programiranje STM8S za serijsko komunikacijo
Ko je nastavitev projekta STVD pripravljena, lahko začnemo pisati kodo v datoteko main.c. Popolno kodo te vadnice najdete na dnu te strani. Razlaga je naslednja.
Prvi korak je vključitev zahtevanih datotek glave, tukaj sem dodal glavno datoteko glave (stm8s) in datoteko glave stm8s_103_serial, ki smo jo pravkar prenesli.
// Zahtevani naslovi #include "STM8S.h" #include "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3_SPL/blob/master/stm8s103%20Libraries/stm8s103_Serial.h
Nato z oblikovalskimi makri določimo vhodne in izhodne nožice. Tu bo nadzorovana samo vgrajena LED, ki je priključena na pin5 vhoda B, zato ji damo ime test_LED .
#define test_LED GPIOB, GPIO_PIN_5 // testna LED je priključena na PB5
Če nadaljujemo znotraj glavne funkcije, bomo pin določili kot izhod. Če ne poznate osnovnih funkcij GPIO, se vrnite na vadnico STM8S GPIO.
// Opredelitve zatičev // Razglasite PB5 kot push pull Izhodni zatič GPIO_Init (test_LED, GPIO_MODE_OUT_PP_LOW_SLOW);
Nato serijska vrata za komunikacijo inicializiramo s hitrostjo 9600 baudov. Za nove uporabnike je 9600 hitrost prenosa podatkovnih bitov med komunikacijo. Če tukaj nastavite 9600, morate enako nastaviti tudi v programski opremi za nadzor. Nato natisnemo tudi niz »Enter command« in se premaknemo v naslednjo vrstico.
Serial_begin (9600); // Inicializiramo serijsko komunikacijo s hitrostjo 9600 baudov Serial_print_string ("Enter command"); // natisne niz Serial_newline (); // premik na naslednjo vrstico
Če nadaljujemo do neskončne zanke while, s funkcijo Serial_available preverimo, ali obstajajo vhodni serijski podatki. Če je odgovor pritrdilen, ga preberemo in shranimo v spremenljivko, imenovano ch, in isto natisnemo tudi s pomočjo Serial_print . Potem, če je prejeta vrednost 0, bomo ugasnili LED, če je 1, pa LED
if (Serial_available ()) {Serial_print_string ("Pritisnili ste:"); ch = serijsko_brano_char (); Serial_print_char (ch); Serial_newline (); if (ch == '0') GPIO_WriteHigh (test_LED); // LED IZKLOPLJEN, če (ch == '1') GPIO_WriteLow (test_LED); // LED VKLOPLJENA}
S tem je programiranje te vadnice končano, samo naložite kodo, navedeno na dnu te strani, in lahko boste lahko upravljali LED s serijskega monitorja.
Upravljanje LED s serijskega monitorja
Ko naložite kodo, lahko odprete kateri koli serijski monitor s hitrostjo 9600 baudov. Za enostavno uporabo sem uporabil sam serijski monitor Arduino. Pritisnite gumb za ponastavitev in prikazalo se bo sporočilo »Vnesite ukaz«. Potem, če vnesete 1 in pritisnete enter, se mora vklopiti vgrajeni led, podobno za 0 pa se mora izklopiti.
Celotno delo najdete v videoposnetku na dnu te strani. Če imate kakršna koli vprašanja, jih pustite v oddelku za komentarje. Na naših forumih lahko objavite tudi druga tehnična vprašanja.
Poglobljen videz serijske knjižnice STM8S
Za tiste radovedneže, ki želijo vedeti, kaj se v resnici dogaja v zaglavni datoteki STM8S103F3_Serial, preberite….
Ta datoteka glave deluje dobro za programiranje na začetni ravni, če pa uporabljate drugo različico krmilnika STM8S ali iščete napredne možnosti, boste morda želeli nekoliko prilagoditi to glavo ali neposredno delati s knjižnicami SPL. To datoteko glave sem napisal ravno kot zrelo datoteko glave UART1, razlaga moje glave datoteke je naslednja.
Branje znaka iz serijskega monitorja
Ta funkcija pomaga prebrati en sam znak, ki je bil serijskemu monitorju poslan mikrokrmilniku.
char Serial_read_char (void) {while (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); vrnitev (UART1_ReceiveData8 ()); }
Počakamo, da se zastavica RXE nastavi, da zaključimo sprejem, nato pa počistimo zastavico, da potrdimo sprejem. Na koncu pošljemo prejete 8-bitne podatke kot rezultat te funkcije.
Tiskanje znaka na Serial Monitor
Ta funkcija prenaša en znak iz mikrokrmilnika na serijski monitor.
void Serial_print_char (vrednost znaka) {UART1_SendData8 (vrednost); medtem ko (UART1_GetFlagStatus (UART1_FLAG_TXE) == PONASTAVI); // čakamo na pošiljanje}
Funkcija preprosto zapiše 8-bitno vrednost in počaka, da se prenos konča, tako da preveri UART1_FLAG_TXE v SET
Inicializacija serijske komunikacije
Ta funkcija inicializira serijsko komunikacijo s potrebno hitrostjo prenosa.
void 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 (); // Deinitializirajte zunanje naprave 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); }
Poleg hitrosti prenosa je treba za serijsko komunikacijo nastaviti še druge parametre, na primer število podatkovnih bitov, število zaustavitvenih bitov, parnost itd. Najpogostejši (podoben Arduinu) so 8-bitni podatki z enim stop-bitom in brez paritete, zato bo to privzeta nastavitev. Po potrebi ga lahko spremenite.
Tiskanje celega števila na serijski monitor
Če za odpravljanje napak ali spremljanje uporabljamo serijski monitor, bomo morda večino časa želeli natisniti spremenljivko tipa int na serijski monitor. Ta funkcija počne točno to
void Serial_print_int (int številka) // Funkcija za tiskanje vrednosti int na serijski monitor {števec znakov = 0; char številka = ""; while (število! = 0) // razdelimo int na matriko char {številka = število% 10; štetje ++; število = število / 10; } while (count! = 0) // natisnemo matriko char v pravilno smer {UART1_SendData8 (številka + 0x30); medtem ko (UART1_GetFlagStatus (UART1_FLAG_TXE) == PONASTAVI); // čakamo na pošiljanje count--; }}
Vnese celoštevilčno vrednost in jo pretvori v matriko v prvi zanki while, nato pa v drugi zanki while pošljemo vsakega od znakov, podobnih naši funkciji print char.
Tiskanje nove vrstice
To je preprosta funkcija za tiskanje nove vrstice. Šestnajstiška vrednost za to je "0x0a", mi jo samo pošiljamo z 8-bitnim ukazom za prenos.
void Serial_newline (void) {UART1_SendData8 (0x0a); medtem ko (UART1_GetFlagStatus (UART1_FLAG_TXE) == PONASTAVI); // čakamo na pošiljanje}
Tiskanje niza na serijski monitor
Druga uporabna funkcija je dejansko tiskanje nizov na serijski monitor.
void Serial_print_string (niz char) {. char i = 0; medtem ko (niz! = 0x00) {UART1_SendData8 (niz); medtem ko (UART1_GetFlagStatus (UART1_FLAG_TXE) == PONASTAVI); i ++; }}
Tudi ta funkcija pretvori niz v matriko char in pošlje vsak znak. Kot vemo, bodo vsi nizi konec nični. Tako moramo samo še naprej prehajati in prenašati znake, dokler ne dosežemo nule 0x00.
Preverjanje, ali so serijski podatki na voljo za branje
Ta funkcija preveri, ali so v vmesniku vmesni podatki pripravljeni na branje.
bool Serial_available () {if (UART1_GetFlagStatus (UART1_FLAG_RXNE) == TRUE) vrne TRUE; sicer vrne FALSE; }
Preveri zastavico UART1_FLAG_RXNE , če je res, vrne true in če ni, vrne false.