Comunicare Uart folosind microcontroler pic

În acest tutorial învățăm să activăm comunicarea UART cu microcontrolerul PIC și cum să transferăm date către și de la computer. Până în prezent, am acoperit toate modulele de bază precum ADC, Timers, PWM și am învățat cum să interfațăm LCD-urile și afișajele cu 7 segmente. Acum, ne vom echipa cu un nou instrument de comunicare numit UART, utilizat pe scară largă în majoritatea proiectelor de microcontroler. Consultați aici Tutorialele noastre complete pentru microcontroler PIC folosind MPLAB și XC8.

Aici am folosit MCU PIC16F877A, are un modul numit „Receptor și emițător sincron asincron universal adresabil”, cunoscut în scurt timp ca USART. USART este un sistem de comunicații cu două fire în care datele curg în serie. USART este, de asemenea, o comunicație full-duplex, înseamnă că puteți trimite și primi date în același timp, care pot fi utilizate pentru a comunica cu dispozitive periferice, cum ar fi terminalele CRT și computerele personale.

USART poate fi configurată în următoarele moduri:

• Asincron (full-duplex)
• Sincron - Master (semi-duplex)
• Sincron - Slave (semi-duplex)

Există, de asemenea, două moduri diferite și anume modul pe 8 biți și pe 9 biți, în acest tutorial vom configura modulul USART pentru a funcționa în modul asincron cu sistem de comunicație pe 8 biți, deoarece este cel mai utilizat tip de comunicație. Deoarece este asincron, nu trebuie să trimită semnal de ceas împreună cu semnalele de date. UART utilizează două linii de date pentru trimiterea (Tx) și primirea (Rx) de date. Pământul ambelor dispozitive ar trebui, de asemenea, să devină comun. Acest tip de comunicare nu are un ceas comun, prin urmare un teren comun este foarte important pentru ca sistemul să funcționeze.

La sfârșitul acestui tutorial, veți putea stabili o comunicație (UART) între computer și microcontrolerul PIC și puteți comuta un LED de pe placa PIC de pe laptop. Starea LED-ului va fi trimisă laptopului dvs. de la PIC MCU. Vom testa ieșirea folosind Hyper Terminal în computer. Video detaliat este, de asemenea, oferit la sfârșitul acestui tutorial.

Cerințe:

Hardware:

• PIC16F877A Perf Board
• Modul convertor RS232 la USB
• Calculator
• Programator PICkit 3

Software:

• MPLABX
• HyperTerminal

Este necesar un convertor RS232 în USB pentru a converti datele seriale într-o formă lizibilă de computer. Există modalități de a vă proiecta propriul circuit în loc să cumpărați propriul modul, dar nu sunt fiabile, deoarece sunt supuse zgomotului. Cel pe care îl folosim este prezentat mai jos

Notă: Fiecare convertor RS232 în USB ar necesita instalarea unui driver special; cele mai multe dintre ele ar trebui instalate automat de îndată ce conectați dispozitivul. Dar, dacă nu se relaxează !!! Utilizați secțiunea de comentarii și vă voi ajuta.

Programarea microcontrolerului PIC pentru comunicarea UART:

La fel ca toate modulele (ADC, Timer, PWM), ar trebui să inițializăm modulul USART al MCU-ului nostru PIC16F877A și să-l instruim să funcționeze în modul de comunicare UART pe 8 biți. Să definim biții de configurare și să începem cu funcția de inițializare UART.

Inițializarea modulului UART al microcontrolerului PIC:

Pinii Tx și Rx sunt prezenți fizic la pinii RC6 și RC7. Conform fișei tehnice, să declarăm TX ca ieșire și RX ca intrare.

// **** Setarea pinilor I / O pentru UART **** // TRISC6 = 0; // TX Pin setat ca ieșire TRISC7 = 1; // RX Pin set ca intrare // ________ I / O pin set __________ //

Acum, viteza de transmisie trebuie setată. Rata de transmisie este rata la care informațiile sunt transferate într-un canal de comunicație. Aceasta poate fi una dintre multele valori implicite, dar în acest program folosim 9600, deoarece este cea mai utilizată rată de transmisie.

/ ** Inițializați registrul SPBRG pentru rata de transmisie necesară și setați BRGH pentru rata de transmisie rapidă ** / SPBRG = ((_XTAL_FREQ / 16) / rata de transmisie) - 1; BRGH = 1; // pentru rata baud mare // _________ Sfârșitul setării ratei baud _________ //

Valoarea vitezei baud trebuie setată utilizând registrul SPBRG, valoarea depinde de valoarea frecvenței cristalului extern, formulele pentru calcularea ratei baud sunt prezentate mai jos:

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

Bitul BRGH trebuie să fie ridicat pentru a permite rata de biți de mare viteză. Conform fișei tehnice (pagina 13), este întotdeauna avantajos să o activați, deoarece poate elimina erorile în timpul comunicării.

Așa cum am spus mai devreme, vom lucra în modul asincron, prin urmare bitul SYNC ar trebui să fie zero și bitul SPEM trebuie să fie ridicat pentru a activa pinii seriali (TRISC6 și TRICSC5)

// **** Activați portul serial asincron ******* // SYNC = 0; // SPEN asincron = 1; // Activează pinii portului serial // _____ Portul serial asincron activat _______ //

În acest tutorial vom trimite și primi date între MCU și computer, prin urmare trebuie să activăm atât biții TXEN, cât și CREN.

// ** Să ne pregătim pentru transmisie și recepție ** // TXEN = 1; // activați transmisia CREN = 1; // activați recepția // __ Modulul UART activat și gata pentru transmisie și recepție __ //

De biți TX9 și RX9 trebuie să fie zero, astfel încât să funcționeze în modul de 8-biți. Dacă trebuie să fie stabilită o fiabilitate ridicată, atunci poate fi selectat modul pe 9 biți.

// ** Selectați modul pe 8 biți ** // TX9 = 0; // recepție pe 8 biți selectată RX9 = 0; // Mod de recepție pe 8 biți selectat // __ Mod de 8 biți selectat __ //

Cu aceasta ne finalizăm configurarea de inițializare. și este gata de funcționare.

Transmiterea datelor folosind UART:

Funcția de mai jos poate fi utilizată pentru a transmite date prin modulul UART:

// ** Funcția de a trimite un octet de dată către UART ** // anulează UART_send_char (char bt) {while (! TXIF); // țineți programul până când bufferul TX este liber TXREG = bt; // Încărcați tamponul transmițătorului cu valoarea primită} // _____________ Sfârșitul funcției ________________ //

Odată ce modulul este inițializat, orice valoare este încărcată în registrul TXREG va fi transmisă prin UART, dar transmisia se poate suprapune. Prin urmare, ar trebui să verificăm întotdeauna semnalizatorul de întrerupere a transmisiei TXIF. Doar dacă acest bit este scăzut, putem continua cu următorul bit pentru transmisie, altfel ar trebui să așteptăm ca acest steag să scadă.

Cu toate acestea, funcția de mai sus poate fi utilizată numai pentru a trimite doar un octet de date, pentru a trimite un șir complet, trebuie folosită funcția de mai jos

// ** Funcția de a converti șirul în octet ** // void UART_send_string (char * st_pt) {while (* st_pt) // dacă există un char UART_send_char (* st_pt ++); // procesează-l ca date de octeți} // ___________ Sfârșitul funcției ______________ //

Această funcție ar putea fi un pic dificil de înțeles, deoarece are indicii, dar credeți-mă indicii sunt minunați și fac programarea mai ușoară și acesta este un bun exemplu al aceleiași.

După cum puteți observa, am apelat din nou la UART_send_char (), dar acum în bucla while. Am împărțit șirul în caractere individuale, de fiecare dată când se apelează această funcție, un caracter va fi trimis către TXREG și va fi transmis.

Primirea datelor folosind UART:

Următoarea funcție poate fi utilizată pentru a primi date de la modulul UART:

// ** Funcția pentru a obține un octet de dată de la UART ** // char UART_get_char () {if (OERR) // verificați eroarea {CREN = 0; // Dacă eroare -> Resetați CREN = 1; // Dacă eroare -> Resetare} în timp ce (! RCIF); // țineți programul până când bufferul RX este returnat gratuit RCREG; // primiți valoarea și trimiteți-o la funcția principală} // _____________ Sfârșitul funcției ________________ //

Atunci când o primire de date de către modulul UART le preluează și le stochează în registrul RCREG. Putem pur și simplu să transferăm valoarea către orice variabilă și să o folosim. Dar s-ar putea să existe o eroare de suprapunere sau utilizatorul ar putea trimite date în mod continuu și nu le-am transferat încă la o variabilă.

În acest caz, bitul de semnalizare Receive RCIF vine în salvare. Acest bit va scădea de fiecare dată când se primesc date și nu sunt încă procesate. Prin urmare, îl folosim în bucla while creând o întârziere pentru a menține programul până când ne ocupăm de acea valoare.

Comutare LED utilizând modulul UART al microcontrolerului PIC:

Acum, haideți să ajungem la ultima parte a programului, funcția void main (void) , unde vom comuta un LED prin computer folosind comunicația UART între PIC și computer.

Când trimitem un caracter „1” (de pe computer) LED-ul va fi aprins și mesajul de stare „RED LED -> ON” va fi trimis înapoi (de la PIC MCU) la computer.

În mod similar, trimitem un caracter „0” (de la computer), LED-ul va fi stins și mesajul de stare „RED LED -> OFF” va fi trimis înapoi (de la PIC MCU) la computer.

while (1) // Buclă infinită {get_value = UART_get_char (); if (get_value == '1') // Dacă utilizatorul trimite „1” {RB3 = 1; // Porniți LED-ul UART_send_string („LED ROȘU -> ON”); // Trimiteți o notificare către computer UART_send_char (10); // Valoarea ASCII 10 este utilizată pentru returnarea transportului (pentru a imprima în linie nouă)} dacă (get_value == '0') // Dacă utilizatorul trimite „0” {RB3 = 0; // Opriți LED-ul UART_send_string ("RED -> OFF"); // Trimiteți o notificare către computer UART_send_char (10); // Valoarea ASCII 10 este utilizată pentru returnarea transportului (pentru a imprima în linie nouă)}}

Simularea programului nostru:

Ca de obicei, să simulăm programul nostru folosind proteus și să aflăm dacă funcționează așa cum era de așteptat.

Imaginea de mai sus arată un terminal virtual în care arată un mesaj de bun venit și starea LED-ului. LED-ul de culoare roșie poate fi observat că este conectat la pinul RB3. Funcționarea detaliată a simulării poate fi găsită în videoclip la final.

Configurare hardware și testare ieșire:

Conexiunea pentru acest circuit este foarte simplă, folosim placa noastră PIC Perf și conectăm doar cele trei fire la convertorul RS232 la USB și conectăm modulul la computerul nostru folosind cablul de date USB, așa cum se arată mai jos.

Apoi instalăm aplicația Hyper Terminal (descărcați-o de aici) și o deschidem. Ar trebui să arate așa ceva

Acum deschideți Device Manager pe computer și verificați la ce port Com este conectat modulul dvs., al meu este conectat la portul COM 17 așa cum se arată mai jos

Notă: numele portului COM pentru modulul dvs. s-ar putea schimba în funcție de furnizorul dvs., nu este o problemă.

Acum reveniți la aplicația Hyper Terminal și navigați la Configurare -> Configurare port sau apăsați Alt + C, pentru a obține următoarea casetă pop-up și selectați portul dorit (COM17 în cazul meu) în fereastra pop-up și faceți clic pe conectare.

Odată ce conexiunea este stabilită, porniți placa de perfecționare PIC și ar trebui să vedeți așa ceva mai jos

Păstrați cursorul în fereastra de comandă și introduceți 1, apoi apăsați Enter. LED-ul va fi aprins și starea va fi afișată așa cum se arată mai jos.

În același mod, păstrați cursorul în fereastra de comandă și introduceți 0, apoi apăsați Enter. LED-ul va fi stins și starea va fi afișată așa cum se arată mai jos.

Mai jos sunt prezentate codul complet și videoclipul detaliat, care va arăta cum reacționează LED-ul în timp real pentru „1” și „0”.

Gata, băieți, am interfațat PIC UART cu computerul și am transferat datele pentru a comuta LED-ul folosind terminalul Hyper. Sper că ați înțeles, dacă nu, folosiți secțiunea de comentarii pentru a vă întreba. În următorul nostru tutorial vom folosi din nou UART, dar îl vom face mai interesant folosind un modul Bluetooth și vom transmite datele prin aer.

De asemenea, verificați comunicarea UART între două microcontrolere ATmega8 și comunicația UART între ATmega8 și Arduino Uno.