- Seriële communicatie op STM8S103F3P6
- Seriële communicatiepennen op STM8S103F3P6
- Schakelschema voor STM8S seriële communicatie
- STVD instellen voor seriële communicatie
- STM8S programmeren voor seriële communicatie
- Controlerende LED van seriële monitor
- STM8S seriële bibliotheek diepere uitstraling
Het programmeren van een nieuwe microcontroller duurt vaak langer vanwege de nieuwe methoden voor het afhandelen van registers en niet weten welk bit precies wat doet. Hetzelfde geldt voor het opsporen van fouten. Dit is de reden waarom programmeurs vaak breekpunten in hun code gebruiken en er doorheen lopen met behulp van een debugger. Maar voor het gebruik van een debugger is wellicht extra hardware nodig (meestal duur) en ook extra tijd. Als Arduino-fanboy kunnen we het er allemaal over eens zijn dat het gebruik van seriële printinstructies voor foutopsporing en het begrijpen van onze code het leven een stuk eenvoudiger maakt. Wat kunnen we hetzelfde repliceren op STM8's met cosmic C-compiler en SPL-bibliotheken? Nou, het is heel goed mogelijk, en dat is precies wat we gaan doen in deze derde tutorial van onze tutorialserie.Je checkt ook het aan de slag gaan met STM8S (tutorial 1) en STM8S GPIO control (tutorial 2) als je hier helemaal nieuw bent. We hebben ook de mogelijkheid onderzocht om STM8S te programmeren met Arduino voor snelle starters. Dat gezegd hebbende, laten we naar de tutorial gaan.
Seriële communicatie op STM8S103F3P6
Uit de datasheet van STM8S103F3P6 kunnen we zien dat onze 8-bits controller UART-communicatie in veel verschillende modi ondersteunt. De controller heeft ook een klokuitgangspen voor synchrone UART-communicatie en ondersteunt ook SmarCard, IrDA en LIN. Maar we zullen niets van dat alles in deze tutorial onderzoeken om uit de buurt te blijven van complexiteit. We zullen leren hoe u eenvoudig UART-lezen en schrijven kunt doen.
De tutorial biedt ook een header-bestand met de naam stm8s103 serial.h waarmee je eenvoudige UART-opdrachten kunt uitvoeren zoals Serieel begin, Serieel lezen, serieel afdrukken, enz. In feite kun je char, int en string naar de seriële monitor afdrukken en lees ook char van de seriële monitor. Aan het einde van deze tutorial kunt u een LED vanaf de seriële monitor bedienen en feedback krijgen over de status van de LED. Het hierboven genoemde header-bestand is afhankelijk van de SPL-bibliotheken, dus zorg ervoor dat u de tutorial 'Aan de slag' hebt gevolgd.
Seriële communicatiepennen op STM8S103F3P6
Laten we beginnen met de hardware-kant. Als we de pinouts op de STM8S103F3P6- microcontroller hieronder snel bekijken, kunnen we zien dat de pinnen 1, 2 en 3 zullen worden gebruikt voor UART-communicatie.
Van de drie is pin 1 de UART-klokpen die alleen wordt gebruikt tijdens synchrone UART-communicatie, dus we hebben deze hier niet nodig. Pin 2 is de UART Transmitter pin en Pin 3 is de UART Receiver pin. Houd er rekening mee dat deze pinnen ook kunnen worden gebruikt als analoge pin of normale GPIO-pin.
Schakelschema voor STM8S seriële communicatie
Het schakelschema is hier heel eenvoudig, we moeten onze ST-LINK 2 aansluiten voor het programmeren en een USB naar TTL-converter voor het lezen van seriële gegevens. Houd er rekening mee dat onze STM8S-controller werkt op een logisch niveau van 3,3 V, dus zorg ervoor dat uw USB-naar-TTL-converter ook 3,3 V-logica ondersteunt. Het volledige schakelschema wordt hieronder weergegeven.
U moet uw ST-link in de ene USB-poort en de USB-naar-TTL-converter in een andere USB-poort van uw laptop aansluiten, zodat u tegelijkertijd gegevens kunt programmeren en monitoren. De UART-verbinding is eenvoudig, sluit gewoon de aarde en de Rx / Tx-pin van uw STM8S-microcontroller aan op de Tx / Rx-pinnen van de USB naar TTL-converter. Hier heb ik de controller van stroom voorzien met de Vcc pin van ST-Link en heb ik de vss pin van TTL converter open gelaten, je kunt dit ook andersom doen. Er zijn veel soorten USB naar TTL-converters op de markt, zorg er gewoon voor dat deze kunnen werken op 3,3V logische signalen en zoek eenvoudig naar Tx-, Rx- en GND-pinnen en maak de hierboven getoonde verbinding. Mijn hardware-installatie wordt hieronder weergegeven.
Om een seriële communicatiemethode te maken, hebben we het STM8S_Serial.h- headerbestand geleverd. Met behulp van dit headerbestand kunt u eenvoudige Arduino-achtige functies uitvoeren voor seriële communicatie.
Je kunt alle vereiste bestanden voor dit project vinden op onze STM8S103F3_SPL Github-pagina. Als u alleen dit specifieke header-bestand nodig heeft, kunt u het downloaden via de onderstaande link.
Download STM8S_Serial.h
STVD instellen voor seriële communicatie
Om met seriële communicatie te werken, zullen we er veel gebruiken met behulp van de STM8S_Serial.h header-bestandsfunctie die we eerder hebben besproken. Maar de bibliotheek heeft andere afhankelijkheden, veel van de SPL UART- en Clock-gerelateerde header- en C-bestanden. Dus vanaf dit punt is het beter om alle header- en C-bestanden in ons project op te nemen om compilatiefouten te voorkomen. Mijn STVD-werkomgeving ziet er zo uit.
Zorg ervoor dat u alle SPL-bronbestanden en het bestand Inclusief hebt opgenomen zoals we deden in onze eerste zelfstudie. En zorg er ook voor dat u het headerbestand stm8s103_serial.h hebt toegevoegd. Er is geen C-bestand voor deze header.
STM8S programmeren voor seriële communicatie
Zodra de STVD-projectconfiguratie klaar is, kunnen we beginnen met het schrijven van onze code in het main.c- bestand. De volledige code voor deze tutorial vind je onderaan deze pagina. De uitleg is als volgt.
De eerste stap is om de vereiste header-bestanden op te nemen, hier heb ik het main header-bestand (stm8s) en het stm8s_103_serial header-bestand toegevoegd dat we zojuist hebben gedownload.
// Vereiste kopteksten #include "STM8S.h" #include "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3_SPL/blob/master/stm8s103%20Libraries/stm8s103_Serial.h
Vervolgens gebruiken we de ontwerpmacro's om de invoer- en uitvoerpinnen te specificeren. Hier zal alleen de ingebouwde LED worden bediend die is aangesloten op pin5 van poort B, dus we geven deze een naam als test_LED .
#define test_LED GPIOB, GPIO_PIN_5 // test-LED is verbonden met PB5
Als we verder gaan met de hoofdfunctie, zullen we de pin als een uitvoer definiëren. Als u niet bekend bent met de basis GPIO-functies, kunt u terugvallen op de STM8S GPIO-tutorial.
// Pin defanitions // Declareer PB5 als push pull Output pin GPIO_Init (test_LED, GPIO_MODE_OUT_PP_LOW_SLOW);
Vervolgens initialiseren we onze seriële communicatiepoorten met 9600 baudrates. Voor degenen die nieuw zijn, is 9600 de snelheid waarmee de databits tijdens de communicatie worden overgedragen. Als u hier 9600 instelt, moet u hetzelfde ook instellen op de bewakingssoftware. Dan drukken we ook een string "Enter commando" af en gaan we verder met de volgende regel.
Serial_begin (9600); // Initialiseer seriële communicatie op 9600 baudrate Serial_print_string ("Enter-commando"); // print een string Serial_newline (); // ga naar de volgende regel
We gaan verder met de oneindige while-lus en gebruiken de functie Serial_available om te controleren of er inkomende seriële gegevens zijn. Zo ja, dan lezen we het en slaan we het op in een variabele met de naam ch en we drukken hetzelfde ook af met Serial_print . Als de ontvangen waarde 0 is, schakelen we de LED uit en als het 1 is, schakelen we de LED in
if (Serial_available ()) {Serial_print_string ("Je hebt op:" gedrukt); ch = Serial_read_char (); Serial_print_char (ch); Serial_newline (); if (ch == '0') GPIO_WriteHigh (test_LED); // LED UIT als (ch == '1') GPIO_WriteLow (test_LED); // LED AAN}
Hiermee is het programmeren voor deze tutorial voltooid, upload gewoon de code die onderaan deze pagina wordt gegeven en je zou de LED moeten kunnen bedienen vanaf de seriële monitor.
Controlerende LED van seriële monitor
Nadat u de code heeft geüpload, kunt u elke seriële monitor openen met 9600 baudrates. Ik heb de Arduino seriële monitor zelf gebruikt vanwege het gebruiksgemak. Druk op de resetknop en u zou het bericht "Voer een commando in" moeten zien. Als u vervolgens 1 invoert en op enter drukt, moet de ingebouwde led gaan branden, op dezelfde manier voor 0, deze moet uitgaan.
De volledige werking is te vinden in de video die onderaan deze pagina is gelinkt. Als u vragen heeft, laat deze dan achter in het commentaargedeelte. U kunt ook onze forums gebruiken om andere technische vragen te stellen.
STM8S seriële bibliotheek diepere uitstraling
Voor die nieuwsgierige geesten die willen weten wat er werkelijk gebeurt in het STM8S103F3_Serial header-bestand, lees verder….
Dit header-bestand werkt goed voor programmeren op beginnersniveau, maar als je een andere versie van de STM8S-controller gebruikt of op zoek bent naar een aantal geavanceerde opties, wil je deze header misschien een beetje aanpassen of direct met SPL-bibliotheken werken. Ik schreef dit header-bestand net als een rijpe off van het UART1-header-bestand, de uitleg van mijn header-bestand is als volgt.
Een personage lezen van Serial Monitor
Deze functie helpt om een enkel teken te lezen dat vanaf de seriële monitor naar de microcontroller is gestuurd.
char Serial_read_char (void) {while (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); terug (UART1_ReceiveData8 ()); }
We wachten tot de RXE-vlag is ingesteld om de ontvangst te voltooien en wissen vervolgens de vlag om de ontvangst te bevestigen. Ten slotte verzenden we de ontvangen 8-bits gegevens als resultaat van deze functie.
Een teken afdrukken naar de seriële monitor
Deze functie verzendt een enkel teken van een microcontroller naar de seriële monitor.
void Serial_print_char (char-waarde) {UART1_SendData8 (waarde); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // wacht op verzending}
De functie schrijft eenvoudig de 8-bits waarde en wacht tot de verzending is voltooid door de UART1_FLAG_TXE naar SET te controleren
Seriële communicatie initialiseren
Deze functie initialiseert seriële communicatie met de vereiste baudrate.
ongeldig 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-randapparatuur UART1_Init deinitialiseren (baud_rate, UART1_WORDLENGTH_8D, UART1_STOPBITS_1, UART1_PARITY_NO, UART1_SYNCMODE_CLOCK_DISABLE, UART1_MODE_TXRX_ENABLE); // (BaudRate, Wordlegth, StopBits, Parity, SyncMode, Mode) UART1_Cmd (ENABLE); }
Naast de baudrate zijn er nog andere parameters die moeten worden ingesteld voor seriële communicatie, zoals het aantal databits, aantal stopbits, pariteit, etc. De meest voorkomende (vergelijkbaar met Arduino) is de 8-bit data met één stopbit en geen pariteit en dat is dus de standaardinstelling. U kunt deze indien nodig wijzigen.
Een geheel getal naar een seriële monitor afdrukken
Als we een seriële monitor gebruiken voor foutopsporing of monitoring, willen we meestal een variabele van het type int naar de seriële monitor afdrukken. Deze functie doet precies dat
void Serial_print_int (int nummer) // Functie om int waarde af te drukken naar seriële monitor {char count = 0; char digit = ""; while (number! = 0) // split de int naar char array {digit = number% 10; tel ++; nummer = nummer / 10; } while (count! = 0) // print char-array in de juiste richting {UART1_SendData8 (digit + 0x30); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // wacht op het verzenden van count--; }}
Het neemt een integerwaarde op en converteert deze naar een tekenarray in de eerste while-lus, en vervolgens in de tweede while-lus, zullen we elk van de karakters verzenden, vergelijkbaar met onze print char-functie.
Een nieuwe regel afdrukken
Dit is een eenvoudige functie om een nieuwe regel af te drukken. De hexadecimale waarde om dat te doen is "0x0a", we sturen het gewoon door met behulp van het 8-bits verzendcommando.
void Serial_newline (ongeldig) {UART1_SendData8 (0x0a); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // wacht op verzending}
Een string naar een seriële monitor afdrukken
Een andere handige functie is om daadwerkelijk strings op de seriële monitor af te drukken.
void Serial_print_string (tekenreeks) {. char i = 0; while (string! = 0x00) {UART1_SendData8 (string); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); i ++; }}
Nogmaals, deze functie converteert ook de string naar een char-array en verzendt elk teken. Zoals we weten, zullen alle strings end null zijn. Dus we hoeven alleen maar de karakters te doorlopen en te verzenden totdat we de nul 0x00 bereiken.
Controleren of seriële gegevens beschikbaar zijn om te lezen
Deze functie controleert of er seriële gegevens in de buffer staan die klaar zijn om gelezen te worden.
bool Serial_available () {if (UART1_GetFlagStatus (UART1_FLAG_RXNE) == TRUE) retourneert TRUE; anders terug ONWAAR; }
Het controleert op de vlag UART1_FLAG_RXNE , als het waar is, retourneert het waar en als dat niet het geval is, wordt onwaar geretourneerd.