Uart Kommunikation mit pic Mikrocontroller

In diesem Tutorial erfahren Sie, wie Sie die UART-Kommunikation mit dem PIC-Mikrocontroller aktivieren und wie Sie Daten von und zu Ihrem Computer übertragen. Bisher haben wir alle grundlegenden Module wie ADC, Timer, PWM behandelt und auch gelernt, wie LCDs und 7-Segment-Displays miteinander verbunden werden. Jetzt werden wir uns mit einem neuen Kommunikationswerkzeug namens UART ausstatten, das in den meisten Mikrocontroller-Projekten weit verbreitet ist. Lesen Sie hier unsere vollständigen TIC-Mikrocontroller-Tutorials mit MPLAB und XC8.

Hier haben wir PIC16F877A MCU verwendet, es hat ein Modul namens "Adressierbarer universeller synchroner asynchroner Empfänger und Sender", kurz bekannt als USART. USART ist ein Zweidraht-Kommunikationssystem, bei dem die Daten seriell fließen. USART ist auch eine Vollduplex-Kommunikation, dh Sie können gleichzeitig Daten senden und empfangen, die für die Kommunikation mit Peripheriegeräten wie CRT-Terminals und PCs verwendet werden können.

Der USART kann in den folgenden Modi konfiguriert werden:

• Asynchron (Vollduplex)
• Synchron - Master (Halbduplex)
• Synchron - Slave (Halbduplex)

Es gibt auch zwei verschiedene Modi, nämlich den 8-Bit- und den 9-Bit-Modus. In diesem Tutorial konfigurieren wir das USART-Modul so, dass es im asynchronen Modus mit einem 8-Bit-Kommunikationssystem arbeitet, da es die am häufigsten verwendete Kommunikationsart ist. Da es asynchron ist, muss es kein Taktsignal zusammen mit den Datensignalen senden. UART verwendet zwei Datenleitungen zum Senden (Tx) und Empfangen (Rx) von Daten. Die Erdung beider Geräte sollte ebenfalls gemeinsam gemacht werden. Diese Art der Kommunikation hat keine gemeinsame Uhr, daher ist eine gemeinsame Basis für das Funktionieren des Systems sehr wichtig.

Am Ende dieses Tutorials können Sie eine Kommunikation (UART) zwischen Ihrem Computer und Ihrem PIC-Mikrocontroller herstellen und eine LED auf der PIC-Karte von Ihrem Laptop aus umschalten. Der Status der LED wird von der PIC-MCU an Ihren Laptop gesendet. Wir werden die Ausgabe mit Hyper Terminal im Computer testen. Ein detailliertes Video finden Sie auch am Ende dieses Tutorials.

Bedarf:

Hardware:

• PIC16F877A Perf Board
• RS232 zu USB Konverter Modul
• Computer
• PICkit 3 Programmierer

Software:

• MPLABX
• HyperTerminal

Ein RS232-zu-USB-Konverter ist erforderlich, um die seriellen Daten in eine computerlesbare Form zu konvertieren. Es gibt Möglichkeiten, Ihre eigene Schaltung zu entwerfen, anstatt ein eigenes Modul zu kaufen, aber sie sind nicht zuverlässig, da sie Rauschen ausgesetzt sind. Die, die wir verwenden, ist unten gezeigt

Hinweis: Für jeden RS232-zu-USB-Konverter muss ein spezieller Treiber installiert werden. Die meisten von ihnen sollten automatisch installiert werden, sobald Sie das Gerät anschließen. Aber wenn es sich nicht entspannt !!! Verwenden Sie den Kommentarbereich und ich werde Ihnen helfen.

Programmierung des PIC-Mikrocontrollers für die UART-Kommunikation:

Wie alle Module (ADC, Timer, PWM) sollten wir auch unser USART-Modul unserer PIC16F877A-MCU initialisieren und anweisen, im UART 8-Bit-Kommunikationsmodus zu arbeiten. Definieren wir die Konfigurationsbits und beginnen mit der UART-Initialisierungsfunktion.

Initialisierung des UART-Moduls des PIC-Mikrocontrollers:

Die Tx- und Rx-Pins sind physikalisch an den Pins RC6 und RC7 vorhanden. Laut Datenblatt deklarieren wir TX als Ausgabe und RX als Eingabe.

// **** Setzen von E / A-Pins für UART **** // TRISC6 = 0; // TX Pin als Ausgang gesetzt TRISC7 = 1; // RX Pin als Eingang gesetzt // ________ E / A Pins gesetzt __________ //

Jetzt muss die Baudrate eingestellt werden. Die Baudrate ist die Rate, mit der Informationen in einem Kommunikationskanal übertragen werden. Dies kann einer der vielen Standardwerte sein, aber in diesem Programm verwenden wir 9600, da es die am häufigsten verwendete Baudrate ist.

/ ** SPBRG-Register für erforderliche Baudrate initialisieren und BRGH für schnelle Baudrate einstellen ** / SPBRG = ((_XTAL_FREQ / 16) / Baudrate) - 1; BRGH = 1; // für hohe Baudrate // _________ Ende der Baudrate _________ //

Der Wert der Baudrate muss mit dem Register SPBRG eingestellt werden. Der Wert hängt vom Wert der externen Kristallfrequenz ab. Die Formeln zur Berechnung der Baudrate sind nachstehend aufgeführt:

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

Das Bit BRGH muss hoch eingestellt werden, um eine hohe Bitrate zu ermöglichen. Laut Datenblatt (Seite 13) ist es immer vorteilhaft, es zu aktivieren, da es Fehler während der Kommunikation beseitigen kann.

Wie bereits erwähnt, werden wir im asynchronen Modus arbeiten, daher sollte das Bit SYNC auf Null gesetzt und das Bit SPEM auf High gesetzt werden, um serielle Pins (TRISC6 und TRICSC5) zu aktivieren.

// **** Asynchrone serielle Schnittstelle aktivieren ******* // SYNC = 0; // Asynchrones SPEN = 1; // Serielle Port-Pins aktivieren // _____ Asynchrone serielle Schnittstelle aktiviert _______ //

In diesem Tutorial senden und empfangen wir Daten zwischen MCU und Computer, daher müssen sowohl TXEN- als auch CREN-Bits aktiviert werden.

// ** Bereiten wir uns auf das Senden und Empfangen vor ** // TXEN = 1; // Übertragung aktivieren CREN = 1; // Empfang aktivieren // __ UART-Modul hoch und bereit zum Senden und Empfangen __ //

Die Bits TX9 und RX9 müssen auf Null gesetzt werden, damit wir im 8-Bit-Modus arbeiten. Wenn eine hohe Zuverlässigkeit festgestellt werden muss, kann der 9-Bit-Modus ausgewählt werden.

// ** 8-Bit-Modus auswählen ** // TX9 = 0; // 8-Bit-Empfang ausgewählt RX9 = 0; // 8-Bit-Empfangsmodus ausgewählt // __ 8-Bit-Modus ausgewählt __ //

Damit schließen wir unser Initialisierungssetup ab. und ist betriebsbereit.

Datenübertragung mit UART:

Die folgende Funktion kann verwendet werden, um Daten über das UART-Modul zu übertragen:

// ** Funktion zum Senden eines Datumsbytes an UART ** // void UART_send_char (char bt) {while (! TXIF); // halte das Programm, bis der TX-Puffer frei ist TXREG = bt; // Lade den Senderpuffer mit dem empfangenen Wert}} _____________ Funktionsende ________________ //

Sobald das Modul initialisiert ist, wird der in das Register TXREG geladene Wert über UART übertragen, die Übertragung kann sich jedoch überschneiden. Daher sollten wir immer nach dem Transmission Interrupt-Flag TXIF suchen. Nur wenn dieses Bit niedrig ist, können wir mit dem nächsten Bit für die Übertragung fortfahren, andernfalls sollten wir warten, bis dieses Flag niedrig wird.

Die obige Funktion kann jedoch nur zum Senden von nur einem Datenbyte verwendet werden. Um eine vollständige Zeichenfolge zu senden, sollte die folgende Funktion verwendet werden

// ** Funktion zum Konvertieren eines Strings in ein Byte ** // void UART_send_string (char * st_pt) {while (* st_pt) // wenn es ein char gibt UART_send_char (* st_pt ++); // als Byte-Daten verarbeiten} // ___________ Funktionsende ______________ //

Diese Funktion ist vielleicht etwas schwierig zu verstehen, da sie Zeiger enthält, aber glauben Sie mir, Zeiger sind wunderbar und erleichtern die Programmierung. Dies ist ein gutes Beispiel dafür.

Wie Sie sehen können, haben wir wieder UART_send_char () aufgerufen, aber jetzt innerhalb der while-Schleife. Wir haben die Zeichenfolge in einzelne Zeichen aufgeteilt. Bei jedem Aufruf dieser Funktion wird ein Zeichen an TXREG gesendet und übertragen.

Empfangen von Daten mit UART:

Mit der folgenden Funktion können Daten vom UART-Modul empfangen werden:

// ** Funktion zum Abrufen eines Datumsbytes von UART ** // char UART_get_char () {if (OERR) // auf Fehler prüfen {CREN = 0; // Wenn Fehler -> CREN = 1 zurücksetzen; // Wenn Fehler -> Zurücksetzen} while (! RCIF); // halte das Programm, bis der Empfangspuffer frei ist return RCREG; // den Wert empfangen und an die Hauptfunktion senden} // _____________ Funktionsende ________________ //

Wenn Daten vom UART-Modul empfangen werden, nimmt es sie auf und speichert sie im RCREG- Register. Wir können den Wert einfach auf eine beliebige Variable übertragen und verwenden. Möglicherweise liegt jedoch ein Überlappungsfehler vor, oder der Benutzer sendet kontinuierlich Daten, und wir haben sie noch nicht an eine Variable übertragen.

In diesem Fall kommt das Empfangsflagbit RCIF zur Rettung. Dieses Bit wird immer dann niedrig, wenn Daten empfangen und noch nicht verarbeitet werden. Daher verwenden wir es in der while-Schleife und erzeugen eine Verzögerung, um das Programm zu halten, bis wir uns mit diesem Wert befassen.

LED mit dem UART-Modul des PIC Microcontroller umschalten:

Kommen wir nun zum letzten Teil des Programms, der void main (void) -Funktion, bei der wir mithilfe der UART-Kommunikation zwischen PIC und Computer eine LED durch den Computer schalten.

Wenn wir ein Zeichen „1“ (vom Computer) senden, wird die LED eingeschaltet und die Statusmeldung „ROTE LED -> EIN“ wird (von der PIC-MCU) an den Computer zurückgesendet.

In ähnlicher Weise senden wir ein Zeichen "0" (vom Computer). Die LED wird ausgeschaltet und die Statusmeldung "ROTE LED -> AUS" wird (vom PIC-MCU) an den Computer zurückgesendet.

while (1) // Endlosschleife {get_value = UART_get_char (); if (get_value == '1') // Wenn der Benutzer "1" sendet {RB3 = 1; // LED einschalten UART_send_string ("RED LED -> ON"); // Benachrichtigung an den Computer senden UART_send_char (10); // ASCII-Wert 10 wird für den Wagenrücklauf verwendet (um in einer neuen Zeile zu drucken)} if (get_value == '0') // Wenn der Benutzer "0" {RB3 sendet = 0; // LED ausschalten UART_send_string ("RED -> OFF"); // Benachrichtigung an den Computer senden UART_send_char (10); // Der ASCII-Wert 10 wird für den Wagenrücklauf verwendet (um in einer neuen Zeile zu drucken)}}

Simulation unseres Programms:

Wie üblich simulieren wir unser Programm mit proteus und finden heraus, ob es wie erwartet funktioniert.

Das obige Bild zeigt ein virtuelles Terminal, in dem eine Begrüßungsnachricht und der Status der LED angezeigt werden. Es ist zu erkennen, dass die rote LED an den Pin RB3 angeschlossen ist. Die detaillierte Arbeitsweise der Simulation finden Sie im Video am Ende.

Hardware-Setup und Testen der Ausgabe:

Die Verbindung für diese Schaltung ist wirklich einfach. Wir verwenden unsere PIC Perf-Karte und verbinden einfach die drei Drähte mit dem RS232-zu-USB-Wandler und verbinden das Modul mit einem USB-Datenkabel wie unten gezeigt mit unserem Computer.

Als nächstes installieren wir die Hyper Terminal-Anwendung (laden Sie sie hier herunter) und öffnen sie. Es sollte so etwas zeigen

Öffnen Sie nun den Geräte-Manager auf Ihrem Computer und überprüfen Sie, an welchen COM-Anschluss Ihr Modul angeschlossen ist. Meiner ist wie unten gezeigt mit dem COM-Anschluss 17 verbunden

Hinweis: Der Name des COM-Anschlusses für Ihr Modul kann sich je nach Hersteller ändern. Dies ist kein Problem.

Gehen Sie nun zurück zu Hyper Terminal Application und navigieren Sie zu Setup -> Port Configuration oder drücken Sie Alt + C, um das folgende Popup-Feld aufzurufen. Wählen Sie den gewünschten Port (in meinem Fall COM17) im Popup-Fenster aus und klicken Sie auf Connect.

Sobald die Verbindung hergestellt ist, schalten Sie Ihr PIC Perf Board ein und Sie sollten so etwas unten sehen

Halten Sie den Cursor im Befehlsfenster und geben Sie 1 ein. Drücken Sie dann die Eingabetaste. Die LED leuchtet und der Status wird wie unten gezeigt angezeigt.

Halten Sie den Cursor auf die gleiche Weise im Befehlsfenster und geben Sie 0 ein. Drücken Sie dann die Eingabetaste. Die LED wird ausgeschaltet und der Status wird wie unten gezeigt angezeigt.

Im Folgenden finden Sie den vollständigen Code und ein detailliertes Video, das zeigt, wie die LED in Echtzeit auf „1“ und „0“ reagiert.

Das war's, Leute, wir haben PIC UART mit unserem Computer verbunden und die Daten übertragen, um die LED mithilfe des Hyper-Terminals umzuschalten. Ich hoffe, Sie haben verstanden, wenn nicht, verwenden Sie den Kommentarbereich, um Ihre Anfrage zu stellen. In unserem nächsten Tutorial werden wir wieder UART verwenden, es aber durch die Verwendung eines Bluetooth-Moduls interessanter machen und die Daten über Funk übertragen.

Überprüfen Sie auch die UART-Kommunikation zwischen zwei ATmega8-Mikrocontrollern und die UART-Kommunikation zwischen ATmega8 und Arduino Uno.