Uart ng komunikasyon gamit ang pic microcontroller

Sa tutorial na ito natututunan namin na Paganahin ang pakikipag-usap ng UART sa PIC Microcontroller at kung paano maglipat ng data sa at mula sa iyong Computer. Sa ngayon, natakpan namin ang lahat ng pangunahing mga module tulad ng ADC, Timers, PWM at natutunan din kung paano i-interface ang mga LCD at 7-Segment na display. Ngayon, gagamitin namin ang aming sarili sa isang bagong tool sa komunikasyon na tinatawag na UART na malawakang ginagamit sa karamihan ng mga proyekto ng Microcontroller. Suriin dito ang aming kumpletong Mga Tutorial sa PIC Microcontroller gamit ang MPLAB at XC8.

Dito ginamit namin ang PIC16F877A MCU, mayroon itong modyul na tinatawag na "Addressable Universal Synchronous Asynchronous Receiver and Transmitter" na kilala bilang USART. Ang USART ay isang dalawang sistema ng komunikasyon sa kawad kung saan serbisye ang daloy ng data. Ang USART ay isa ring komunikasyon na full-duplex, nangangahulugang maaari kang magpadala at makatanggap ng data nang sabay-sabay na maaaring magamit upang makipag-usap sa mga peripheral na aparato, tulad ng mga CRT terminal at personal na computer.

Ang USART maaaring i-configure sa mga sumusunod na mode:

• Asynchronous (full-duplex)
• Kasabay - Master (kalahating duplex)
• Kasabay - Alipin (kalahating duplex)

Mayroon ding dalawang magkakaibang mga mode na katulad ng 8-bit at 9-bit mode, sa tutorial na ito mai-configure namin ang module ng USART upang gumana sa Asynchronous mode na may 8-bit na sistema ng komunikasyon, dahil ito ang pinaka ginagamit na uri ng komunikasyon. Dahil ito ay hindi magkakasabay hindi na kailangang magpadala ng signal ng orasan kasama ang mga signal ng data. Gumagamit ang UART ng dalawang linya ng data para sa pagpapadala (Tx) at pagtanggap ng (Rx) data. Ang lupa ng parehong mga aparato ay dapat ding gawing karaniwan. Ang ganitong uri ng komunikasyon ay hindi nagbabahagi ng isang karaniwang orasan kung kaya't ang isang karaniwang batayan ay napakahalaga para gumana ang system.

Sa pagtatapos ng tutorial na ito makakagawa ka ng isang komunikasyon (UART) sa pagitan ng iyong computer at ng iyong PIC Microcontroller at magpalipat-lipat ng isang LED sa board ng PIC mula sa iyong laptop. Ang katayuan ng LED ay ipapadala sa iyong laptop mula sa PIC MCU. Susubukan namin ang output gamit ang Hyper Terminal sa computer. Ang Detalyadong Video ay ibinibigay din sa pagtatapos ng tutorial na ito.

Mga Kinakailangan:

Hardware:

• PIC16F877A Perf Board
• Ang RS232 sa USB converter Module
• Computer
• PICkit 3 Programmer

Software:

• MPLABX
• HyperTerminal

Kinakailangan ang isang RS232 sa USB converter upang mai-convert ang serial data sa readable form ng computer. Mayroong mga paraan upang mag-disenyo ng iyong sariling circuit sa halip na bumili ng iyong sariling module ngunit hindi sila maaasahan dahil napapailalim sila ng ingay. Ang isa na ginagamit namin ay ipinapakita sa ibaba

Tandaan: Ang bawat RS232 sa USB converter ay mangangailangan ng isang espesyal na driver na mai-install; karamihan sa mga ito ay dapat na awtomatikong mai-install kaagad sa sandaling na-plug mo ang aparato. Ngunit, kung hindi ito nakakarelaks !!! Gamitin ang seksyon ng komento at tutulungan kita.

Programming PIC Microcontroller para sa Pakikipag-usap sa UART:

Tulad ng lahat ng mga module (ADC, Timer, PWM) dapat din nating simulan ang aming module ng USART ng aming PIC16F877A MCU at bilin ito na gumana sa UART 8-bit na mode ng komunikasyon. Tukuyin natin ang mga bit ng pagsasaayos at magsimula sa pag-andar ng pagsisimula ng UART.

Pinasimulan ang UART module ng PIC Microcontroller:

Ang mga pin ng Tx at Rx ay pisikal na naroroon sa mga pin RC6 at RC7. Ayon sa datasheet ideklara natin ang TX bilang output at RX bilang input.

// **** Ang pagtatakda ng mga I / O na pin para sa UART **** // TRISC6 = 0; // TX Pin itinakda bilang output TRISC7 = 1; // RX Pin set as input // ________ I / O pins set __________ //

Ngayon dapat itakda ang rate ng baud. Ang rate ng baud ay ang rate kung saan inililipat ang impormasyon sa isang channel ng komunikasyon. Maaari itong maging isa sa maraming mga default na halaga, ngunit sa program na ito ginagamit namin ang 9600 dahil ito ang pinaka ginagamit na rate ng baud.

/ ** Ipasimula ang rehistro ng SPBRG para sa kinakailangang rate ng baud at itakda ang BRGH para sa mabilis na baud_rate ** / SPBRG = ((_XTAL_FREQ / 16) / Baud_rate) - 1; BRGH = 1; // for high baud_rate // _________ End of baud_rate setting _________ //

Ang halaga ng baud rate ay dapat itakda gamit ang rehistro SPBRG, ang halaga ay nakasalalay sa halaga ng External na dalas ng kristal, ang mga formula upang makalkula ang rate ng baud ay ipinapakita sa ibaba:

SPBRG = ((_XTAL_FREQ / 16) / Baud_rate) - 1;

Ang bit BRGH ay dapat gawin mataas upang paganahin ang mataas na bilis ng rate ng bit. Ayon sa datasheet (pahina 13) palaging kapaki-pakinabang upang paganahin ito, dahil maaari nitong matanggal ang mga pagkakamali sa panahon ng komunikasyon.

Tulad ng sinabi nang mas maaga, nagtatrabaho kami sa Asynchronous mode, samakatuwid ang bit SYNC ay dapat gawing zero at bit SPEM ay dapat gawing mataas upang paganahin ang mga serial pin (TRISC6 at TRICSC5)

// **** Paganahin ang Asynchronous serial port ***** // SYNC = 0; // Asynchronous SPEN = 1; // Paganahin ang mga serial port pin // _____ Hindi pinagana ang serial port na _______ //

Sa tutorial na ito ay pareho kaming nagpapadala at tumatanggap ng data sa pagitan ng MCU at computer kaya kailangan naming paganahin ang parehong TXEN at CREN bits.

// ** Hinahanda ang paghahatid at pagtanggap ** // TXEN = 1; // paganahin ang paghahatid CREN = 1; // paganahin ang pagtanggap // __ UART module up at handa na para sa paghahatid at pagtanggap __ //

Ang mga bit TX9 at RX9 ay kailangang gawing zero upang mapatakbo namin sa 8-bit mode. Kung kailangang magkaroon ng mataas na pagiging maaasahan ay kailangang maitaguyod pagkatapos ay maaaring mapili ang 9-bit mode.

// ** Piliin ang 8-bit mode ** // TX9 = 0; // 8-bit na pagtanggap na napili RX9 = 0; // 8-bit na mode ng pagtanggap ang napili // __ Napili ang mode na 8-bit __ //

Sa pamamagitan nito nakumpleto namin ang aming pag-setup ng pagsisimula. at handa na para sa operasyon.

Paghahatid ng data gamit ang UART:

Ang pagpapaandar sa ibaba ay maaaring magamit upang magpadala ng data sa pamamagitan ng module na UART:

// ** Function to send one byte of date to UART ** // void UART_send_char (char bt) {habang (! TXIF); // hawakan ang programa hanggang sa ang buffer ng TX ay libre TXREG = bt; // Load ang transmitter buffer na may natanggap na halaga} // _____________ Katapusan ng pagpapaandar ________________ //

Sa sandaling nasimulan ang module kung anong halaga ang na-load sa rehistro na TXREG ay maililipat sa pamamagitan ng UART, ngunit maaaring mag-overlap ang paghahatid. Samakatuwid dapat naming laging suriin para sa Transmission Interrupt flag TXIF. Kung mababa lamang ang bit na ito maaari tayong magpatuloy sa susunod na bit para sa paghahatid pa dapat maghintay tayo para bumaba ang bandila na ito.

Gayunpaman, ang pag-andar sa itaas ay magagamit lamang upang magpadala lamang ng isang byte ng data, upang magpadala ng isang kumpletong isang string na dapat gamitin ang pagpapaandar sa ibaba

// ** Function to convert string to byte ** // void UART_send_string (char * st_pt) {habang (* st_pt) // kung mayroong isang char UART_send_char (* st_pt ++); // iproseso ito bilang isang byte data} // ___________ Pagtatapos ng pag-andar ______________ //

Ang pagpapaandar na ito ay maaaring maging medyo nakakalito upang maunawaan dahil mayroon itong mga payo, ngunit pinagkakatiwalaan ako ng mga payo ay kahanga-hanga at ginagawa nilang mas madali ang pag-program at ito ay isang magandang halimbawa ng pareho.

Tulad ng napapansin tumawag ulit kami sa UART_send_char () ngunit ngayon sa loob ng habang loop. Pinaghiwalay namin ang string sa mga indibidwal na character, sa tuwing tatawagin ang pagpapaandar na ito, isang char ang ipapadala sa TXREG at maililipat ito.

Tumatanggap ng data gamit ang UART:

Ang sumusunod na pagpapaandar ay maaaring magamit upang makatanggap ng data mula sa module ng UART:

// ** Function upang makakuha ng isang byte ng petsa mula sa UART ** // char UART_get_char () {kung (OERR) // suriin ang Error {CREN = 0; // If error -> I-reset ang CREN = 1; // Kung error -> I-reset} habang (! RCIF); // hawakan ang programa hanggang sa ang RX buffer ay libreng pagbalik RCREG; // tanggapin ang halaga at ipadala ito sa pangunahing pagpapaandar} // _____________ Pagtatapos ng pag-andar ________________ //

Kapag ang isang data ay natanggap ng module ng UART kinukuha ito at iniimbak sa rehistro ng RCREG. Maaari lamang naming ilipat ang halaga sa anumang variable at magamit ito. Ngunit maaaring mayroong magkakapatong na error o maaaring magpatuloy ang pagpapadala ng gumagamit ng data at hindi pa namin maililipat ang mga ito sa isang variable.

Sa kasong iyon ang Tanggap na flag bit RCIF ay dumating upang iligtas. Mababa ang bit na ito tuwing natanggap ang isang data at hindi pa napoproseso. Samakatuwid ginagamit namin ito sa habang loop na lumilikha ng isang pagkaantala upang hawakan ang programa hanggang makitungo kami sa halagang iyon.

Pag-toggle ng LED gamit ang UART module ng PIC Microcontroller:

Ngayon ay punta tayo sa huling bahagi ng Program, ang walang bisa na pangunahing (walang bisa) na pag- andar, kung saan magpapalipat- lipat kami ng isang LED sa pamamagitan ng computer gamit ang komunikasyon ng UART sa pagitan ng PIC at computer.

Kapag nagpapadala kami ng isang character na "1" (mula sa computer) ang LED ay bubuksan at ang mensahe ng katayuan na "RED LED -> ON" ay ibabalik (mula sa PIC MCU) sa computer.

Katulad nito ay nagpapadala kami ng isang character na "0" (mula sa computer) ang LED ay papatayin at ang mensahe ng katayuan na "RED LED -> OFF" ay ibabalik (mula sa PIC MCU) sa computer.

habang (1) // Walang katapusang loop {get_value = UART_get_char (); kung (get_value == '1') // Kung ang gumagamit ay nagpapadala ng "1" {RB3 = 1; // Turn on LED UART_send_string ("RED LED -> ON"); // Magpadala ng abiso sa computer UART_send_char (10); // ASCII halaga 10 ay ginagamit para sa pagbalik ng karwahe (upang mai-print sa bagong linya)} kung (get_value == '0') // Kung ang gumagamit ay nagpapadala ng "0" {RB3 = 0; // Patayin ang LED UART_send_string ("PULA -> OFF"); // Magpadala ng abiso sa computer UART_send_char (10); // ASCII na halaga 10 ay ginagamit para sa pagbalik ng karwahe (upang mai-print sa bagong linya)}}

Paggaya sa aming programa:

Tulad ng dati ay gayahin natin ang aming programa gamit ang proteus at alamin kung ito ay gumagana tulad ng inaasahan.

Ang imaheng nasa itaas ay nagpapakita ng isang virtual terminal kung saan ipinapakita nito ang isang maligayang mensahe at katayuan ng LED. Mapapansin ang Red Color LED na konektado sa pin RB3. Ang detalyadong pagtatrabaho ng simulation ay matatagpuan sa Video sa dulo.

Pag-setup ng Hardware at Pagsubok ng output:

Ang koneksyon para sa circuit na ito ay talagang simple, ginagamit namin ang aming PIC Perf board at ikonekta lamang ang tatlong mga wire sa RS232 sa USB converter at ikonekta ang module sa aming computer gamit ang USB data cable tulad ng ipinakita sa ibaba.

Susunod na nai-install namin ang Hyper Terminal Application (i-download ito mula rito) at buksan ito. Dapat itong magpakita ng katulad nito

Ngayon buksan ang Device Manager sa iyong computer at suriin kung aling Com port ang iyong module ay konektado, ang minahan ay konektado sa COM port 17 tulad ng ipinakita sa ibaba

Tandaan: Ang pangalan ng COM port para sa iyong module ay maaaring mabago alinsunod sa iyong vendor, hindi ito isang problema.

Bumalik ngayon sa Hyper Terminal Application at mag-navigate sa Set Up -> Port Configuration o pindutin ang Alt + C, upang makuha ang sumusunod na pop up box at piliin ang nais na port (COM17 sa aking kaso) sa pop-up window at mag-click sa kumonekta.

Kapag naitatag ang koneksyon i-on ang iyong PIC perf board at dapat mong makita ang isang bagay tulad nito sa ibaba

Panatilihin ang iyong cursor sa Command Window at ipasok ang 1 pagkatapos ay pindutin ang enter. Ang LED ay bubuksan at ang katayuan ay ipapakita tulad ng ipinakita sa ibaba.

Sa parehong paraan, panatilihin ang iyong cursor sa Command Window at ipasok ang 0 pagkatapos ay pindutin ang enter. Ang LED ay papatayin at ang katayuan ay ipapakita tulad ng ipinakita sa ibaba.

Sa ibaba ay binibigyan ang kumpletong code at detalyadong video, na ipapakita kung paano tumugon ang LED sa real time para sa "1" at "0".

Iyon lang guys, nag- interfaced kami ng PIC UART sa aming computer at inilipat ang data upang i-toggle ang LED gamit ang Hyper terminal. Inaasahan kong naintindihan mo, kung hindi, gamitin ang seksyon ng komento upang tanungin ang iyong query. Sa aming susunod na tutorial gagamitin ulit namin ang UART ngunit gawin itong mas kawili-wili sa pamamagitan ng paggamit ng isang module ng Bluetooth at i-broadcast ang data sa hangin.

Suriin din ang Komunikasyon ng UART sa pagitan ng Dalawang ATmega8 Microcontrollers at komunikasyon ng UART sa pagitan ng ATmega8 at Arduino Uno.