- Serial Communication sa STM8S103F3P6
- Mga Serial Communication Pins sa STM8S103F3P6
- Circuit Diagram para sa STM8S Serial Communication
- Pagse-set up ng STVD para sa Serial Communication
- Programming STM8S para sa Serial Communication
- Pagkontrol ng LED mula sa Serial monitor
- Mas malalim na pagtingin ng STM8S Serial Library
Ang pagprograma ng isang bagong microcontroller ay madalas na tumatagal ng isang mas mahabang oras dahil sa bagong pamamaraan ng paghawak ng rehistro at hindi alam kung ano ang eksaktong gawin. Ganun din sa pag-debug din nang hindi sinasabi. Ito ang dahilan kung bakit madalas na gumagamit ang mga programmer ng mga breakpoint sa kanilang code at hakbangin ito gamit ang isang debugger. Ngunit ang paggamit ng isang debugger ay maaaring mangailangan ng karagdagang hardware (karamihan sa mga oras na mahal) at din ng karagdagang oras. Ang pagiging isang fan fan ng Arduino, isang bagay na lahat tayo ay maaaring sumang-ayon ay ang paggamit ng mga serial print statement para sa pag-debug at pag-unawa sa aming code na ginagawang mas madali ang buhay. Ano ang maaari nating kopyahin ang pareho sa STM8s na may cosmic C compiler at SPL na aklatan? Sa gayon, posible, at iyon mismo ang gagawin natin sa pangatlong tutorial ng aming serye ng tutorial.Suriin mo rin ang pagsisimula sa STM8S (tutorial 1) at STM8S GPIO control (tutorial 2) kung ikaw ay ganap na bago dito. Gayundin, napagmasdan din namin ang posibilidad ng Programming STM8S kasama ang Arduino para sa mabilis na pagsisimula. Ang lahat ng nasasabi ay kumuha tayo sa tutorial.
Serial Communication sa STM8S103F3P6
Mula sa datasheet ng STM8S103F3P6, maaari naming makita na sinusuportahan ng aming 8-bit controller ang komunikasyon ng UART sa maraming iba't ibang mga mode. Ang controller ay mayroon ding isang output output pin para sa kasabay na komunikasyon sa UART at maaari ring suportahan ang SmarCard, IrDA, at LIN. Ngunit susuriin namin ang wala sa mga ito sa tutorial na ito upang lamang malayo sa pagiging kumplikado. Malalaman natin kung paano gumawa ng simpleng UART na magbasa at magsulat.
Nagbibigay din ang tutorial ng isang header file na tinatawag na stm8s103 serial.h gamit ang kung saan maaari kang magsagawa ng mga simpleng utos ng UART tulad ng Serial start, Serial read, serial print, atbp. Karaniwan, magagawa mong i-print ang char, int, at string sa serial monitor at basahin din ang char mula sa serial monitor. Sa pagtatapos ng tutorial na ito, makokontrol mo ang isang LED mula sa serial monitor at makakuha ng feedback tungkol sa katayuan ng LED. Ang file ng header na nabanggit sa itaas ay nakasalalay sa mga aklatan ng SPL, kaya tiyaking nasunod mo ang panimulang tutorial.
Mga Serial Communication Pins sa STM8S103F3P6
Magsimula tayo mula sa panig ng hardware. Ang isang mabilis na pagtingin sa mga pinout sa STM8S103F3P6 microcontroller na ibinigay sa ibaba, maaari nating makita na ang mga pin 1, 2, at 3 ay gagamitin para sa komunikasyon ng UART.
Kabilang sa tatlo, ang pin 1 ay ang pin na orasan ng UART na magagamit lamang sa kasabay na komunikasyon sa UART, kaya hindi na namin ito kakailanganin dito. Ang Pin 2 ay ang UART Transmitter pin at ang Pin 3 ay ang UART Receiver pin. Tandaan na ang mga pin na ito ay maaari ring i-double up bilang isang analog pin o normal na GPIO pin.
Circuit Diagram para sa STM8S Serial Communication
Ang circuit diagram ay napaka-simple dito, kailangan naming ikonekta ang aming ST-LINK 2 para sa programa at isang USB sa TTL converter para sa pagbabasa ng serial data. Tandaan na ang aming STM8S controller ay gumagana sa 3.3V antas ng lohika, kaya tiyaking sinusuportahan din ng iyong USB to TTL converter ang 3.3V na lohika. Ang kumpletong diagram ng circuit ay ipinapakita sa ibaba.
Kailangan mong ikonekta ang iyong ST-link sa isang USB port at USB sa TTL converter sa isa pang USB port ng iyong laptop, upang maaari mong parehong programa at subaybayan ang data nang sabay. Ang koneksyon sa UART ay simple, ikonekta lamang ang ground at Rx / Tx pin ng iyong STM8S microcontroller sa mga Tx / Rx pin ng USB sa TTL converter. Dito ko pinapagana ang controller gamit ang Vcc pin ng ST-Link at naiwan ang vss pin ng TTL converter na bukas, magagawa mo rin ito sa ibang paraan. Maraming uri ng USB to TTL converter sa merkado siguraduhin lamang na maaari itong gumana sa mga signal ng 3.3V Logic at simpleng hitsura para sa mga Tx, Rx, at GND na pin at gawin ang koneksyon na ipinakita sa itaas. Ang aking pag-set up ng hardware ay ipinapakita sa ibaba.
Upang makagawa ng isang serial na paraan ng komunikasyon, ibinigay namin ang file na header ng STM8S_Serial.h . Gamit ang header file na ito, maaari kang magsagawa ng simpleng Arduino tulad ng mga pagpapaandar para sa serial na komunikasyon.
Mahahanap mo ang lahat ng kinakailangang mga file para sa proyektong ito sa aming pahina ng STM8S103F3_SPL Github. Kung kakailanganin mo lamang ang partikular na file ng header, maaari mo itong i-download mula sa link sa ibaba.
I-download ang STM8S_Serial.h
Pagse-set up ng STVD para sa Serial Communication
Upang gumana sa serial na komunikasyon, gagamit kami ng maraming gamit ang pagpapaandar ng header file ng STM8S_Serial.h na tinalakay namin kanina. Ngunit ang library ay may iba pang mga dependency, marami sa SPL UART at Clock na may kaugnayan sa header at C file. Kaya't mula sa puntong ito, mas mahusay na isama ang lahat ng mga file ng header at C sa aming proyekto upang maiwasan ang isang error sa pagtitipon. Ganito ang hitsura ng aking kapaligiran sa trabaho sa STVD.
Tiyaking isinama mo ang lahat ng mga file ng mapagkukunan ng SPL at Isama ang file tulad ng ginawa namin sa aming unang tutorial. At tiyaking dinagdagan mo ang stm8s103_serial.h header file. Walang C file para sa header na ito.
Programming STM8S para sa Serial Communication
Kapag handa na ang pag-set up ng proyekto ng STVD, maaari naming simulang isulat ang aming code sa main.c file. Ang kumpletong code para sa tutorial na ito ay matatagpuan sa ilalim ng pahinang ito. Ang paliwanag ay ang mga sumusunod.
Ang unang hakbang ay upang isama ang kinakailangang mga file ng header, narito ko naidagdag ang pangunahing file ng header (stm8s) at ang stm8s_103_serial header file na na-download lamang namin.
// Required Headers # isama ang "STM8S.h" #include "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3_SPL/blob/master/stm8s103%20Libraries/stm8s103_Serial.h
Susunod, gumagamit kami ng mga macros na disenyo upang tukuyin ang mga input at output pin. Dito ay makokontrol lamang ang on-board LED na konektado sa pin5 ng port B, kaya binibigyan namin ito ng isang pangalan bilang test_LED .
#define test_LED GPIOB, GPIO_PIN_5 // test LED ay konektado sa PB5
Ang paglipat sa loob ng pangunahing pag-andar, tutukuyin namin ang pin bilang isang output. Kung hindi ka pamilyar sa pangunahing mga pagpapaandar ng GPIO bumalik sa tutorial na STM8S GPIO.
// Pin defanitions // Declare PB5 as push pull Output pin GPIO_Init (test_LED, GPIO_MODE_OUT_PP_LOW_SLOW);
Pagkatapos ay pinasimulan namin ang aming serial port ng komunikasyon sa 9600 baud rate. Para sa mga bago, 9600 ang rate ng bilis ng paglipat ng data bits habang nasa komunikasyon. Kung magtakda ka ng 9600 dito, kailangan mo ring itakda ang pareho sa monitoring software. Pagkatapos ay nag-print din kami ng isang string na "Enter command" at magpatuloy sa susunod na linya.
Serial_begin (9600); // Initialize Serial komunikasyon sa 9600 baud rate Serial_print_string ("Enter command"); // print a string Serial_newline (); // lumipat sa susunod na linya
Ang paglipat sa walang katapusan habang loop, ginagamit namin ang Serial_available function upang suriin kung mayroong anumang papasok na serial data. Kung oo, basahin at i-save namin ito sa isang variable na tinatawag na ch at i-print din ang pareho gamit ang Serial_print . Pagkatapos kung ang natanggap na halaga ay 0, papatayin namin ang LED at kung ito ay 1, bubuksan namin ang LED
kung (Serial_available ()) {Serial_print_string ("Pinindot mo:"); ch = Serial_read_char (); Serial_print_char (ch); Serial_newline (); kung (ch == '0') GPIO_WriteHigh (test_LED); // LED OFF kung (ch == '1') GPIO_WriteLow (test_LED); //HUMANTONG SA }
Sa pamamagitan nito, kumpleto ang programa para sa tutorial na ito, i-upload lamang ang code na ibinigay sa ilalim ng pahinang ito at dapat mong makontrol ang LED mula sa serial monitor.
Pagkontrol ng LED mula sa Serial monitor
Kapag na-upload mo ang code, maaari mong buksan ang anumang serial monitor sa 9600 baud rate. Ginamit ko ang Arduino serial monitor mismo para sa kadalian ng paggamit nito. Pindutin ang pindutan ng pag-reset at dapat mong makita ang mensahe na "Magpasok ng isang utos". Pagkatapos kung ipasok mo ang 1 at pindutin ang enter, ang on-board led ay dapat na i-on, katulad para sa 0, dapat itong patayin.
Ang kumpletong pagtatrabaho ay matatagpuan sa video na naka-link sa ilalim ng pahinang ito. Kung mayroon kang anumang mga katanungan, mangyaring iwanan ang mga ito sa seksyon ng komento. Maaari mo ring gamitin ang aming mga forum upang mag-post ng iba pang mga teknikal na katanungan.
Mas malalim na pagtingin ng STM8S Serial Library
Para sa mga nakakaisip na isip na nais malaman kung ano talaga ang nangyayari sa loob ng STM8S103F3_Serial header file na nabasa sa….
Ang header file na ito ay gumagana nang maayos para sa pag-program sa antas ng nagsisimula, ngunit kung gumagamit ka ng ibang bersyon ng STM8S controller o naghahanap ng ilang mga advanced na pagpipilian, baka gusto mong sabunutan nang kaunti ang header na ito o direktang gumana sa mga aklatan ng SPL. Sinulat ko ang file ng header na ito tulad ng isang hinog mula sa UART1 header file, ang paliwanag ng aking header file ay ang mga sumusunod.
Nagbabasa ng character mula sa Serial Monitor
Ang pagpapaandar na ito ay makakatulong upang mabasa ang isang solong character na naipadala sa microcontroller mula sa serial monitor.
char Serial_read_char (void) {habang (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); bumalik (UART1_ReceiveData8 ()); }
Naghihintay kami hanggang sa maitakda ang watawat ng RXE upang makumpleto ang pagtanggap at pagkatapos ay i-clear ang bandila upang kilalanin ang pagtanggap. Panghuli, ipinapadala namin ang natanggap na 8-bit na data bilang resulta ng pagpapaandar na ito.
Pag-print ng isang character sa Serial Monitor
Ang pagpapaandar na ito ay nagpapadala ng isang solong character mula sa isang microcontroller sa serial monitor.
walang bisa Serial_print_char (char halaga) {UART1_SendData8 (halaga); habang (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // maghintay para sa pagpapadala}
Sinusulat lamang ng pagpapaandar ang 8-bit na halaga at naghihintay hanggang sa makumpleto ang paghahatid sa pamamagitan ng pag-check sa UART1_FLAG_TXE upang itakda
Pinasimulan ang Serial Communication
Ang pagpapaandar na ito ay nagpapasimula sa serial na komunikasyon sa kinakailangang rate ng baud.
walang bisa 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 (); // Deinitialize UART peripherals 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 (I-ENABLE); }
Bukod sa rate ng baud, may iba pang mga parameter na kailangang maitakda para sa serial na komunikasyon, tulad ng bilang ng mga data bit, bilang ng mga stop bits, pagkakapareho, atbp. Ang pinaka-karaniwang isa (katulad ng Arduino) ay ang 8-bit na data na may isang stop bit at walang pagkakapantay-pantay at samakatuwid ay ang magiging default na setting. Maaari mo itong palitan kung kinakailangan.
Pagpi-print ng isang Integer sa Serial Monitor
Karamihan sa oras, kung gumagamit kami ng isang serial monitor para sa pag-debug o pagsubaybay, baka gusto naming mag-print ng isang variable ng uri int sa serial monitor. Ang pag-andar na ito ay eksaktong ginagawa
void Serial_print_int (int number) // Funtion upang mai-print ang int halaga sa serial monitor {char count = 0; char digit = ""; habang (number! = 0) // hatiin ang int to char array {digit = number% 10; bilangin ++; numero = numero / 10; } habang (count! = 0) // print char array sa tamang direksyon {UART1_SendData8 (digit + 0x30); habang (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // maghintay para sa pagpapadala ng bilang--; }}
Tumatagal ito sa isang halaga ng integer at binago ito sa array ng character sa una habang loop, pagkatapos sa pangalawa habang loop, magpapadala kami ng bawat isa sa mga character na katulad ng aming print char function.
Pagpi-print ng isang bagong linya
Ito ay isang simpleng pag-andar upang mag-print ng isang bagong linya. Ang hexvalue upang gawin iyon ay "0x0a", ipinapadala lamang namin ito sa kabuuan gamit ang 8-bit transmit command.
walang bisa Serial_newline (walang bisa) {UART1_SendData8 (0x0a); habang (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // maghintay para sa pagpapadala}
Pag-print ng isang string sa serial monitor
Ang isa pang kapaki-pakinabang na pagpapaandar ay ang tunay na pag-print ng mga string sa serial monitor.
walang bisa Serial_print_string (char string) {. char i = 0; habang (string! = 0x00) {UART1_SendData8 (string); habang (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); ako ++; }}
Muli, ang pagpapaandar na ito ay nagko-convert din ng string sa char array at nagpapadala ng bawat character. Tulad ng alam nating ang lahat ng mga strings ay magtatapos ay null. Kaya't patuloy lamang tayong dumaan at mailipat ang mga character hanggang sa maabot natin ang null 0x00.
Sinusuri kung magagamit ang serial data upang mabasa
Sinusuri ng pagpapaandar na ito kung mayroong anumang serial data sa buffer na handa nang basahin.
bool Serial_available () {kung (UART1_GetFlagStatus (UART1_FLAG_RXNE) == TRUE) ibalik ang TUNAY; kung hindi man ay ibalik ang MALI; }
Sinusuri nito ang watawat na UART1_FLAG_RXNE , kung totoo ito, nagbabalik ito ng totoo at kung hindi, nagbabalik ito ng hindi totoo.