Uart-communicatie met behulp van pic-microcontroller

In deze tutorial leren we om UART-communicatie met PIC Microcontroller mogelijk te maken en hoe u gegevens van en naar uw computer kunt overbrengen. Tot nu toe hebben we alle basismodules zoals ADC, Timers, PWM behandeld en ook geleerd hoe we LCD's en 7-segment-displays met elkaar kunnen verbinden. Nu zullen we onszelf uitrusten met een nieuw communicatiemiddel genaamd UART, dat op grote schaal wordt gebruikt in de meeste Microcontroller-projecten. Bekijk hier onze complete PIC Microcontroller Tutorials met MPLAB en XC8.

Hier hebben we de PIC16F877A MCU gebruikt, het heeft een module genaamd "Adresseerbare universele synchrone asynchrone ontvanger en zender", kortweg USART. USART is een tweedraads communicatiesysteem waarin de gegevens serieel stromen. USART is ook een full-duplex communicatie, wat betekent dat u tegelijkertijd gegevens kunt verzenden en ontvangen die kunnen worden gebruikt om te communiceren met randapparatuur, zoals CRT-terminals en pc's.

De USART kan worden geconfigureerd in de volgende modi:

• Asynchroon (full-duplex)
• Synchroon - Master (half-duplex)
• Synchroon - Slave (half-duplex)

Er zijn ook twee verschillende modi, namelijk de 8-bit en 9-bit modus, in deze tutorial zullen we de USART-module configureren om te werken in de asynchrone modus met 8-bit communicatiesysteem, aangezien dit het meest gebruikte type communicatie is. Omdat het asynchroon is, hoeft het geen kloksignaal samen met de datasignalen te verzenden. UART gebruikt twee datalijnen voor het verzenden (Tx) en ontvangen (Rx) van gegevens. De aarde van beide apparaten moet ook gemeenschappelijk worden gemaakt. Dit type communicatie deelt geen gemeenschappelijke klok, daarom is een gemeenschappelijke basis erg belangrijk om het systeem te laten werken.

Aan het einde van deze tutorial kunt u een communicatie (UART) tot stand brengen tussen uw computer en uw PIC-microcontroller en een LED op het PIC-bord vanaf uw laptop schakelen. De status van de LED wordt vanaf de PIC MCU naar uw laptop gestuurd. We zullen de uitvoer testen met Hyper Terminal op de computer. Aan het einde van deze tutorial wordt ook een gedetailleerde video gegeven.

Vereisten:

Hardware:

• PIC16F877A Perf bord
• RS232 naar USB-convertermodule
• Computer
• PICkit 3 Programmer

Software:

• MPLABX
• HyperTerminal

Een RS232 naar USB-converter is vereist om de seriële gegevens om te zetten in een computerleesbare vorm. Er zijn manieren om uw eigen circuit te ontwerpen in plaats van uw eigen module te kopen, maar ze zijn niet betrouwbaar omdat ze worden blootgesteld aan ruis. Degene die we gebruiken, wordt hieronder weergegeven

Opmerking: voor elke RS232-naar-USB-converter moet een speciaal stuurprogramma worden geïnstalleerd; de meeste zouden automatisch moeten worden geïnstalleerd zodra u het apparaat aansluit. Maar als het niet ontspant !!! Gebruik het commentaargedeelte en ik zal je helpen.

PIC-microcontroller programmeren voor UART-communicatie:

Zoals alle modules (ADC, Timer, PWM), moeten we ook onze USART-module van onze PIC16F877A MCU initialiseren en deze opdracht geven om te werken in de UART 8-bits communicatiemodus. Laten we de configuratiebits definiëren en beginnen met de UART-initialisatiefunctie.

Initialiseren van de UART-module van de PIC Microcontroller:

De Tx- en Rx-pinnen zijn fysiek aanwezig op de pinnen RC6 en RC7. Laten we volgens het gegevensblad TX als uitvoer en RX als invoer aangeven.

// **** I / O-pinnen instellen voor UART **** // TRISC6 = 0; // TX Pin ingesteld als uitvoer TRISC7 = 1; // RX-pin ingesteld als invoer // ________ I / O-pinnen ingesteld __________ //

Nu moet de baudrate worden ingesteld. De baudrate is de snelheid waarmee informatie wordt overgedragen in een communicatiekanaal. Dit kan een van de vele standaardwaarden zijn, maar in dit programma gebruiken we 9600 omdat dit de meest gebruikte baudrate is.

/ ** Initialiseer SPBRG-register voor vereiste baudsnelheid en stel BRGH in voor snelle baud_snelheid ** / SPBRG = ((_XTAL_FREQ / 16) / Baud_snelheid) - 1; BRGH = 1; // voor hoge baud_rate // _________ Einde van baud_rate-instelling _________ //

De waarde van de baudrate moet worden ingesteld met behulp van het register SPBRG, de waarde hangt af van de waarde van de externe kristalfrequentie, de formules om de baudrate te berekenen worden hieronder weergegeven:

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

De bit BRGH moet hoog worden gemaakt om een ​​hoge bitsnelheid mogelijk te maken. Volgens datasheet (pagina 13) is het altijd voordelig om het in te schakelen, omdat het fouten tijdens de communicatie kan elimineren.

Zoals eerder gezegd zullen we in de asynchrone modus werken, daarom moet de bit SYNC nul worden gemaakt en moet bit SPEM hoog worden gemaakt om seriële pinnen mogelijk te maken (TRISC6 en TRICSC5)

// **** Asynchrone seriële poort inschakelen ******* // SYNC = 0; // Asynchrone SPEN = 1; // Schakel seriële poortpinnen in // _____ Asynchrone seriële poort ingeschakeld _______ //

In deze tutorial zullen we zowel gegevens verzenden als ontvangen tussen MCU en computer, daarom moeten we zowel TXEN- als CREN-bits inschakelen.

// ** Laten we ons voorbereiden op verzending en ontvangst ** // TXEN = 1; // schakel transmissie CREN = 1 in; // ontvangst inschakelen // __ UART-module klaar voor verzending en ontvangst __ //

De bits TX9 en RX9 moeten nul worden gemaakt zodat we in 8-bit mode werken. Als er een hoge betrouwbaarheid moet worden vastgesteld, kan de 9-bits modus worden geselecteerd.

// ** Selecteer 8-bits modus ** // TX9 = 0; // 8-bits ontvangst geselecteerd RX9 = 0; // 8-bits ontvangstmodus geselecteerd // __ 8-bits modus geselecteerd __ //

Hiermee voltooien we onze initialisatie-instellingen. en is klaar voor gebruik.

Gegevens verzenden met UART:

De onderstaande functie kan worden gebruikt om gegevens via de UART-module te verzenden:

// ** Functie om een ​​byte van de datum naar UART ** // void UART_send_char (char bt) {while (! TXIF); // houd het programma vast totdat TX-buffer vrij is TXREG = bt; // Laad de zenderbuffer met de ontvangen waarde} // _____________ Einde functie ________________ //

Zodra de module is geïnitialiseerd, wordt de waarde die in het register TXREG wordt geladen, verzonden via UART, maar de verzending kan elkaar overlappen. Daarom moeten we altijd controleren op de transmissieonderbrekingsvlag TXIF. Alleen als dit bit laag is, kunnen we doorgaan met het volgende bit voor verzending, anders moeten we wachten tot deze vlag laag wordt.

De bovenstaande functie kan echter alleen worden gebruikt om slechts één byte aan gegevens te verzenden, om een ​​volledige reeks te verzenden, moet de onderstaande functie worden gebruikt

// ** Functie om string naar byte te converteren ** // void UART_send_string (char * st_pt) {while (* st_pt) // als er een char is UART_send_char (* st_pt ++); // verwerk het als bytegegevens} // ___________ Einde van de functie ______________ //

Deze functie is misschien een beetje lastig te begrijpen omdat het aanwijzingen bevat, maar geloof me, aanwijzingen zijn geweldig en ze maken het programmeren gemakkelijker en dit is een goed voorbeeld van hetzelfde.

Zoals je kunt zien, hebben we opnieuw de UART_send_char () aangeroepen, maar nu binnen de while-lus. We hebben de string in afzonderlijke karakters opgesplitst, elke keer dat deze functie wordt aangeroepen, wordt er een char naar de TXREG gestuurd en deze wordt verzonden.

Gegevens ontvangen met UART:

De volgende functie kan worden gebruikt om gegevens van de UART-module te ontvangen:

// ** Functie om één byte van de datum op te halen uit UART ** // char UART_get_char () {if (OERR) // controleer op fout {CREN = 0; // Als fout -> Reset CREN = 1; // If error -> Reset} while (! RCIF); // houd het programma vast totdat de RX-buffer vrij is, geef RCREG terug; // ontvang de waarde en stuur deze naar de hoofdfunctie} // _____________ Einde van de functie ________________ //

Wanneer een gegevens door de UART-module wordt ontvangen, pikt deze deze op en slaat deze op in het RCREG- register. We kunnen de waarde eenvoudig naar een willekeurige variabele overbrengen en gebruiken. Maar er kan een overlappingsfout zijn of de gebruiker verzendt mogelijk continu gegevens en we hebben ze nog niet naar een variabele overgedragen.

In dat geval komt de ontvangstvlagbit RCIF te hulp. Dit bit zal laag worden wanneer gegevens worden ontvangen en nog niet zijn verwerkt. Daarom gebruiken we het in de while-lus en creëren we een vertraging om het programma vast te houden totdat we met die waarde omgaan.

Schakelen tussen LED's met behulp van de UART-module van PIC Microcontroller:

Laten we nu naar het laatste deel van het programma komen, de void main (void) functie, waar we een LED door de computer laten schakelen met behulp van de UART-communicatie tussen PIC en computer.

Als we een teken "1" (vanaf de computer) sturen, wordt de LED AAN gezet en wordt het statusbericht "RODE LED -> AAN" teruggestuurd (van PIC MCU) naar de computer.

Op dezelfde manier sturen we een teken "0" (vanaf de computer), de LED wordt UIT geschakeld en het statusbericht "RODE LED -> UIT" wordt teruggestuurd (van PIC MCU) naar de computer.

while (1) // Oneindige lus {get_value = UART_get_char (); if (get_value == '1') // Als de gebruiker "1" verzendt {RB3 = 1; // Schakel LED UART_send_string in ("RODE LED -> AAN"); // Stuur een melding naar de computer UART_send_char (10); // ASCII-waarde 10 wordt gebruikt voor regelterugloop (om in een nieuwe regel af te drukken)} if (get_value == '0') // Als de gebruiker "0" {RB3 = 0; // Schakel LED UART_send_string ("RED -> OFF") uit; // Stuur een melding naar de computer UART_send_char (10); // ASCII-waarde 10 wordt gebruikt voor regelterugloop (om in een nieuwe regel af te drukken)}}

Ons programma simuleren:

Laten we zoals gewoonlijk ons ​​programma simuleren met proteus en kijken of het werkt zoals verwacht.

De bovenstaande afbeelding toont een virtuele terminal waarin een welkomstbericht en de status van de LED wordt weergegeven. De rode kleur LED kan worden opgemerkt om te zijn aangesloten op de pin RB3. De gedetailleerde werking van de simulatie is te vinden in de video aan het einde.

Hardware instellen en de uitvoer testen:

De verbinding voor dit circuit is heel eenvoudig, we gebruiken ons PIC Perf-bord en sluiten gewoon de drie draden aan op de RS232 naar USB-converter en verbinden de module met onze computer met behulp van een USB-datakabel, zoals hieronder weergegeven.

Vervolgens installeren we de Hyper Terminal-applicatie (download deze van hier) en openen deze. Het zou zoiets als dit moeten laten zien

Open nu Apparaatbeheer op uw computer en controleer op welke Com-poort uw module is aangesloten, de mijne is aangesloten op COM-poort 17 zoals hieronder weergegeven

Opmerking: De naam van de COM-poort voor uw module kan veranderen naargelang uw leverancier, dit is geen probleem.

Ga nu terug naar Hyper Terminal Application en navigeer naar Set Up -> Port Configuration of druk op Alt + C, om het volgende pop-upvenster te krijgen en selecteer de gewenste poort (COM17 in mijn geval) in het pop-upvenster en klik op verbinden.

Zodra de verbinding tot stand is gebracht, zet u uw PIC-kaart aan en u zou zoiets als dit hieronder moeten zien

Houd uw cursor in het opdrachtvenster en voer 1 in en druk op enter. De LED gaat aan en de status wordt weergegeven zoals hieronder weergegeven.

Houd op dezelfde manier uw cursor in het opdrachtvenster en voer 0 in en druk op enter. De LED wordt uitgeschakeld en de status wordt weergegeven zoals hieronder weergegeven.

Hieronder vindt u de volledige code en gedetailleerde video, die laat zien hoe de LED in realtime reageert voor "1" en "0".

Dat zijn het jongens, we hebben PIC UART met onze computer verbonden en de gegevens overgedragen om de LED te schakelen met behulp van Hyper-terminal. Ik hoop dat je het begrepen hebt, zo niet, gebruik dan het commentaargedeelte om je vraag te stellen. In onze volgende tutorial zullen we UART opnieuw gebruiken, maar het interessanter maken door een Bluetooth-module te gebruiken en de gegevens via de ether uit te zenden.

Controleer ook UART-communicatie tussen twee ATmega8-microcontrollers en UART-communicatie tussen ATmega8 en Arduino Uno.