Uart-kommunikasjon ved hjelp av pic-mikrokontroller

I denne opplæringen lærer vi å aktivere UART-kommunikasjon med PIC Microcontroller og hvordan du overfører data til og fra datamaskinen din. Så langt har vi dekket alle grunnleggende moduler som ADC, Timers, PWM, og har også lært hvordan vi kan grensesnitt LCD-skjermer og 7-segment skjermer. Nå vil vi utstyre oss selv med et nytt kommunikasjonsverktøy kalt UART som er mye brukt i de fleste av Microcontroller-prosjektene. Sjekk her våre komplette PIC Microcontroller-opplæringsprogrammer ved bruk av MPLAB og XC8.

Her har vi brukt PIC16F877A MCU, den har en modul kalt “Addressable Universal Synchronous Asynchronous Receiver and Transmitter” kort kjent som USART. USART er et to-leders kommunikasjonssystem der dataene flyter serielt. USART er også en tosidig kommunikasjon, noe som betyr at du kan sende og motta data samtidig som kan brukes til å kommunisere med eksterne enheter, for eksempel CRT-terminaler og PC-er.

Den USART kan konfigureres i de følgende modi:

• Asynkron (full dupleks)
• Synkron - Master (halv dupleks)
• Synkron - Slave (halv dupleks)

Det er også to forskjellige moduser, nemlig 8-bit og 9-bit-modus, i denne opplæringen vil vi konfigurere USART-modulen til å fungere i asynkron modus med 8-bit kommunikasjonssystem, siden det er den mest brukte kommunikasjonstypen. Siden det er asynkront, trenger det ikke å sende klokkesignal sammen med datasignalene. UART bruker to datalinjer for å sende (Tx) og motta (Rx) data. Bakken til begge enhetene bør også gjøres vanlig. Denne typen kommunikasjon deler ikke en felles klokke, og derfor er et felles grunnlag veldig viktig for at systemet skal fungere.

På slutten av denne opplæringen vil du kunne etablere en kommunikasjon (UART) mellom datamaskinen din og PIC-mikrokontrolleren din og bytte en LED på PIC-kortet fra den bærbare datamaskinen. Statusen til LED-en vil bli sendt til den bærbare datamaskinen din fra PIC MCU. Vi vil teste utdataene ved hjelp av Hyper Terminal i datamaskinen. Detaljert video er også gitt på slutten av denne opplæringen.

Krav:

Maskinvare:

• PIC16F877A Perf Board
• RS232 til USB-omformermodul
• Datamaskin
• PICkit 3 programmerer

Programvare:

• MPLABX
• HyperTerminal

En RS232 til USB-omformer er nødvendig for å konvertere serielle data til datamaskinnelig lesbar form. Det er måter å designe din egen krets i stedet for å kjøpe din egen modul, men de er ikke pålitelige siden de utsettes for støy. Den vi bruker er vist nedenfor

Merk: Hver RS232 til USB-omformer krever at det installeres en spesiell driver; de fleste av dem skal installeres automatisk så snart du kobler til enheten. Men hvis det ikke slapper av !!! Bruk kommentarseksjonen, så hjelper jeg deg.

Programmering av PIC-mikrokontroller for UART-kommunikasjon:

Som alle moduler (ADC, Timer, PWM), bør vi også initialisere USART-modulen vår PIC16F877A MCU og instruere den til å fungere i UART 8-bit kommunikasjonsmodus. La oss definere konfigurasjonsbitene og starte med UART-initialiseringsfunksjonen.

Initialisere UART-modulen til PIC Microcontroller:

Tx- og Rx-pinnene er fysisk til stede ved pinnene RC6 og RC7. I følge databladet, la oss erklære TX som utgang og RX som inngang.

// **** Innstilling av I / O-pinner for UART **** // TRISC6 = 0; // TX Pin satt som utgang TRISC7 = 1; // RX-pinne satt som inngang // ________ I / O-pinner satt __________ //

Nå må baudrate innstilles. Baudhastigheten er hastigheten som informasjon overføres i en kommunikasjonskanal. Dette kan være en av de mange standardverdiene, men i dette programmet bruker vi 9600 siden det er den mest brukte overføringshastigheten.

/ ** Initialiser SPBRG-register for ønsket baudrate og sett BRGH for rask baud_rate ** / SPBRG = ((_XTAL_FREQ / 16) / Baud_rate) - 1; BRGH = 1; // for høy baudhastighet // _________ Slutt på baud_rate innstilling _________ //

Verdien av overføringshastigheten må stilles inn ved hjelp av registeret SPBRG, verdien avhenger av verdien av den eksterne krystallfrekvensen, formlene for å beregne overføringshastigheten er vist nedenfor:

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

Biten BRGH må gjøres høy for å muliggjøre bithastighet med høy hastighet. I følge databladet (side 13) er det alltid fordelaktig å aktivere det, da det kan eliminere feil under kommunikasjonen.

Som sagt tidligere, vil vi jobbe i asynkron modus, derfor bør bit SYNC gjøres null og bit SPEM må gjøres høyt for å muliggjøre serielle pinner (TRISC6 og TRICSC5)

// **** Aktiver asynkron seriell port ******* // SYNC = 0; // Asynkron SPEN = 1; // Aktiver serielle portpinner // _____ Asynkron seriell port aktivert _______ //

I denne opplæringen vil vi både sende og motta data mellom MCU og datamaskin, og derfor må vi aktivere både TXEN- og CREN-biter.

// ** La oss forberede overføring og mottak ** // TXEN = 1; // aktivere overføring CREN = 1; // aktivere mottak // __ UART-modul opp og klar for overføring og mottak __ //

De bits TX9 og RX9 måtte bli gjort lik null, slik at vi opererer i 8-bits modus. Hvis det må opprettes høy pålitelighet, kan 9-biters modus velges.

// ** Velg 8-bits modus ** // TX9 = 0; // 8-bit mottak valgt RX9 = 0; // 8-bit mottaksmodus valgt // __ 8-bits modus valgt __ //

Med dette fullfører vi initialiseringsoppsettet. og er klar til drift.

Overføring av data ved bruk av UART:

Funksjonen nedenfor kan brukes til å overføre data gjennom UART-modulen:

// ** Funksjon for å sende en byte av dato til UART ** // ugyldig UART_send_char (char bt) {mens (! TXIF); // hold programmet til TX-bufferen er gratis TXREG = bt; // Legg senderbufferen med den mottatte verdien} // _____________ Funksjonens slutt ________________ //

Når modulen er initialisert, vil uansett hvilken verdi som er lastet inn i registeret TXREG overføres gjennom UART, men overføring kan overlappe hverandre. Derfor bør vi alltid sjekke for Transmission Interrupt-flagget TXIF. Bare hvis denne biten er lav, kan vi fortsette med neste bit for overføring, ellers bør vi vente på at dette flagget blir lavt.

Ovennevnte funksjon kan imidlertid bare brukes til å sende bare en byte med data, for å sende en komplett streng skal funksjonen nedenfor brukes

// ** Funksjon for å konvertere streng til byte ** // ugyldig UART_send_string (char * st_pt) {mens (* st_pt) // hvis det er en char UART_send_char (* st_pt ++); // behandle det som byte-data} // ___________ Funksjonsslutt ______________ //

Denne funksjonen kan være litt vanskelig å forstå siden den har pekere, men stol på meg pekere er fantastiske, og de gjør programmering enklere, og dette er et godt eksempel på det samme.

Som du kan legge merke til har vi igjen kalt UART_send_char (), men nå inne i mens løkken. Vi har delt strengen i individuelle tegn, hver gang denne funksjonen kalles, vil en røye sendes til TXREG og den vil bli sendt.

Motta data ved hjelp av UART:

Følgende funksjon kan brukes til å motta data fra UART-modulen:

// ** Funksjon for å få en byte av dato fra UART ** // char UART_get_char () {if (OERR) // se etter feil {CREN = 0; // Hvis feil -> Tilbakestill CREN = 1; // Hvis feil -> Tilbakestill} mens (! RCIF); // hold programmet til RX buffer er gratis retur RCREG; // motta verdien og sende den til hovedfunksjonen} // _____________ Funksjonens slutt ________________ //

Når en data mottas av UART-modulen, plukker den opp og lagrer den i RCREG- registeret. Vi kan ganske enkelt overføre verdien til hvilken som helst variabel og bruke den. Men det kan være overlappingsfeil, eller brukeren kan sende data kontinuerlig, og vi har ennå ikke overført dem til en variabel.

I så fall kommer mottaksflaggen RCIF til redning. Denne biten vil gå lavt når data mottas og ennå ikke er behandlet. Derfor bruker vi den i loop mens skaper en forsinkelse for å holde programmet til vi takler den verdien.

Veksle LED ved bruk av UART-modulen til PIC Microcontroller:

La oss nå komme til den siste delen av programmet, den ugyldige hovedfunksjonen (ugyldig) , der vi vil bytte en LED gjennom datamaskinen ved hjelp av UART-kommunikasjonen mellom PIC og datamaskin.

Når vi sender tegnet “1” (fra datamaskinen) vil LED-lampen slås PÅ og statusmeldingen “RED LED -> ON” vil bli sendt tilbake (fra PIC MCU) til datamaskinen.

På samme måte sender vi tegnet "0" (fra datamaskinen). LED-lampen vil bli slått AV og statusmeldingen "RØD LED -> AV" vil bli sendt tilbake (fra PIC MCU) til datamaskinen.

mens (1) // Infinite loop {get_value = UART_get_char (); if (get_value == '1') // Hvis brukeren sender "1" {RB3 = 1; // Slå på LED UART_send_string ("RØD LED -> PÅ"); // Send varsel til datamaskinen UART_send_char (10); // ASCII-verdi 10 brukes til vognretur (for å skrive ut i ny linje)} hvis (get_value == '0') // Hvis brukeren sender "0" {RB3 = 0; // Slå av LED UART_send_string ("RØD -> AV"); // Send varsel til datamaskinen UART_send_char (10); // ASCII-verdi 10 brukes for vognretur (for å skrive ut i ny linje)}}

Simulering av programmet vårt:

Som vanlig, la oss simulere programmet vårt ved hjelp av proteus og finne ut om det fungerer som forventet.

Ovennevnte bilde viser en virtuell terminal der den viser en velkomstmelding og status for LED-lampen. Den røde fargedioden kan merkes å være koblet til pinnen RB3. Den detaljerte bearbeidingen av simuleringen finner du i videoen på slutten.

Maskinvareoppsett og testing av utdata:

Tilkoblingen for denne kretsen er veldig enkel, vi bruker PIC Perf-kortet og kobler bare de tre ledningene til RS232 til USB-omformer og kobler modulen til datamaskinen vår ved hjelp av USB-datakabel som vist nedenfor.

Deretter installerer vi Hyper Terminal-applikasjonen (laster den ned herfra) og åpner den. Det skal vise noe slikt

Åpne nå Enhetsbehandling på datamaskinen din og sjekk hvilken Com-port modulen din er koblet til, min er koblet til COM-port 17 som vist nedenfor

Merk: COM-portnavnet for modulen din kan endres i henhold til leverandøren din, det er ikke noe problem.

Gå nå tilbake til Hyper Terminal Application og naviger til Oppsett -> Portkonfigurasjon eller trykk Alt + C, for å få følgende popup-boks og velg ønsket port (COM17 i mitt tilfelle) i popup-vinduet og klikk på koble til.

Når forbindelsen er opprettet, slå på PIC perf-kortet ditt, og du bør se noe slikt nedenfor

Hold markøren i kommandovinduet og skriv inn 1 og trykk deretter på enter. LED-lampen slås på og statusen vises som vist nedenfor.

På samme måte, hold markøren i kommandovinduet og skriv 0 og trykk deretter på enter. LED-lampen slås av og statusen vises som vist nedenfor.

Nedenfor får du fullstendig kode og detaljert video, som viser hvordan LED-en reagerer i sanntid for “1” og “0”.

Det er det gutta, vi har grensesnitt PIC UART med datamaskinen vår og overført dataene for å slå LED-lampen ved hjelp av Hyper terminal. Håper du forsto, hvis ikke, bruk kommentarseksjonen til å spørre. I vår neste opplæring vil vi igjen bruke UART, men gjøre det mer interessant ved å bruke en Bluetooth-modul og kringkaste dataene over luft.

Sjekk også UART-kommunikasjon mellom to ATmega8 mikrokontrollere og UART-kommunikasjon mellom ATmega8 og Arduino Uno.