Uart kommunikáció pic mikrovezérlővel

Ebben az oktatóanyagban megtanuljuk engedélyezni az UART kommunikációt a PIC mikrokontrollerrel, és hogyan lehet adatokat továbbítani a számítógépére és a számítógépéről. Eddig minden olyan alapmodult átfogtunk, mint az ADC, az időzítők, a PWM, és megtanultuk az LCD-k és a 7 szegmenses kijelzők interfészének kezelését is. Most felszereljük önmagunkat egy új, UART nevű kommunikációs eszközzel, amelyet széles körben használnak a mikrokontroller projektek többségében. Itt tekintheti meg az MPLAB és az XC8 protokollt használó teljes PIC mikrokontroller oktatóanyagokat.

Itt a PIC16F877A MCU-t használtuk, van egy "Címezhető univerzális szinkron aszinkron vevő és adó" nevű modulja, röviden USART néven. A USART egy kétvezetékes kommunikációs rendszer, amelyben az adatok sorozatosan áramlanak. A USART egyben egy full-duplex kommunikáció is, vagyis egyszerre küldhet és fogadhat adatokat, amelyek felhasználhatók perifériás eszközökkel, például CRT terminálokkal és személyi számítógépekkel való kommunikációra.

Az USART a következő módokban konfigurálható:

• Aszinkron (full-duplex)
• Szinkron - Master (fél-duplex)
• Szinkron - Slave (fél-duplex)

Két különböző mód is létezik, nevezetesen a 8 bites és a 9 bites mód, ebben az oktatóanyagban úgy konfiguráljuk az USART modult, hogy aszinkron módban működjön 8 bites kommunikációs rendszerrel, mivel ez a leggyakrabban használt kommunikációs típus. Mivel aszinkron, nem kell órajelet küldenie az adatjelekkel együtt. Az UART két adatsort használ az adatok küldéséhez (Tx) és fogadásához (Rx). Mindkét eszköz földjét szintén közösvé kell tenni. Ennek a kommunikációs típusnak nincs közös órája, ezért nagyon fontos a közös működés a rendszer működéséhez.

Az oktatóanyag végén kommunikációt (UART) hozhat létre a számítógép és a PIC mikrovezérlő között, és a LED-et kapcsolhatja a PIC-alaplapon a laptopról. A LED állapotát a PIC MCU küldi el laptopjára. A kimenetet a számítógépen lévő Hyper Terminal segítségével teszteljük. A részletes videó szintén az oktatóanyag végén található.

Követelmények:

Hardver:

• PIC16F877A Perf Board
• RS232 - USB átalakító modul
• Számítógép
• PICkit 3 programozó

Szoftver:

• MPLABX
• HyperTerminal

Az RS232-USB átalakítóra van szükség a soros adatok számítógéppel olvasható formába konvertálásához. Van néhány módszer saját áramkör megtervezésére ahelyett, hogy saját modult vásárolna, de ezek nem megbízhatóak, mivel zajnak vannak kitéve. Az alábbiakban látható az, amelyet használunk

Megjegyzés: Minden RS232-USB átalakítóhoz külön illesztőprogram telepítése szükséges; legtöbbjüket automatikusan telepíteni kell, amint csatlakoztatja az eszközt. De, ha nem lazít !!! Használd a megjegyzés részt, és én segítek neked.

PIC mikrokontroller programozása az UART kommunikációhoz:

Mint minden modulhoz (ADC, Timer, PWM), inicializálnunk kell a PIC16F877A MCU- s USART modulunkat is, és meg kell utasítanunk, hogy működjön 8 bites UART kommunikációs módban. Határozzuk meg a konfigurációs biteket, és kezdjük az UART inicializáló függvénnyel.

A PIC mikrokontroller UART moduljának inicializálása:

A Tx és Rx csapok fizikailag jelen vannak az RC6 és RC7 csapokon. Az adatlap szerint deklaráljuk a TX-t kimenetnek és az RX-t bemenetnek.

// **** I / O csapok beállítása az UART számára **** // TRISC6 = 0; // TX kimenet kimenetként TRISC7 = 1; // RX Pin beállítva bemenetként // ________ I / O csapok beállítása __________ //

Most be kell állítani az adatátviteli sebességet. Az adatátviteli sebesség az az információ átvitelének sebessége egy kommunikációs csatornán. Ez lehet a sok alapértelmezett érték egyike, de ebben a programban 9600-at használunk, mivel a leggyakrabban használt adatátviteli sebesség.

/ ** Inicializálja az SPBRG regisztert a szükséges adatátviteli sebességhez, és állítsa be a BRGH értéket a gyors adatátviteli sebességhez ** / SPBRG = ((_XTAL_FREQ / 16) / Baud_rate) - 1; BRGH = 1; // a magas baud_rate esetén // _________ A baud_rate beállítás vége _________ //

Az adatátviteli sebesség értékét az SPBRG regiszter segítségével kell beállítani, az érték a Külső kristály frekvencia értékétől függ, az átviteli sebesség kiszámításának képletei az alábbiakban láthatók:

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

A BRGH bitet nagyra kell tenni, hogy lehetővé tegye a nagy sebességű bitsebességet. Az adatlap (13. oldal) szerint mindig előnyös engedélyezni, mivel kiküszöböli a kommunikáció során fellépő hibákat.

Mint már említettük dolgozni fogunk aszinkron módban, így a bit SYNC kell tenni nulla bit SPEM kell tenni a magas ahhoz, hogy a soros csapok (TRISC6 és TRICSC5)

// **** Aszinkron soros port engedélyezése ******* // SYNC = 0; // aszinkron SPEN = 1; // Soros port csapok engedélyezése // _____ Aszinkron soros port engedélyezve _______ //

Ebben az oktatóanyagban egyaránt küldünk és fogadunk adatokat az MCU és a számítógép között, ezért engedélyeznünk kell a TXEN és a CREN biteket is.

// ** Felkészülhet az átvitelre és vételre ** // TXEN = 1; // átvitel engedélyezése CREN = 1; // engedélyezi a vételt // __ UART modul fel van készen áll az átvitelre és vételre __ //

A TX9 és RX9 biteket nullára kell tenni, hogy 8 bites módban működjünk. Ha nagy megbízhatóságot kell létrehozni, akkor 9 bites mód választható.

// ** Válasszon 8 bites módot ** // TX9 = 0; // 8 bites vétel kiválasztva RX9 = 0; // 8 bites vételi mód kiválasztva // __ 8 bites mód kiválasztva __ //

Ezzel befejezzük az inicializálási beállítást. és üzemkész.

Adatok továbbítása UART segítségével:

Az alábbi funkció használható adatok továbbítására az UART modulon keresztül:

// ** Funkció egy dátum bájt elküldésére az UART-ra ** // void UART_send_char (char bt) {while (! TXIF); // tartsa lenyomva a programot, amíg a TX puffer nem lesz szabad TXREG = bt; // Töltse be az adó puffert a kapott értékkel} // _____________ Funkció vége ________________ //

A modul inicializálása után a regiszterbe betöltött bármely értéket a TXREG továbbítja az UART-on keresztül, de az átvitel átfedhet. Ezért mindig ellenőriznünk kell a TXIF Transmission Interrupt jelzőt . Csak akkor, ha ez a bit alacsony, folytathatjuk a következő bitet az átvitelhez, különben várnunk kell, amíg ez a zászló alacsony lesz.

A fenti függvény azonban csak egy bájt adat küldésére használható, egy teljes karakterlánc elküldésére az alábbi függvényt kell használni

// ** Funkció a karakterlánc bájtokká alakítására ** // void UART_send_string (char * st_pt) {while (* st_pt) // ha van karakter UART_send_char (* st_pt ++); // bájtadatokként feldolgozza} // ___________ A funkció vége ______________ //

Lehet, hogy ezt a funkciót kissé trükkös megérteni, mivel vannak mutatói, de hidd el, hogy a mutatók csodálatosak, és megkönnyítik a programozást, és ez jó példa erre.

Amint észreveheti, ismét hívtuk az UART_send_char () -t, de most a while ciklus belsejében. A karakterláncot külön karakterekre bontottuk, minden egyes alkalommal, amikor ezt a függvényt meghívtuk, egy karaktert küldünk a TXREG-nek, és továbbítja.

Adatok fogadása az UART segítségével:

A következő funkció használható adatok fogadására az UART modulból:

// ** Funkció, hogy egy bájt dátumot kapjon az UART-ból ** // char UART_get_char () {if (OERR) // ellenőrizze a {CREN = 0 hibát; // Ha hiba -> CREN visszaállítása = 1; // Ha hiba -> Visszaállítás} while (! RCIF); // tartsa lenyomva a programot, amíg az RX puffer szabadon visszatér RCREG; // megkapja az értéket és elküldi a fő függvénynek} // _____________ Funkció vége ________________ //

Amikor egy adatot megkap az UART modul, akkor felveszi és tárolja az RCREG regiszterben. Egyszerűen átvihetjük az értéket bármely változóba és felhasználhatjuk. De lehet, hogy átfedési hiba van, vagy a felhasználó folyamatosan adatokat küld, és mi még nem vittük át őket egy változóba.

Ebben az esetben az RCIF fogadó jelző bit jön megmentésre. Ez a bit alacsony lesz, amikor adat érkezik és még nincs feldolgozva. Ezért használjuk a while ciklusban, ami késleltetést jelent a program megtartására, amíg nem foglalkozunk ezzel az értékkel.

LED bekapcsolása a PIC mikrokontroller UART moduljával:

Most térjünk el a Program utolsó részéhez, a void main (void) funkcióhoz, ahol egy LED-et kapcsolunk át a számítógépen, a PIC és a számítógép közötti UART kommunikáció segítségével.

Amikor egy „1” karaktert küldünk (számítógépről), a LED bekapcsol és a „RED LED -> ON” állapotüzenet visszaküldik (a PIC MCU-tól) a számítógépre.

Hasonlóképpen küldünk egy „0” karaktert (számítógépről), a LED kialszik és a „RED LED -> OFF” állapotüzenetet visszaküldik (a PIC MCU-tól) a számítógépre.

while (1) // Végtelen ciklus {get_value = UART_get_char (); if (get_value == '1') // Ha a felhasználó "1" -et küld {RB3 = 1; // Kapcsolja be a LED UART_send_string ("RED LED -> ON"); // Értesítés küldése a számítógépre UART_send_char (10); // ASCII 10 értéket használunk a kocsi visszaadásához (új sorban történő nyomtatáshoz)} if (get_value == '0') // Ha a felhasználó "0" {RB3 üzenetet küld = 0; // Kapcsolja ki a LED UART_send_string ("RED -> OFF"); // Értesítés küldése a számítógépre UART_send_char (10); // ASCII 10 értéket használunk a kocsi visszaadásához (új sorban történő nyomtatáshoz)}}

Programunk szimulálása:

Szokás szerint szimuláljuk programunkat a proteus segítségével, és derítsük ki, hogy a várt módon működik-e.

A fenti kép egy virtuális terminált mutat, amelyben egy üdvözlő üzenetet és a LED állapotát mutatja. A piros színű LED észrevehető, hogy az RB3 tűhöz csatlakozik. A szimuláció részletes leírása a videó végén található.

Hardver beállítása és a kimenet tesztelése:

Ennek az áramkörnek a csatlakoztatása nagyon egyszerű: használjuk a PIC Perf kártyánkat, és csak csatlakoztassuk a három vezetéket az RS232-hez az USB-átalakítóhoz, és csatlakoztassuk a modult a számítógépünkhöz USB-adatkábellel az alábbiak szerint.

Ezután telepítjük a Hyper Terminal alkalmazást (innen letölthetjük), és megnyithatjuk. Valami ilyesmit kell mutatnia

Most nyissa meg az Eszközkezelőt a számítógépén, és ellenőrizze, hogy melyik Com porthoz van csatlakoztatva a modul, az enyém pedig a 17. COM porthoz van csatlakoztatva, az alábbiak szerint

Megjegyzés: A modul COM portjának neve változhat a gyártótól függően, ez nem jelent problémát.

Most térjen vissza a Hyper Terminal alkalmazáshoz, és lépjen a Beállítás -> Portkonfiguráció lehetőséghez, vagy nyomja le az Alt + C billentyűt, hogy megkapja a következő felugró ablakot, és a felugró ablakban válassza ki a kívánt portot (esetemben COM17), majd kattintson a Connect.

Ha a kapcsolat létrejött, kapcsolja be a PIC perf tábláját, és valami ilyesmit kell látnia az alábbiakban

Tartsa a kurzort a Parancs ablakban, írja be az 1 értéket, majd nyomja meg az Enter billentyűt. A LED bekapcsol és az állapot az alábbiak szerint jelenik meg.

Ugyanígy tartsa a kurzort a Parancs ablakban, írja be a 0 értéket, majd nyomja meg az Enter billentyűt. A LED kikapcsol és az állapot az alábbiak szerint jelenik meg.

Az alábbiakban megadjuk a teljes kódot és a részletes videót, amely megmutatja, hogy a LED hogyan reagál valós időben „1” és „0” esetén.

Ez az, srácok, összekötöttük a PIC UART-ot a számítógépünkkel, és átadtuk az adatokat a LED váltásához a Hyper terminál segítségével. Remélem, megértette, ha nem, akkor a megjegyzés szakaszban kérdezze meg lekérdezését. A következő bemutatónkban ismét használjuk az UART-ot, de érdekesebbé tesszük egy Bluetooth-modul használatával, és az adatokat sugározzuk levegőn.

Ellenőrizze továbbá az UART kommunikációt két ATmega8 mikrokontroller között, valamint az UART kommunikációt az ATmega8 és az Arduino Uno között.