Serielle Uart-Kommunikation auf stm8 mit Cosmic C und STVD

Das Programmieren eines neuen Mikrocontrollers dauert aufgrund der neuen Registerbehandlungsmethoden oft länger und es ist nicht bekannt, welches Bit genau was bewirkt. Gleiches gilt natürlich auch für das Debuggen. Aus diesem Grund verwenden Programmierer häufig Haltepunkte in ihrem Code und durchlaufen ihn mit einem Debugger. Die Verwendung eines Debuggers erfordert jedoch möglicherweise zusätzliche Hardware (meistens teuer) und zusätzliche Zeit. Als Arduino-Fanjunge können wir uns alle darauf einigen, dass serielle Druckanweisungen zum Debuggen und Verstehen unseres Codes das Leben viel einfacher machen. Was können wir auf STM8s mit Cosmic C Compiler und SPL-Bibliotheken replizieren? Nun, es ist sehr gut möglich, und genau das werden wir in diesem dritten Tutorial unserer Tutorial-Reihe tun.Sie können auch die ersten Schritte mit STM8S (Lernprogramm 1) und STM8S GPIO-Steuerung (Lernprogramm 2) überprüfen, wenn Sie hier völlig neu sind. Wir haben auch die Möglichkeit untersucht, STM8S mit Arduino für schnelle Starter zu programmieren. Lassen Sie uns mit dem Tutorial beginnen.

Serielle Kommunikation auf STM8S103F3P6

Aus dem Datenblatt von STM8S103F3P6 können wir erkennen, dass unser 8-Bit-Controller die UART-Kommunikation in vielen verschiedenen Modi unterstützt. Der Controller verfügt außerdem über einen Taktausgangspin für die synchrone UART-Kommunikation und unterstützt auch SmarCard, IrDA und LIN. In diesem Tutorial werden wir jedoch nichts davon untersuchen, um der Komplexität fernzuhalten. Wir werden lernen, wie man einfach UART liest und schreibt.

Das Lernprogramm enthält auch eine Header-Datei mit dem Namen stm8s103 serial.h, mit der Sie einfache UART-Befehle wie Serial begin, Serial read, serial print usw. ausführen können. Grundsätzlich können Sie char, int und string auf dem seriellen Monitor drucken und lesen Sie auch char vom seriellen Monitor. Am Ende dieses Tutorials können Sie eine LED vom seriellen Monitor aus steuern und Feedback zum Status der LED erhalten. Die oben erwähnte Header-Datei hängt von den SPL-Bibliotheken ab. Stellen Sie daher sicher, dass Sie das Tutorial für die ersten Schritte befolgt haben.

Serielle Kommunikationsstifte am STM8S103F3P6

Beginnen wir von der Hardware-Seite. Ein kurzer Blick auf die Pinbelegung des unten angegebenen STM8S103F3P6- Mikrocontrollers zeigt, dass die Pins 1, 2 und 3 für die UART-Kommunikation verwendet werden.

Unter den drei ist Pin 1 der UART-Clock-Pin, der nur während der synchronen UART-Kommunikation verwendet wird, sodass wir ihn hier nicht benötigen. Pin 2 ist der UART-Sender-Pin und Pin 3 ist der UART-Empfänger-Pin. Beachten Sie, dass diese Pins auch als analoger oder normaler GPIO-Pin verwendet werden können.

Schaltplan für die serielle STM8S-Kommunikation

Der Schaltplan ist hier sehr einfach. Wir müssen unseren ST-LINK 2 zum Programmieren und einen USB-TTL-Wandler zum Lesen serieller Daten anschließen. Beachten Sie, dass unser STM8S-Controller mit einem 3,3-V-Logikpegel arbeitet. Stellen Sie daher sicher, dass Ihr USB-TTL-Wandler auch 3,3-V-Logik unterstützt. Das vollständige Schaltbild ist unten dargestellt.

Sie müssen Ihren ST-Link an einem USB-Anschluss und den USB-TTL-Konverter an einem anderen USB-Anschluss Ihres Laptops anschließen, damit Sie Daten gleichzeitig programmieren und überwachen können. Die UART-Verbindung ist einfach. Verbinden Sie einfach die Erdung und den Rx / Tx-Pin Ihres STM8S-Mikrocontrollers mit den Tx / Rx-Pins des USB-TTL-Wandlers. Hier habe ich den Controller mit dem Vcc-Pin von ST-Link versorgt und den vss-Pin des TTL-Konverters offen gelassen. Sie können dies auch umgekehrt tun. Es gibt viele Arten von USB-zu-TTL-Wandlern auf dem Markt. Stellen Sie nur sicher, dass diese mit 3,3-V-Logiksignalen betrieben werden können, suchen Sie einfach nach Tx-, Rx- und GND-Pins und stellen Sie die oben gezeigte Verbindung her. Meine Hardware-Einrichtung ist unten dargestellt.

Für eine serielle Kommunikation haben wir die Header-Datei STM8S_Serial.h bereitgestellt. Mit dieser Header-Datei können Sie einfache Arduino-ähnliche Funktionen für die serielle Kommunikation ausführen.

Alle für dieses Projekt erforderlichen Dateien finden Sie auf unserer Github-Seite STM8S103F3_SPL. Wenn Sie nur diese bestimmte Header-Datei benötigen, können Sie sie über den folgenden Link herunterladen.

Laden Sie STM8S_Serial.h herunter

Einrichten von STVD für die serielle Kommunikation

Um mit der seriellen Kommunikation zu arbeiten, werden wir viele verwenden, die die zuvor beschriebene STM8S_Serial.h- Header- Dateifunktion verwenden . Die Bibliothek hat jedoch andere Abhängigkeiten, viele SPL UART- und Clock-bezogene Header- und C-Dateien. Ab diesem Zeitpunkt ist es daher besser, alle Header- und C-Dateien in unser Projekt aufzunehmen, um einen Kompilierungsfehler zu vermeiden. Meine STVD-Arbeitsumgebung sieht so aus.

Stellen Sie sicher, dass Sie alle SPL-Quelldateien und Include-Dateien wie in unserem ersten Tutorial aufgenommen haben. Stellen Sie außerdem sicher, dass Sie die Header-Datei stm8s103_serial.h hinzugefügt haben. Für diesen Header gibt es keine C-Datei.

Programmierung von STM8S für die serielle Kommunikation

Sobald das STVD-Projekt-Setup fertig ist, können wir unseren Code in die Datei main.c schreiben . Den vollständigen Code für dieses Tutorial finden Sie unten auf dieser Seite. Die Erklärung lautet wie folgt.

Der erste Schritt besteht darin, die erforderlichen Header-Dateien einzuschließen. Hier habe ich die Haupt-Header-Datei (stm8s) und die gerade heruntergeladene stm8s_103_serial- Header-Datei hinzugefügt.

// Erforderliche Header #include "STM8S.h" #include "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3_SPL/blob/master/stm8s103%20Libraries/stm8s103_Serial.h

Als Nächstes verwenden wir die Entwurfsmakros, um die Eingangs- und Ausgangspins anzugeben. Hier wird nur die integrierte LED gesteuert, die an Pin 5 von Port B angeschlossen ist. Daher geben wir ihr den Namen test_LED .

#define test_LED GPIOB, GPIO_PIN_5 // Die Test-LED ist an PB5 angeschlossen

Wenn wir in der Hauptfunktion weitermachen, definieren wir den Pin als Ausgang. Wenn Sie mit den grundlegenden GPIO-Funktionen nicht vertraut sind, greifen Sie auf das STM8S GPIO-Lernprogramm zurück.

// Pin-Definitionen // Deklariere PB5 als Push-Pull-Ausgangspin GPIO_Init (test_LED, GPIO_MODE_OUT_PP_LOW_SLOW);

Dann initialisieren wir unsere seriellen Kommunikationsports mit 9600 Baudraten. Für Neueinsteiger ist 9600 die Geschwindigkeit, mit der die Datenbits während der Kommunikation übertragen werden. Wenn Sie hier 9600 einstellen, müssen Sie dies auch in der Überwachungssoftware einstellen. Dann drucken wir auch eine Zeichenfolge "Befehl eingeben" und fahren mit der nächsten Zeile fort.

Serial_begin (9600); // Serielle Kommunikation mit einer Baudrate von 9600 initialisieren Serial_print_string ("Befehl eingeben"); // einen String drucken Serial_newline (); // gehe zur nächsten Zeile

Wenn wir zur Endlos- while-Schleife übergehen , verwenden wir die Funktion Serial_available , um zu überprüfen, ob serielle Daten eingehen. Wenn ja, lesen und speichern wir es in einer Variablen namens ch und drucken es auch mit Serial_print . Wenn der empfangene Wert 0 ist, schalten wir die LED aus und wenn er 1 ist, schalten wir die LED ein

if (Serial_available ()) {Serial_print_string ("Sie haben gedrückt:"); ch = Serial_read_char (); Serial_print_char (ch); Serial_newline (); if (ch == '0') GPIO_WriteHigh (test_LED); // LED AUS wenn (ch == '1') GPIO_WriteLow (test_LED); // LED leuchtet}

Damit ist die Programmierung für dieses Tutorial abgeschlossen. Laden Sie einfach den unten auf dieser Seite angegebenen Code hoch und Sie sollten in der Lage sein, die LED vom seriellen Monitor aus zu steuern.

Steuer-LED vom seriellen Monitor

Sobald Sie den Code hochgeladen haben, können Sie jeden seriellen Monitor mit 9600 Baudraten öffnen. Ich habe den seriellen Arduino-Monitor selbst verwendet, um die Verwendung zu vereinfachen. Drücken Sie die Reset-Taste und Sie sollten die Meldung "Geben Sie einen Befehl ein" sehen. Wenn Sie dann 1 eingeben und die Eingabetaste drücken, sollte sich die integrierte LED einschalten, ähnlich wie bei 0, sollte sie sich ausschalten.

Die vollständige Arbeit finden Sie in dem Video, das unten auf dieser Seite verlinkt ist. Wenn Sie Fragen haben, hinterlassen Sie diese bitte im Kommentarbereich. Sie können auch unsere Foren verwenden, um andere technische Fragen zu stellen.

STM8S Serial Library Deeper Look

Für diejenigen Neugierigen, die wissen möchten, was tatsächlich in der STM8S103F3_Serial- Header-Datei passiert, lesen Sie weiter….

Diese Header-Datei eignet sich gut für die Programmierung auf Anfängerebene. Wenn Sie jedoch eine andere Version des STM8S-Controllers verwenden oder nach erweiterten Optionen suchen, möchten Sie diesen Header möglicherweise ein wenig optimieren oder direkt mit SPL-Bibliotheken arbeiten. Ich habe diese Header-Datei nur als Reife von der UART1-Header-Datei geschrieben. Die Erklärung meiner Header-Datei lautet wie folgt.

Lesen eines Zeichens vom seriellen Monitor

Diese Funktion hilft beim Lesen eines einzelnen Zeichens, das vom seriellen Monitor an den Mikrocontroller gesendet wurde.

char Serial_read_char (void) {while (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); return (UART1_ReceiveData8 ()); }}

Wir warten, bis das RXE-Flag gesetzt ist, um den Empfang abzuschließen, und löschen dann das Flag, um den Empfang zu bestätigen. Schließlich senden wir die empfangenen 8-Bit-Daten als Ergebnis dieser Funktion.

Drucken eines Zeichens auf dem seriellen Monitor

Diese Funktion überträgt ein einzelnes Zeichen von einem Mikrocontroller an den seriellen Monitor.

void Serial_print_char (Zeichenwert) {UART1_SendData8 (Wert); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // warte auf das Senden}

Die Funktion schreibt einfach den 8-Bit-Wert und wartet, bis die Übertragung abgeschlossen ist, indem sie UART1_FLAG_TXE auf SET überprüft

Serielle Kommunikation initialisieren

Diese Funktion initialisiert die serielle Kommunikation mit der erforderlichen Baudrate.

void Serial_begin (uint32_t baud_rate) {GPIO_Init (GPIOD, GPIO_PIN_5, GPIO_MODE_OUT_PP_HIGH_FAST); GPIO_Init (GPIOD, GPIO_PIN_6, GPIO_MODE_IN_PU_NO_IT); UART1_DeInit (); // UART-Peripheriegeräte initialisieren UART1_Init (Baudrate, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO, UART1_SYNCMODE_CLOCK_DISABLE, UART1_MODE_TXRX_ENABLE); // (BaudRate, Wordlegth, StopBits, Parität, SyncMode, Modus) UART1_Cmd (ENABLE); }}

Neben der Baudrate müssen für die serielle Kommunikation noch andere Parameter eingestellt werden, z. B. die Anzahl der Datenbits, die Anzahl der Stoppbits, die Parität usw. Die häufigste (ähnlich wie bei Arduino) sind die 8-Bit-Daten mit einem Stoppbit und ohne Parität und daher ist dies die Standardeinstellung. Sie können es bei Bedarf ändern.

Drucken einer Ganzzahl auf den seriellen Monitor

Wenn wir zum Debuggen oder Überwachen einen seriellen Monitor verwenden, möchten wir meistens eine Variable vom Typ int auf den seriellen Monitor drucken. Diese Funktion macht genau das

void Serial_print_int (int number) // Funktion zum Drucken des int-Werts auf den seriellen Monitor {char count = 0; char digit = ""; while (number! = 0) // teile das int in char array {digit = number% 10; count ++; Nummer = Nummer / 10; } while (count! = 0) // Zeichenarray in die richtige Richtung drucken {UART1_SendData8 (Ziffer + 0x30); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // warte auf das Senden count--; }}

Es nimmt einen ganzzahligen Wert an und konvertiert ihn in der ersten while-Schleife in ein Zeichenarray. In der zweiten while-Schleife senden wir jedes der Zeichen ähnlich unserer Druckzeichenfunktion.

Neue Zeile drucken

Dies ist eine einfache Funktion zum Drucken einer neuen Zeile. Der Hex-Wert dafür ist "0x0a". Wir senden ihn nur mit dem 8-Bit-Sendebefehl.

void Serial_newline (void) {UART1_SendData8 (0x0a); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // warte auf das Senden}

Drucken einer Zeichenfolge auf dem seriellen Monitor

Eine weitere nützliche Funktion besteht darin, Zeichenfolgen tatsächlich auf dem seriellen Monitor zu drucken.

void Serial_print_string (char string) {. char i = 0; while (string! = 0x00) {UART1_SendData8 (string); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); i ++; }}

Auch diese Funktion konvertiert die Zeichenfolge in ein char-Array und sendet jedes Zeichen. Wie wir wissen, wird das Ende aller Zeichenfolgen null sein. Wir müssen also nur die Zeichen weiter durchlaufen und übertragen, bis wir die Null 0x00 erreichen.

Überprüfen, ob serielle Daten zum Lesen verfügbar sind

Diese Funktion prüft, ob sich serielle Daten im Puffer befinden, die zum Lesen bereit sind.

bool Serial_available () {if (UART1_GetFlagStatus (UART1_FLAG_RXNE) == TRUE) return TRUE; sonst return FALSE; }}

Es prüft auf das Flag UART1_FLAG_RXNE . Wenn es wahr ist, gibt es wahr zurück und wenn es nicht wahr ist, gibt es falsch zurück.