Uart-kommunikation ved hjælp af pic-mikrocontroller

I denne vejledning lærer vi at aktivere UART-kommunikation med PIC Microcontroller og hvordan man overfører data til og fra din computer. Indtil videre har vi dækket alle grundlæggende moduler som ADC, Timere, PWM og har også lært at interface LCD-skærme og 7-segmentskærme. Nu vil vi udstyre os selv med et nyt kommunikationsværktøj kaldet UART, som er meget udbredt i de fleste af Microcontroller-projekterne. Tjek her vores komplette PIC Microcontroller Tutorials ved hjælp af MPLAB og XC8.

Her har vi brugt PIC16F877A MCU, den har et modul kaldet “Adresserbar universal synkron asynkron modtager og sender” kort kendt som USART. USART er et to-leder kommunikationssystem, hvor dataene strømmer serielt. USART er også en full-duplex kommunikation, hvilket betyder, at du kan sende og modtage data på samme tid, som kan bruges til at kommunikere med perifere enheder, såsom CRT-terminaler og pc'er.

Den USART kan konfigureres i følgende tilstande:

• Asynkron (fuld dupleks)
• Synkron - Master (halv duplex)
• Synkron - Slave (halv duplex)

Der er også to forskellige tilstande, nemlig 8-bit og 9-bit-tilstand, i denne vejledning konfigurerer vi USART-modulet til at arbejde i asynkron tilstand med 8-bit kommunikationssystem, da det er den mest anvendte kommunikationstype. Da det er asynkront, behøver det ikke at sende ursignal sammen med datasignalerne. UART bruger to datalinjer til at sende (Tx) og modtage (Rx) data. Jorden på begge enheder skal også gøres fælles. Denne type kommunikation deler ikke et fælles ur, derfor er en fælles grund meget vigtig for, at systemet fungerer.

I slutningen af ​​denne tutorial kan du etablere en kommunikation (UART) mellem din computer og din PIC Microcontroller og skifte en LED på PIC-kortet fra din bærbare computer. LED-status sendes til din bærbare computer fra PIC MCU. Vi tester output ved hjælp af Hyper Terminal i computeren. Detaljeret video gives også i slutningen af ​​denne vejledning.

Krav:

Hardware:

• PIC16F877A Perf Board
• RS232 til USB konverter modul
• Computer
• PICkit 3 programmør

Software:

• MPLABX
• HyperTerminal

En RS232 til USB-konverter er påkrævet for at konvertere serielle data til computerlæsbar form. Der er måder at designe dit eget kredsløb i stedet for at købe dit eget modul, men de er ikke pålidelige, da de udsættes for støj. Den, som vi bruger, er vist nedenfor

Bemærk: Hver RS232 til USB-konverter kræver, at der installeres en speciel driver; de fleste af dem skal installeres automatisk, så snart du tilslutter enheden. Men hvis det ikke slapper af !!! Brug kommentarsektionen, så hjælper jeg dig.

Programmering af PIC-mikrocontroller til UART-kommunikation:

Som alle moduler (ADC, Timer, PWM) skal vi også initialisere vores USART-modul af vores PIC16F877A MCU og instruere det om at arbejde i UART 8-bit kommunikationstilstand. Lad os definere konfigurationsbits og starte med UART-initialiseringsfunktionen.

Initialisering af UART-modulet på PIC Microcontroller:

Tx- og Rx-stifterne er fysisk til stede ved stifterne RC6 og RC7. I henhold til databladet lad os erklære TX som output og RX som input.

// **** Indstilling af I / O-ben til UART **** // TRISC6 = 0; // TX Pin indstillet som output TRISC7 = 1; // RX-stift indstillet som input // ________ I / O-stifter indstillet __________ //

Nu skal baudhastigheden indstilles. Baudhastigheden er den hastighed, hvormed information overføres i en kommunikationskanal. Dette kan være en af ​​de mange standardværdier, men i dette program bruger vi 9600, da det er den mest anvendte baudrate.

/ ** Initialiser SPBRG-register for krævet baudrate og indstil BRGH til hurtig baud_rate ** / SPBRG = ((_XTAL_FREQ / 16) / Baud_rate) - 1; BRGH = 1; // for høj baud_rate // _________ Slut for indstilling af baud_rate _________ //

Værdien af ​​baudhastigheden skal indstilles ved hjælp af registeret SPBRG, værdien afhænger af værdien af ​​den eksterne krystalfrekvens, formlerne til beregning af baudhastigheden er vist nedenfor:

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

Bit BRGH skal gøres høj for at muliggøre bithastighed med høj hastighed. Ifølge databladet (side 13) er det altid en fordel at aktivere det, da det kan eliminere fejl under kommunikationen.

Som tidligere nævnt arbejder vi i asynkron tilstand, derfor skal bit SYNC gøres nul, og bit SPEM skal gøres højt for at muliggøre serielle ben (TRISC6 og TRICSC5)

// **** Aktivér asynkron seriel port ******* // SYNC = 0; // Asynkron SPEN = 1; // Aktiver stifter til seriel port // _____ Asynkron seriel port aktiveret _______ //

I denne vejledning sender vi og modtager data mellem MCU og computer, og derfor skal vi aktivere både TXEN- og CREN-bits.

// ** Lad os forberede os på transmission og modtagelse ** // TXEN = 1; // aktiver transmission CREN = 1; // aktiver modtagelse // __ UART-modul op og klar til transmission og modtagelse __ //

De bits TX9 og RX9 skal foretages nul, så vi opererer i 8-bit-tilstand. Hvis der skal være høj pålidelighed, skal der oprettes 9-bit-tilstand.

// ** Vælg 8-bit-tilstand ** // TX9 = 0; // 8-bit modtagelse valgt RX9 = 0; // 8-bit modtagefunktion valgt // __ 8-bit tilstand valgt __ //

Med dette fuldfører vi vores initialiseringsopsætning. og er klar til drift.

Overførsel af data ved hjælp af UART:

Nedenstående funktion kan bruges til at overføre data gennem UART-modulet:

// ** Funktion til at sende en byte af dato til UART ** // ugyldig UART_send_char (char bt) {mens (! TXIF); // hold programmet indtil TX-buffer er gratis TXREG = bt; // Indlæs senderbufferen med den modtagne værdi} // _____________ Funktionens afslutning ________________ //

Når modulet er initialiseret, vil den værdi, der er indlæst i registret, TXREG blive transmitteret via UART, men transmission overlapper muligvis. Derfor skal vi altid tjekke for Transmission Interrupt-flag TXIF. Kun hvis denne bit er lav, kan vi fortsætte med den næste bit til transmission ellers skal vi vente på, at dette flag bliver lavt.

Ovenstående funktion kan dog kun bruges til at sende kun en byte data, for at sende en komplet streng skal nedenstående funktion bruges

// ** Funktion til konvertering af streng til byte ** // ugyldig UART_send_string (char * st_pt) {mens (* st_pt) // hvis der er en char UART_send_char (* st_pt ++); // behandle det som en byte data} // ___________ Funktionens afslutning ______________ //

Denne funktion kan være lidt vanskelig at forstå, da den har pegepinde, men tro mig, pekere er vidunderlige, og de gør programmering lettere, og dette er et godt eksempel på det samme.

Som du kan bemærke, har vi igen kaldt UART_send_char (), men nu inde i while-løkken. Vi har delt strengen i individuelle tegn, hver gang denne funktion kaldes, sendes en tegn til TXREG, og den sendes.

Modtagelse af data ved hjælp af UART:

Følgende funktion kan bruges til at modtage data fra UART-modulet:

// ** Funktion for at få en byte af dato fra UART ** // char UART_get_char () {if (OERR) // check for Error {CREN = 0; // Hvis fejl -> Nulstil CREN = 1; // Hvis fejl -> Nulstil} mens (! RCIF); // hold programmet, indtil RX-buffer er gratis retur RCREG; // modtage værdien og sende den til hovedfunktionen} // _____________ Funktionens afslutning ________________ //

Når data modtages af UART-modulet, samler de dem op og gemmer dem i RCREG- registret. Vi kan simpelthen overføre værdien til enhver variabel og bruge den. Men der kan være en overlapningsfejl, eller brugeren sender muligvis data kontinuerligt, og vi har endnu ikke overført dem til en variabel.

I så fald kommer modtageflagbit RCIF til redning. Denne bit vil gå lavt, hver gang der modtages data og endnu ikke behandles. Derfor bruger vi det i while-loop, hvilket skaber en forsinkelse for at holde programmet, indtil vi håndterer den værdi.

Skift af LED ved hjælp af UART-modulet på PIC Microcontroller:

Lad os nu komme til den sidste del af programmet, den ugyldige hovedfunktion (ugyldig) , hvor vi skifter en LED gennem computeren ved hjælp af UART-kommunikationen mellem PIC og computer.

Når vi sender tegnet “1” (fra computeren), tændes lysdioden, og statusmeddelelsen “RØD LED -> TIL” sendes tilbage (fra PIC MCU) til computeren.

På samme måde sender vi tegnet "0" (fra computeren), LED'en slukkes, og statusmeddelelsen "RØD LED -> FRA" sendes tilbage (fra PIC MCU) til computeren.

mens (1) // Infinite loop {get_value = UART_get_char (); if (get_value == '1') // Hvis brugeren sender "1" {RB3 = 1; // Tænd LED UART_send_string ("RØD LED -> TIL"); // Send underretning til computeren UART_send_char (10); // ASCII-værdi 10 bruges til vognretur (til udskrivning i ny linje)} hvis (get_value == '0') // Hvis brugeren sender "0" {RB3 = 0; // Sluk for LED UART_send_string ("RØD -> FRA"); // Send underretning til computeren UART_send_char (10); // ASCII-værdi 10 bruges til vognretur (til udskrivning i ny linje)}}

Simulering af vores program:

Lad os som sædvanlig simulere vores program ved hjælp af proteus og finde ud af, om det fungerer som forventet.

Ovenstående billede viser en virtuel terminal, hvor den viser en velkomstbesked og status på LED'en. Den røde farve-LED kan bemærkes, at den er tilsluttet stiften RB3. Den detaljerede bearbejdning af simuleringen kan findes i videoen i slutningen.

Hardwareopsætning og test af output:

Forbindelsen til dette kredsløb er virkelig enkel, vi bruger vores PIC Perf-kort og forbinder bare de tre ledninger til RS232 til USB-konverter og forbinder modulet til vores computer ved hjælp af USB-datakabel som vist nedenfor.

Dernæst installerer vi Hyper Terminal-applikationen (download den herfra) og åbner den. Det skulle vise noget som dette

Åbn nu Enhedshåndtering på din computer og kontroller hvilken Com-port dit modul er tilsluttet, min er tilsluttet COM-port 17 som vist nedenfor

Bemærk: COM-portnavnet til dit modul kan ændre sig i henhold til din leverandør, det er ikke et problem.

Gå nu tilbage til Hyper Terminal Application og naviger til Opsætning -> Portkonfiguration eller tryk på Alt + C for at få følgende pop op-boks og vælg den ønskede port (COM17 i mit tilfælde) i pop op-vinduet, og klik på Opret forbindelse.

Når forbindelsen er oprettet, skal du tænde for dit PIC perf-kort, og du skal se noget lignende nedenfor

Hold markøren i kommandovinduet, og indtast 1, og tryk derefter på enter. LED'en tændes, og status vises som vist nedenfor.

På samme måde skal du holde markøren i kommandovinduet og indtaste 0 og derefter trykke på enter. LED'en slukkes, og status vises som vist nedenfor.

Nedenfor gives den komplette kode og detaljerede video, som viser, hvordan LED'en reagerer i realtid for "1" og "0".

Det er det gutter, vi har grænsefladen PIC UART med vores computer og overført dataene til at skifte LED ved hjælp af Hyper terminal. Håber du har forstået, hvis ikke, brug kommentarsektionen til at stille din forespørgsel. I vores næste tutorial bruger vi igen UART, men gør det mere interessant ved hjælp af et Bluetooth-modul og sender dataene over luft.

Kontroller også UART-kommunikation mellem to ATmega8-mikrocontrollere og UART-kommunikation mellem ATmega8 og Arduino Uno.