Uart-kommunikation med pic-mikrokontroller

I denna handledning lär vi oss att aktivera UART-kommunikation med PIC Microcontroller och hur man överför data till och från din dator. Hittills har vi täckt alla grundläggande moduler som ADC, Timers, PWM och har också lärt oss hur man gränssnitt LCD-skärmar och 7-segment skärmar. Nu kommer vi att utrusta oss med ett nytt kommunikationsverktyg som heter UART som används i stor utsträckning i de flesta av Microcontroller-projekten. Kolla här våra kompletta PIC Microcontroller-handledning med MPLAB och XC8.

Här har vi använt PIC16F877A MCU, den har en modul som heter “Adresserbar universal synkron asynkron mottagare och sändare”, kort känd som USART. USART är ett tvåledarkommunikationssystem där dataflödet seriellt. USART är också en full duplexkommunikation, vilket innebär att du kan skicka och ta emot data samtidigt som kan användas för att kommunicera med kringutrustning, till exempel CRT-terminaler och persondatorer.

Den USART kan konfigureras i följande lägen:

• Asynkron (full duplex)
• Synkron - Master (halv duplex)
• Synkron - Slav (halv duplex)

Det finns också två olika lägen, nämligen 8-bitars och 9-bitars-läge, i denna handledning konfigurerar vi USART-modulen för att fungera i asynkront läge med 8-bitars kommunikationssystem, eftersom det är den mest använda typen av kommunikation. Eftersom den är asynkron behöver den inte skicka klocksignal tillsammans med datasignalerna. UART använder två datalinjer för att skicka (Tx) och ta emot (Rx) data. Marken för båda enheterna bör också göras gemensam. Denna typ av kommunikation delar inte en gemensam klocka, därför är en gemensam grund mycket viktig för att systemet ska fungera.

I slutet av denna handledning kommer du att kunna skapa en kommunikation (UART) mellan din dator och din PIC Microcontroller och växla en lysdiod på PIC-kortet från din bärbara dator. Status för LED kommer att skickas till din bärbara dator från PIC MCU. Vi testar utdata med Hyper Terminal i datorn. Detaljerad video ges också i slutet av denna handledning.

Krav:

Hårdvara:

• PIC16F877A Perf Board
• RS232 till USB-omvandlarmodul
• Dator
• PICkit 3 Programmerare

Programvara:

• MPLABX
• HyperTerminal

En RS232 till USB-omvandlare krävs för att konvertera seriell data till datorläsbar form. Det finns sätt att designa din egen krets istället för att köpa din egen modul men de är inte tillförlitliga eftersom de utsätts för buller. Den som vi använder visas nedan

Obs! Varje RS232 till USB-omvandlare kräver att en speciell drivrutin installeras; de flesta av dem ska installeras automatiskt så snart du ansluter enheten. Men om det inte slappnar av !!! Använd kommentarsektionen så hjälper jag dig.

Programmering av PIC-mikrokontroller för UART-kommunikation:

Som alla moduler (ADC, Timer, PWM) bör vi också initiera vår USART-modul av vår PIC16F877A MCU och instruera den att arbeta i UART 8-bitars kommunikationsläge. Låt oss definiera konfigurationsbitarna och börja med UART-initialiseringsfunktionen.

Initiera UART-modulen i PIC Microcontroller:

Tx- och Rx-stiften är fysiskt närvarande vid stiften RC6 och RC7. Enligt databladet låt oss förklara TX som utdata och RX som ingång.

// **** Ställa in I / O-stift för UART **** // TRISC6 = 0; // TX-stift som utgång TRISC7 = 1; // RX-stift som ingång // ________ I / O-stift inställd __________ //

Nu måste överföringshastigheten ställas in. Överföringshastigheten är den hastighet med vilken information överförs i en kommunikationskanal. Detta kan vara ett av de många standardvärdena, men i det här programmet använder vi 9600 eftersom det är den mest använda baudhastigheten.

/ ** Initiera SPBRG-register för erforderlig baudhastighet och ställ in BRGH för snabb baudhastighet ** / SPBRG = ((_XTAL_FREQ / 16) / Baud_rate) - 1; BRGH = 1; // för hög baudhastighet // _________ Slut för inställning av baudhastighet _________ //

Värdet på överföringshastigheten måste ställas in med registret SPBRG, värdet beror på värdet på den externa kristallfrekvensen, formlerna för att beräkna överföringshastigheten visas nedan:

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

Biten BRGH måste göras hög för att möjliggöra höghastighetsbithastighet. Enligt databladet (sidan 13) är det alltid fördelaktigt att aktivera det, eftersom det kan eliminera fel under kommunikationen.

Som sagt tidigare kommer vi att arbeta i Asynkron läge, därför bör bit SYNC göras noll och bit SPEM måste göras högt för att möjliggöra seriella stift (TRISC6 och TRICSC5)

// **** Aktivera asynkron seriell port ******* // SYNC = 0; // Asynkron SPEN = 1; // Aktivera seriella portstift // _____ Asynkron seriell port aktiverad _______ //

I denna handledning kommer vi både att skicka och ta emot data mellan MCU och dator, därför måste vi aktivera både TXEN- och CREN-bitar.

// ** Låt oss förbereda för sändning och mottagning ** // TXEN = 1; // aktivera överföring CREN = 1; // aktivera mottagning // __ UART-modul upp och redo för överföring och mottagning __ //

De bitarna TX9 och RX9 måste göras noll så att vi verkar i 8-bitarsläge. Om det måste finnas hög tillförlitlighet måste upprättas kan 9-bitars läge väljas.

// ** Välj 8-bitars läge ** // TX9 = 0; // 8-bitars mottagning vald RX9 = 0; // 8-bitars mottagningsläge valt // __ 8-bitars läge valt __ //

Med detta slutför vi vår initialiseringsinställning. och är redo för drift.

Överföring av data med UART:

Funktionen nedan kan användas för att överföra data via UART-modulen:

// ** Funktion för att skicka en byte av datum till UART ** // ogiltig UART_send_char (char bt) {medan (! TXIF); // håll programmet tills TX-buffert är gratis TXREG = bt; // Ladda sändarbufferten med det mottagna värdet} // _____________ Funktionens slut ________________ //

När modulen har initierats överförs vilket värde som helst som laddas in i registret TXREG via UART, men överföringen kan överlappa varandra. Därför bör vi alltid kontrollera om transmissionsavbrottsflaggan TXIF. Endast om den här biten är låg kan vi fortsätta med nästa bit för överföring annars bör vi vänta på att den här flaggan blir låg.

Ovanstående funktion kan dock endast användas för att skicka bara en byte med data, för att skicka en komplett en sträng ska funktionen nedan användas

// ** Funktion för att konvertera sträng till byte ** // ogiltig UART_send_string (char * st_pt) {medan (* st_pt) // om det finns en char UART_send_char (* st_pt ++); // bearbeta det som byte-data} // ___________ Funktionens slut ______________ //

Den här funktionen kan vara lite knepig att förstå eftersom den har pekare, men lita på att pekare är underbara och de gör programmeringen enklare och detta är ett bra exempel på detsamma.

Som du märker har vi återigen ringt UART_send_char () men nu inne i while-slingan. Vi har delat strängen i enskilda tecken, varje gång den här funktionen anropas skickas en char till TXREG och den kommer att sändas.

Ta emot data med UART:

Följande funktion kan användas för att ta emot data från UART-modulen:

// ** Funktion för att få en byte av datum från UART ** // char UART_get_char () {if (OERR) // leta efter fel {CREN = 0; // Om fel -> Återställ CREN = 1; // Om fel -> Återställ} medan (! RCIF); // håll programmet tills RX-buffert är fri retur RCREG; // ta emot värdet och skicka det till huvudfunktionen} // _____________ Funktionens slut ________________ //

När en data tas emot av UART-modulen hämtar den den och lagrar den i RCREG- registret. Vi kan helt enkelt överföra värdet till valfri variabel och använda det. Men det kan finnas överlappningsfel eller så kan användaren skicka data kontinuerligt och vi har ännu inte överfört dem till en variabel.

I så fall kommer mottagningsflaggan RCIF att rädda. Denna bit kommer att bli låg när en data tas emot och ännu inte bearbetas. Därför använder vi den i stundslingan och skapar en fördröjning för att hålla programmet tills vi hanterar det värdet.

Växla LED med hjälp av UART-modulen i PIC Microcontroller:

Låt oss nu komma till den sista delen av programmet, den ogiltiga huvudfunktionen (ogiltig) , där vi kommer att växla en LED genom datorn med hjälp av UART-kommunikationen mellan PIC och dator.

När vi skickar tecknet "1" (från datorn) kommer lysdioden att slås PÅ och statusmeddelandet "RÖD LED -> PÅ" skickas tillbaka (från PIC MCU) till datorn.

På samma sätt skickar vi tecknet "0" (från datorn) kommer lampan att stängas av och statusmeddelandet "RÖD LED -> AV" kommer att skickas tillbaka (från PIC MCU) till datorn.

medan (1) // Oändlig slinga {get_value = UART_get_char (); if (get_value == '1') // Om användaren skickar "1" {RB3 = 1; // Slå på LED UART_send_string ("RÖD LED -> PÅ"); // Skicka meddelande till datorn UART_send_char (10); // ASCII-värde 10 används för vagnretur (för att skriva ut i ny rad)} if (get_value == '0') // Om användaren skickar "0" {RB3 = 0; // Stäng av LED UART_send_string ("RÖD -> AV"); // Skicka meddelande till datorn UART_send_char (10); // ASCII-värde 10 används för vagnretur (för att skriva ut på en ny rad)}}

Simulera vårt program:

Som vanligt låt oss simulera vårt program med proteus och ta reda på om det fungerar som förväntat.

Ovanstående bild visar en virtuell terminal i vilken den visar ett välkomstmeddelande och status för lysdioden. Den röda färg-lysdioden kan märkas att den är ansluten till stiftet RB3. Den detaljerade bearbetningen av simuleringen finns i videon i slutet.

Hårdvaruinstallation och testning av utdata:

Anslutningen för denna krets är väldigt enkel, vi använder vårt PIC Perf-kort och ansluter bara de tre ledningarna till RS232 till USB-omvandlare och ansluter modulen till vår dator med USB-datakabel som visas nedan.

Därefter installerar vi Hyper Terminal-applikationen (laddar ner den härifrån) och öppnar den. Det borde visa något liknande detta

Öppna nu Enhetshanteraren på din dator och kontrollera vilken Com-port din modul är ansluten till, min är ansluten till COM-port 17 som visas nedan

Obs! COM-portnamnet för din modul kan ändras beroende på din leverantör, det är inte ett problem.

Gå nu tillbaka till Hyper Terminal Application och navigera till Set Up -> Port Configuration eller tryck på Alt + C, för att få följande popup-ruta och välj önskad port (COM17 i mitt fall) i popup-fönstret och klicka på anslut.

När anslutningen är upprättad, sätt på PIC perf-kortet och du bör se något liknande nedan

Håll markören i kommandofönstret och ange 1 och tryck sedan på enter. LED-lampan tänds och statusen visas enligt nedan.

På samma sätt håller du markören i kommandofönstret och anger 0 och tryck sedan på enter. LED-lampan kommer att stängas av och statusen visas enligt nedan.

Nedan ges den fullständiga koden och den detaljerade videon, som visar hur lysdioden reagerar i realtid för "1" och "0".

Det är det killar, vi har kopplat PIC UART med vår dator och överfört data för att växla lysdioden med hjälp av Hyper terminal. Hoppas du förstod, om inte, använd kommentarsektionen för att ställa din fråga. I vår nästa handledning använder vi igen UART men gör det mer intressant genom att använda en Bluetooth-modul och sända data över luft.

Kontrollera också UART-kommunikation mellan två ATmega8-mikrokontroller och UART-kommunikation mellan ATmega8 och Arduino Uno.