- Soros kommunikáció az STM8S103F3P6-on
- Soros kommunikációs csapok az STM8S103F3P6-on
- Áramkör az STM8S soros kommunikációhoz
- STVD beállítása a soros kommunikációhoz
- Az STM8S programozása a soros kommunikációhoz
- LED vezérlése soros monitorról
- STM8S soros könyvtár mélyebb megjelenés
Az új mikrovezérlő programozása gyakran hosszabb időt vesz igénybe az új regisztráció-kezelési módszerek miatt, és nem tudva, hogy mi a bit pontosan mit csinál. Ugyanez vonatkozik a hibakeresésre is, szó nélkül. Ezért a programozók gyakran használnak töréspontokat a kódjukban, és egy hibakereső segítségével lépnek át rajta. De a hibakereső használatához további hardverre (a legtöbbször drágábbra) és további időre lehet szükség. Arduino rajongói fiúként egy dologban mindannyian egyetértünk, hogy a sorozatnyomtatási utasításokat használjuk a hibakereséshez és a kódunk megértéséhez sokkal könnyebbé válik az élet. Mit tudunk ugyanezt megismételni az STM8-on kozmikus C fordítóval és SPL könyvtárakkal? Nos, ez nagyon is lehetséges, és pontosan ezt fogjuk tenni a bemutató sorozatunk harmadik bemutatójában.Az STM8S (1. oktatóanyag) és az STM8S GPIO vezérlés (2. oktatóanyag) használatának megkezdését is ellenőrizheti, ha itt teljesen új vagy. Megvizsgáltuk az STM8S programozásának lehetőségét is az Arduinóval a gyors indítás érdekében. Mindezek mellett menjünk be a bemutatóba.
Soros kommunikáció az STM8S103F3P6-on
Az STM8S103F3P6 adatlapjából láthatjuk, hogy 8 bites vezérlőnk számos különböző módban támogatja az UART kommunikációt. A vezérlő rendelkezik egy óra kimeneti tűvel a szinkron UART kommunikációhoz, és támogatja a SmarCard, az IrDA és a LIN funkciókat is. De ebben a bemutatóban egyiket sem fogjuk feltárni, csak azért, hogy távol tartsuk magunkat a bonyolultságtól. Megtanuljuk, hogyan kell egyszerű UART-t írni és olvasni.
Az oktatóanyag tartalmaz egy fejlécfájlt is, amelynek neve stm8s103 serial.h , amely segítségével egyszerű UART parancsokat hajthat végre, mint például a Soros kezdés , Soros olvasás, Soros nyomtatás stb. és a soros monitorról is leolvasta a char-t. Az oktatóanyag végén vezérelhet egy LED-et a soros monitorról, és visszajelzést kaphat a LED állapotáról. A fent említett fejlécfájl az SPL könyvtáraktól függ, ezért ellenőrizze, hogy betartotta-e az első lépéseket bemutató oktatóanyagot.
Soros kommunikációs csapok az STM8S103F3P6-on
Kezdjük a hardver oldaláról. Gyorsan megnézve az alább megadott STM8S103F3P6 mikrovezérlő csatlakozóit, láthatjuk, hogy az 1., 2. és 3. tűt fogják használni az UART kommunikációhoz.
A három közül az 1. tű az UART órajel, amelyet csak a szinkron UART kommunikáció során használnak, ezért itt nem lesz rá szükség. A 2. érintkező az UART adó tűje, a 3. érintkező pedig az UART adó tűje. Ne feledje, hogy ezek a csapok analóg tűként vagy normál GPIO tűként is duplázódhatnak.
Áramkör az STM8S soros kommunikációhoz
A kapcsolási rajz itt nagyon egyszerű, a programozáshoz csatlakoztatnunk kell az ST-LINK 2-t és a soros adatok leolvasásához USB-TTL átalakítót. Ne feledje, hogy az STM8S vezérlőnk 3.3V logikai szinten működik, ezért ellenőrizze, hogy az USB to TTL átalakítója támogatja-e a 3.3V logikát is. A teljes kapcsolási rajz az alábbiakban látható.
Az ST-linket egy USB-porton, az USB-TTL átalakítót pedig a laptop egy másik USB-portján kell csatlakoztatnia, így egyszerre programozhatja és monitorozhatja az adatokat. Az UART kapcsolat egyszerű, csak csatlakoztassa az STM8S mikrovezérlő földelését és Rx / Tx csatlakozóját az USB-TTL átalakító Tx / Rx csatlakozóihoz. Itt tápláltam a vezérlőt az ST-Link Vcc tűjével, és nyitva hagytam a TTL átalakító vss tűjét, ezt megteheti fordítva is. Az USB-TTL átalakítónak sokféle típusa van a piacon, csak győződjön meg arról, hogy képes működni a 3,3 V-os logikai jeleken, és egyszerűen megkeresi a Tx, Rx és GND tűket, és létrehozza a fent bemutatott kapcsolatot. Az alábbiakban bemutatom a hardver beállításomat.
A soros kommunikáció érdekében megadtuk az STM8S_Serial.h fejlécfájlt. A fejlécfájl segítségével egyszerű Arduino-szerű funkciókat hajthat végre a soros kommunikációhoz.
A projekt összes szükséges fájlját megtalálhatja az STM8S103F3_SPL Github oldalon. Ha csak erre a fejlécfájlra van szüksége, letöltheti az alábbi linkről.
Töltse le az STM8S_Serial.h fájlt
STVD beállítása a soros kommunikációhoz
A soros kommunikációhoz sokakat fogunk használni a korábban tárgyalt STM8S_Serial.h fejlécfájl funkcióval. De a könyvtárnak más függőségei vannak, sok az SPL UART és az Óra kapcsolatos fejléc és C fájl. Tehát ettől a ponttól kezdve jobb, ha az összes fejléc és C fájlt belefoglaljuk a projektünkbe, hogy elkerüljük a fordítási hibákat. Az STVD munkakörnyezetem így néz ki.
Győződjön meg róla, hogy az összes SPL forrásfájlt és a Fájlokat is belefoglalta, mint az első bemutatónkban. És azt is ellenőrizze, hogy hozzáadta-e az stm8s103_serial.h fejlécfájlt. Ehhez a fejléchez nincs C fájl.
Az STM8S programozása a soros kommunikációhoz
Miután elkészült az STVD projekt beállítása, elkezdhetjük írni a kódunkat a main.c fájlba. Az oktatóanyag teljes kódja az oldal alján található. A magyarázat a következő.
Az első lépés a szükséges fejlécfájlok felvétele, itt hozzáadtam a fő fejlécfájlt (stm8s) és az imént letöltött stm8s_103_serial fejlécfájlt.
// Kötelező fejlécek #include "STM8S.h" #include "stm8s103_serial.h" //https://github.com/CircuitDigest/STM8S103F3_SPL/blob/master/stm8s103%20Libraries/stm8s103_Serial.h
Ezután a tervezési makrókat használjuk a bemeneti és kimeneti csapok megadásához. Itt csak a fedélzeti LED vezérlését lehet ellenőrizni, amely a B port pin5-éhez csatlakozik, ezért nevet adunk neki, mint test_LED .
#define test_LED GPIOB, GPIO_PIN_5 // teszt LED csatlakozik a PB5-hez
A fő funkció belsejében haladva meghatározzuk a csapot kimenetként. Ha még nem ismeri az alapvető GPIO funkciókat, térjen vissza az STM8S GPIO oktatóanyagra.
// Pin defanitions // A PB5 deklarálása push pull kimeneti kimenetként GPIO_Init (teszt_LED, GPIO_MODE_OUT_PP_LOW_SLOW);
Ezután inicializáljuk soros kommunikációs portjainkat 9600 baud sebességgel. Azok számára, akik újak, a 9600 az a sebesség, amellyel az adatbiteket átviszik a kommunikáció során. Ha itt állítja be a 9600 értéket, akkor ugyanezt be kell állítania a felügyeleti szoftverben is. Ezután egy “Enter command” karakterláncot is kinyomtatunk, és továbblépünk a következő sorra.
Sorozat kezdete (9600); // Soros kommunikáció inicializálása 9600 baud sebességgel Serial_print_string ("Enter parancs"); // karakterlánc nyomtatása Serial_newline (); // lépés a következő sorra
A végtelen idő ciklusra továbblépve a Serial_available függvény segítségével ellenőrizzük, hogy van-e bejövő soros adat. Ha igen, akkor elolvassuk és elmentjük egy ch nevű változóba, és ugyanezt kinyomtatjuk a Serial_print használatával is . Majd ha a kapott érték 0, akkor kikapcsoljuk a LED-et, és ha 1, akkor bekapcsoljuk a LED-et
if (Serial_available ()) {Serial_print_string ("Megnyomta:"); ch = Soros_olvasott_jel (); Soros_nyomtatott_char (ch); Soros_új sor (); if (ch == '0') GPIO_WriteHigh (teszt_LED); // LED KI, ha (ch == '1') GPIO_WriteLow (teszt_LED); // LED világít}
Ezzel az oktatóanyag programozása befejeződött, csak töltse fel az oldal alján megadott kódot, és képesnek kell lennie a LED vezérlésére a soros monitorról.
LED vezérlése soros monitorról
A kód feltöltése után bármelyik soros monitort 9600 baud sebességgel megnyithatja. Magát az Arduino soros monitort a könnyű használat érdekében használtam. Nyomja meg a reset gombot, és látnia kell az „Írjon be egy parancsot” üzenetet. Majd ha beír 1-t és megnyomja az Enter-t, akkor a fedélzeti lednek bekapcsolnia kell, hasonlóan a 0-hoz, ki kell kapcsolnia.
A teljes munka megtalálható az oldal alján linkelt videóban. Ha bármilyen kérdése van, kérjük, hagyja őket a megjegyzés részben. Fórumunkat felhasználhatja egyéb technikai kérdések feltöltésére is.
STM8S soros könyvtár mélyebb megjelenés
Azoknak a kíváncsi elméknek, akik szeretnék tudni, mi történik valójában az STM8S103F3_Serial fejlécfájlban, olvassa el a következőt :.
Ez a fejlécfájl jól használható a kezdő szintű programozáshoz, de ha az STM8S vezérlő másik verzióját használja, vagy speciális beállításokat keres, akkor érdemes kicsit módosítania ezt a fejlécet, vagy közvetlenül működnie az SPL könyvtárakkal. Ezt a fejlécfájlt épp akkor készítettem, amikor megérettem az UART1 fejlécfájlból, a fejlécfájlom magyarázata a következő.
Karakter olvasása a Soros monitorról
Ez a funkció segít egyetlen karakter beolvasásában, amelyet a soros monitorról küldtek a mikrovezérlőnek.
char Serial_read_char (void) {while (UART1_GetFlagStatus (UART1_FLAG_RXE) == RESET); UART1_ClearFlag (UART1_FLAG_RXNE); return (UART1_ReceiveData8 ()); }
Várjuk, amíg az RXE jelző BE van állítva a vétel befejezéséhez, majd töröljük a jelet a vétel nyugtázása érdekében. Végül a kapott 8 bites adatokat elküldjük ennek a funkciónak az eredményeként.
Karakter nyomtatása a Serial Monitorra
Ez a funkció egyetlen karaktert továbbít a mikrokontrollerről a soros monitorra.
void Serial_print_char (char érték) {UART1_SendData8 (érték); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // várakozás a küldésre}
A függvény egyszerűen megírja a 8 bites értéket, és az UART1_FLAG_TXE- től a SET-ig ellenőrizve várja az átvitel befejezését.
A soros kommunikáció inicializálása
Ez a funkció inicializálja a soros kommunikációt a szükséges átviteli sebességgel.
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 (); // Az UART perifériák inicializálása UART1_Init (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); }
Az adatátviteli sebesség mellett más paramétereket is meg kell adni a soros kommunikációhoz, mint például az adatbitek száma, a stopbitek száma, a paritás stb. A leggyakoribb (az Arduino-hoz hasonlóan) a 8 bites adat egy stop bittel és nincs paritás, ezért ez lesz az alapértelmezett beállítás. Szükség esetén módosíthatja.
Egész szám nyomtatása a soros monitorra
Legtöbbször, ha soros monitort használunk hibakereséshez vagy figyeléshez, akkor érdemes egy int típusú változót kinyomtatni a soros monitorra. Ez a funkció pontosan ezt teszi
void Serial_print_int (int szám) // Funkció az int érték kinyomtatására a soros monitorra {char count = 0; char digit = ""; while (szám! = 0) // osztja az int-t tömb {számjegy = szám% 10; szám ++; szám = szám / 10; } while (count! = 0) // a char tömb helyes nyomtatása {UART1_SendData8 (számjegy + 0x30); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // várja meg a count küldését; }}
Egy egész értéket vesz fel, és az első while ciklusban karaktertömbökké alakítja, majd a második while ciklusban a karakterek mindegyikét elküldjük, hasonlóan a print char függvényünkhöz.
Új sor nyomtatása
Ez egy egyszerű funkció új vonal kinyomtatására. Ennek hatértéke „0x0a”, csak átküldjük a 8 bites továbbítási paranccsal.
void Serial_newline (void) {UART1_SendData8 (0x0a); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); // várakozás a küldésre}
Karakterlánc nyomtatása soros monitorra
Egy másik hasznos funkció a húrok tényleges nyomtatása a soros monitoron.
void Serial_print_string (char string) {. char i = 0; while (karakterlánc! = 0x00) {UART1_SendData8 (karakterlánc); while (UART1_GetFlagStatus (UART1_FLAG_TXE) == RESET); i ++; }}
Ez a függvény megint átalakítja a karakterláncot char tömbgé, és elküldi az egyes karaktereket. Mint tudjuk, az összes karakterlánc vége semmis. Tehát csak folytatnunk kell a karakterek áthaladását és továbbítását, amíg el nem érjük a 0x00 értéket.
Annak ellenőrzése, hogy rendelkezésre állnak-e soros adatok
Ez a funkció ellenőrzi, hogy van-e soros adat a pufferben olvasásra készen.
bool Serial_available () {if (UART1_GetFlagStatus (UART1_FLAG_RXNE) == IGAZ) visszatér IGAZ; else return FALSE; }
Ellenőrzi az UART1_FLAG_RXNE jelzőt , ha igaz, akkor igaz, ha pedig nem, akkor hamis.