Tento tutoriál si neklade za cíl vyčerpávajícím způsobem popsat problematiku STM32. Jde mi o to jen vám předat některé zajímavé informace, které by se vám mohli hodit při výběru mikrokontroléru, vývojového kitu, vývojového prostředí a stylu programování. Nemohu vám tedy bohužel zaručit to, že si nějaké informace nebudete muset dohledat sami. Dočtete se zde:
Proč začít programovat STM32 ? Ta otázka by se na první pohled mohla zdát zbytečná, existuje přece spoustu dobrých důvodů proč ARMy, proč STM32. Mě to až tak zřejmé nepřipadá, ona je totiž konkurence velmi bohatá. Pokud vám jde pouze o výpočetní výkon a nepotřebujete nějak výrazně úzkou spolupráci s hardwarem, čeká tu na vás s otevřenou náručí Raspberry Pi. Naopak pokud nepotřebujete výpočetní výkon čekají na vás davy osmibitových mikrokontrolerů (AVR,PIC,STM8 atd.). Pokusíte-li se použít STM32 na úkol stvořený pro raspberry přidáváte si práci s programováním, protože nebudete mít k dispozici prostředky Linuxu. Použijete-li STM32 na jednoduchý úkol pro osmibitový mikrokontrolér, zbytečně ztrácíte čas s učením složité platformy a s její náročnější konfigurací. Můžeme se na to podívat třeba následujícím způsobem. Co se výpočetního výkonu týče, vítězí Raspberry, za ním jsou STMka a nakonec 8bity. Podíváme-li se na schopnosti periferií, tedy schopnost úzce spolupracovat s hardwarem, vítězí STM32, za nimi jsou 8bity a teprve nakonec je Raspberry. Dalším faktorem je spotřeba. Autonomním projektům napájeným ze solárka nebo z akumulátorů nebude odběr Raspberry (0.1-0.5A) asi moc vyhovovat, STM32 i 8bity mají srovnatelné schopnosti běžet se spotřebou několika mikroapér. Důležitý faktor bude hrát i složitost programování a náročnost učení, kterou ale neumím objektivně porovnávat, protože závisí na předešlých zkušenostech. Jinak řečeno programátorům z PC bude Raspberry vyhovovat víc. No a nakonec nesmíme zapomenout na cenu. Raspberry je drahé, STM32 i 8bity stojí stejné peníze a začínají někde na ceně za jedno nebo dvě piva. Já osobně využívám STM32 hlavně v aplikacích úzce spjatých s hardwarem. Tedy v projektech, kde jde o přesné časování, rychlé reakce a schopnost pracovat s obecnou elektronikou. Krom tohoto relativně pragmatického přístupu existuje ještě jeden zajímavý důvod proč s STM32 začínat a to je zvědavost. Programovat totiž můžete klidně pro zábavu :)
Obchodní politika ST Microelectronics je velice vstřícná k amatérům. Největší zásluhu na tom mají vývojové kity Discovery a Nucleo. Nejlevnější stojí okolo 250kč. Za ty peníze je mnozí z vás rovnou zabudují do svého zařízení a nebudou se obtěžovat s výrobou vlastní desky plošných spojů. To by ale ani zdaleka nebylo všechno. To nejlepší je totiž fakt, že každý z těchto kitů na sobě nese plnohodnotný debugger. Tedy hardware schopný programovat a ladit jakýkoli jiný čip. Můžete si tedy klidně vyrobit vlastní desku a osadit ji libovolným čipem STM32, nebo si nakoupit za pár korun desky z Číny (jako na obrázcích níže) a ladit svůj program na nich s použitím libovolného vývojového kitu. Jen pro představu, nejlevnější debugger například pro platformu AVR stojí mezi 1500-2000.
Vývojové kity o nichž je řeč se dělí do tří typů. První a nejstarší z nich jsou vývojové desky Discovery. Jejich výbava je od té nejchudší (jako například STM32VLDiscovery nebo STM32L100 Discovery) až po tu nejbohatší (STM32F429 Discovery s TFT displejem nebo STM32L0538 Discovery s displejem E-Ink). Další kategorii tvoří desky Nucleo-64 a Nucleo-144 (např NUCLEO-F302 nebo NUCLEO-F767), které krom klasických kolíkových řad pro připojení čehokoli obsahují také "arduino" konektory, jež se navzdory mnoha nevýhodám stávají celkem normou. Všechny tyto kity obsahují už dříve zmíněný plnohodnotný debugger/programátor nazývaný ST-LINK. U Nucleo kitů je dokonce možné ST-LINK fyzicky oddělit od desky. Poslední kategorii pak tvoří desky Nucleo-32 jako například NUCLEO-F303K8. Ty na sobě také obsahují ST-LINK, ale není jej možné využít k programování externích STM32. Kit je totiž designovaný jako miniaturní a počítá se s tím že jej jako celek zanecháte v cílové aplikaci.
K programování a debuggování slouží na kitech rozhraní SWD (Serial Wire Debugging). To je tvořeno 4mi linkami, GND, VCC, SWCLK a SWDIO. Na drtivé většině kitů je rozhraní obohaceno ještě o RST a SWO, o jehož použití pro ladění aplikace se dozvíte později. Vyjmutím dvou jumperů (CN2) odpojíte cílový čip na desce od ST-LINKu a SWD konektor (CN3) pak můžete připojit k vnějšímu STM32. Rozložení pinů SWD konektoru si můžete najít v datasheetu (z nějž pochází i obrázek níže). Musím vás ale upozornit na menší nedostatek kitu v roli stand-alone debuggeru. Discovery (a počítám že i Nucleo) kity jsou uzpůsobeny tak aby je bylo možné napájet jak z USB, tak z vnějšího 5V zdroje a stejně tak aby bylo možné přivést čipům vnější napájení 3.3V. Z toho důvodu je na desce několik diod, z nichž se jedna nachází za 3.3V stabilizátorem. Což má neblahý důsledek. Napětí označené jako 3V3 má ve skutečnosti hodnotu přibližně 3.0V a může kolísat s odběrem (úbytek napětí na diodě je závislý na proudu). To spolu nese i jisté úskalí při programování externích aplikací. Programovat čip běžící na napětí do 3.3V je bezproblémové. Problém nastane jen v situaci, kdy cílová aplikace běží na maximálním provozním napětí 3.6V (což asi většina z vás nikdy potřebovat nebude). Stejně tak má nestabilní napětí vliv na přesnost AD převodníku, protože tvoří jeho referenci. Ve většině případů vás to nebude nijak pálit. A pokud ano, dá se dioda přemostit kouskem drátu a problém je vyřešen.
ST-LINK přirozeně existuje i v samostatných variantách (zde) a stojí okolo 650kč. Je přirozeně bohatší a schopný programovat například i čipy STM8. Existuje i čínský klon ST-LINKu, který jsem ale neměl důvod nikdy vyzkoušet (k čemu také, když vám stačí libovolný vývojový kit). Nezanedbatelným pozitivem je existence multiplatformích vývojových prostředí a překladače bez omezení velikosti překládaného kódu (Ani jedno z toho před několika lety ještě neexistovalo) a celé řady podpůrných nástrojů jako je třeba CubeMX. Rešerši na toto téma, ale nechám na někom fundovanějším, protože jsem osobně měl možnost pracovat pouze v CoIDE a TrueSTUDIu (o něm více v závěru tutoriálu). Můžu ale potvrdit, že jsem viděl programovat STM32F0 na linuxu i s funkčním debuggerem.
Mikrokontroléry STM32 se dělí do rodin. Přehledný klikací seznam můžete najít zde. V seznamu stačí kliknout na vybranou rodinu a dostanete se na přehledné členění s tabulkovým výpisem všech periferií (např zde). Ve stručném úvodu se dočtete k čemu je složením periferií čip určen. Například čipy F0x0 (tedy F050 nebo F030) jsou v tzv. "Value line" tedy jde o nejlevnější čipy v dané třídě. Nebo například čipy F373 spadají do kategorie "precision measurment", protože mají ve výbavě 16bitové AD převodníky.
Další dělení probíhá podle kapacity paměti a typu pouzdra. Vybereme-li si tedy jednoho konkrétního člena rodiny F0, například čip F051, pořád existuje několik variant lišících se kapacitou paměti a počtem vývodů. K této informaci se opět dostanete jednoduchým kliknutím skrze dříve uvedený seznam na stránkách ST. Dostanete se tedy zde. Z tabulky kterou máte před sebou můžete vidět že první písmeno za názvem čipu STM32F051R určuje velikost pouzdra (64pin) a následující znak STM32F051R8 pak kapacitu paměti (64kB flash / 8kB RAM).
Nakonec, když si v této poslední tabulce vyberete konkrétní čip, dejme tomu STM32F051R8 a kliknete na něj, dostanete se k dokumentaci. Tedy sem. Čímž se dostáváme ke klíčové informaci. Datasheety jsou totiž dva (respektive čtyři). První dokument, tzv. "Datasheet", který je hned v úvodu stránky, obsahuje přehled periferií čipu, organizaci vývodů a třeba seznam elektrických parametrů. Nejčastěji do něj budete nahlížet právě kvůli organizaci vývodů. Dalším dokumentem je reference manual. Je to ten nejdelší a nejdůležitější dokument, obsahující detailní popis všech periferií, jejich registrů a ovládání. Do něj budete nahlížet asi nejčastěji. Reference manual bývá sdružený pro vícero čipů v rámci jedné rodiny. Pro které z nich je platný zjistíte hned v jeho nadpise. Dále pak existuje Errata sheet obsahující seznam chyb v čipu a způsobů jak je ošetřit. Jen pro přehlednost ještě uvedu poslední dokument, tzv Programming manual, který se váže k jádru (tomto případě Cortex M0) a je v něm dokumentace ke všem instrukcím procesoru a jeho přidruženým modulům. Často se do něj asi nepodíváte (nicméně je tam třeba dokumentace k Systicku a NVIC).
Tím bychom měli za sebou otázku dokumentace k jednotlivým mikrokontrolerům. Tím to ale nekončí, uniknout by vám neměla ani dokumentace k jednotlivým vývojovým kitům. Jestliže používáte Discovery nebo Nucleo moduly, je opět namístě poukázat na ten nejdůležitější z nich - User Manual (tento pro STM32F051 Discovery). V něm najdete kompletní popis Discovery kitu. Tedy přehlednou tabulku s popisem využití všech vývodů mikrokontroléru. Dále pak informace o možnostech hardwarových úprav kitu (skrze připravené pájecí propojky) a také kompletní schemata.
Do dokumentace ke knihovnám LL nebo HAL asi nebudete nahlížet tak často (obsahují stejné informace jako relativně kvalitní komentáře přímo v souborech knihoven), ale je dobré aby jste věděli že existují. K STM32F0 je můžete najít třeba zde. Vyplatí si pročíst si hlavně sekci o souborové struktuře aby jste byli schopni knihovny správně včlenit do projektu. Je trochu škoda, že ke knihovnám neexistuje žádný vysvětlující manuál. Ačkoli je název většiny funkcí samovysvětlující, občas narazíte na některou u které si nebudete jisti co k čertu vlastně dělá. A nezjistíte to ani po pročtení příslušné pasáže reference manuálu. Pak vám nezbude nic jiného než si prohlédnout zdrojový kód funkce, detailně se seznámit s čiností periferie a zkusit její činnost odhadnout. Na pomoc vám k tomu poslouží tři zdroje. Jednak ukázkové zdrojové kódy (examples) přiložené v balíčku s knihovnami. Potom "appnotes" (aplikační poznámky) od ST. A docela mocnou pomůckou mohou být ukázkové zdrojové kódy (psané v CMSIS), které najdete v některých reference manuálech v příloze (Apendix). Což ale bohužel nemění nic na tom že tady v té oblasti dokumentace pokulhává. U jiných výrobců (např Atmel) to je ale mnohem, mnohem horší ;) takže si těch krásně komentovaných knihovních funkcí važte.
Zamyšlení si zaslouží i otázka kterého člena rodiny STM si zvolit pro bastlířské pokusy. Výkonné varianty F2,F3,F4,F7,L2 a L4 dokážou rozvinout svoje schopnosti v podstatě jen když mají k dispozici odpovídající hardware (SDRAM, Displeje a pod.). K tomu ale potřebujete buď vlastní desku nebo dobře vybavený vývojový kit a to je něco do čeho se vám kvůli domácím aplikacím asi nebude chtít investovat. Proto se pro bastlíře jeví nejvhodnější čipy F0 a F1, případně pro solární a bateriové aplikace čipy z low-power rodiny L0 a L1. Já se v návodech pokusím zaměřovat předně, ale nikoliv výhradně, právě na tyto čipy.
Ještě než se pustíte do programování STM32, není od věci seznámit se s přístupy jakými je možné programovat. Díky tomu že existuje několik typů knihoven existuje i několik programovacích stylů. V tomto tutoriálu se ještě nebudeme zaměřovat na zvládnutí nějaké periferie. Budu se pouze soustředit na to abych vám předvedl jednoduchou úlohu blikání LEDkou několika různými styly. Doufám, že si díky tomu uděláte představu a vyberete si pro začátek ten styl který je vám nejbližší. Pojďme si tyto přístupy nejprve stručně představit.
Programování pouze s knihovnou CMSIS se velice podobá programovacím stylům 8bitových mikrokontrolérů. Programujete tím stylem že přímo zapisujete a čtete z registrů (SFR). Vystačíte si s hlavičkovým souborem, který obsahuje stovky maker a definic usnadňujících vám přístup k řídicím registrům čipu. Během programování je nezbytně nutné stále nahlížet do datasheetu na funkci jednotlivých bitů v registrech. Je to tedy velice pracná a zdlouhavá metoda. Jedinou její výhodou (a to velice spornou) je fakt že se nemusíte učit jak pracují knihovní funkce. Využitelná je v aplikacích, které jsou úzce vázané na periferie čipu. Tedy v aplikacích zaměřených primárně na hardware.
Programování s pomocí knihoven SPL (Standard Peripheral Library) je postup který nemá budoucnost, protože podpora SPL byla před více jak rokem ukončena. SPL jsou k dispozici k čipům rodin F0,F1,F2,F3,F4 a L1 a protože jsem si na ně zvykl a navíc jsou dle mého názoru vyvážené a přehledné, budu je v dalších tutoriálech používat (vedle LL API).
Nízkoúrovňové (Low Level) knihovny slouží pro kompletní ovládání periferií. Odstiňují vás od přímé práce s registry, aniž by ale obětovaly některé z funkcí periferií. Jejich blízký vztah k periferiím snižuje teoreticky přenositelnost programu. Na druhou stranu umožňuje plně rozvinout schopnosti periferií.
Vysokoúrovňové knihovny (High Abstraction Layer) jsou dobře přenositelné. Odstiňují programátora od detailní práce s periferiemi. Díky tomu je konfigurace periferií rychlejší. Nejsou ale tak efektivní jako LL nebo SPL a já se jim v tutoriálu nejspíš nebudu věnovat. Čímž nechci naznačit že jsou špatné, ale leží příliš daleko od těžiště mé práce a tedy i mých zkušeností. Kód generovaný wizzardem (CubeMX) je v HAL.
Poslední dobou se rozvinulo online prostředí Mbed, ve kterém lze programovat v c++ v "Arduino" stylu. Nemám s ním zkušenosti, ale co vím tak neobsahuje debug. Nebude tedy nejspíš vhodné pro rozsáhlejší projekty.
V ukázkách si zablikáme LEDkami, které máme na Discovery boardu (STM32F051 Discovery) připojeny na pinech PC8(modrá) a PC9(zelená) přes odpory 330R resp. 660R proti GND. A vy se zkuste soustředit jen na to jak je pro vás zdrojový kód čitelný. Ve všech třech příkladech děláme totéž. Spustíme clock periferii GPIOC, nastavíme PC8 a PC9 jako výstupy (s maximální rychlostí přeběhu). Poté s pomocí tupé čekací smyčky (s dobou čekání okolo 1s) obě LED zhasneme a jednu po druhé rozsvítíme. Pojďme se tedy nejprve podívat na ukázku CMSIS.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | // A) ukázka programování pouze s pomocí CMSIS, blikání LED // procesor STM32F051R8T6 na desce STM32F051 Discovery // LEDky na PC8 a PC9 #include "stm32f0xx.h" void delay(uint32_t del); // hloupý delay #define DELAY_VAL 1000000 int main(void){ // pustit clock do GPIOC RCC->AHBENR |= RCC_AHBENR_GPIOCEN; // nastavit PC8 a PC9 jako výstupy GPIOC->MODER = GPIO_MODER_MODER9_0 | GPIO_MODER_MODER8_0; // nastavit rychlost přeběhu na PC8 a PC9 na maximum (jen pro legraci) GPIOC->OSPEEDR = GPIO_OSPEEDR_OSPEEDR8_Msk | GPIO_OSPEEDR_OSPEEDR9_Msk; while (1){ GPIOC->BRR = GPIO_BRR_BR_9 | GPIO_BRR_BR_8; // zhasni obě LED delay(DELAY_VAL); // chvíli počkej GPIOC->BSRR = GPIO_BSRR_BS_8; // Rozsviť LED na PC8 delay(DELAY_VAL); // chvíli počkej GPIOC->BSRR = GPIO_BSRR_BS_9; // Rozsviť LED na PC9 delay(DELAY_VAL); // chvíli počkej } } // hloupý delay void delay(uint32_t del){ uint32_t i; for(i=0;i<del;i++){}; } |
Všimněte si struktury příkazů. Registr ke kterému přistupujeme se stává z bázové adresy periferie a offsetu příslušného registru. Na konkrétním příkladě příkazu:
RCC->AHBENR |= RCC_AHBENR_GPIOCEN;
můžete vidět, že v periferii RCC (Reset and Clock Control) chceme přistupovat do registru AHBENR. Za rovnítkem je pak makro kterým přistupujeme ke konkrétnímu bitu v tomto registru a nastavujeme ho do log.1. V situacích kdy bychom chtěli nastavovat celou skupinu bitů zároveň, hledáme makra zakončená koncovkou _Msk (těchto maker využijete typicky při nulování skupiny bitů). A to je v podstatě vše s čím si musíte vystačit. Další zdrojový kód bude ke stejnému účelu využívat LL knihovny v plné výbavě.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | // B) ukázka programování s pomocí LL API (s využitím USE_FULL_LL_DRIVER), blikání LED // Styl velmi podobný SPL // procesor STM32F051R8T6 na desce STM32F051 Discovery // LEDky na PC8 a PC9 #include "stm32f0xx.h" #include "stm32f0xx_ll_bus.h" // kvůli fcím pro povolování clocku periferiím #include "stm32f0xx_ll_gpio.h" // kvůli fcím pro práci s GPIO void delay(uint32_t del); // hloupý delay #define DELAY_VAL 1000000 int main(void){ // deklarace struktury pro konfiguraci pinů LL_GPIO_InitTypeDef gpio; // spustit clock pro GPIOC LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOC); // naplníme strukturu gpio (s vybranou konfigurací pinů) gpio.Mode = LL_GPIO_MODE_OUTPUT; // vybrané piny jsou výstupy gpio.Speed = LL_GPIO_SPEED_HIGH; // rychlost přeběhu maximální gpio.OutputType = LL_GPIO_OUTPUT_PUSHPULL; // typ výstupu push-pull gpio.Pull = LL_GPIO_PULL_NO; // pull-up ani pull-down resistor nechceme gpio.Pin = LL_GPIO_PIN_8 | LL_GPIO_PIN_9; // piny 8 a 9 // aplikujeme zvolenou konfiguraci na GPIOC LL_GPIO_Init(GPIOC,&gpio); while (1){ LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_8 | LL_GPIO_PIN_9); // zhasni obě LED delay(DELAY_VAL); // chvíli počkej LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_8); // Rozsviť LED na PC8 delay(DELAY_VAL); // chvíli počkej LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_9); // Rozsviť LED na PC9 delay(DELAY_VAL); // chvíli počkej } } // hloupý delay void delay(uint32_t del){ uint32_t i; for(i=0;i<del;i++){}; } |
Pro použití knihoven musíme potřebné soubory inkludovat, což je patrné z prvních řádků ukázky. Veškeré programování se odehrává pomocí čitelných funkcí a skrývá tak před vámi přímý přístup do registrů i nutnost listovat datasheetem a sledovat jak jednotlivé bity v registrech konfigurovat. Stejně tak ani nemusíte hledat mezi makry, protože funkce jsou velmi dobře komentované a v záhlaví každé funkce je seznam všech povolených argumentů. Což výrazně zrychluje programování. Pro konfiguraci periferií slouží přehledné struktury, které před-plníme čitelnými parametry a zavoláním příslušné funkce se toto nastavení aplikuje. V našem příkladě takto nastavujeme parametry pinům PC8 a PC9 (všimněte si že to můžeme dělat hromadně pro více pinů). Aby jste tyto struktury mohli používat, musíte si v překladači mezi definované symboly zařadit "USE_FULL_LL_DRIVER" (o čemž se dozvíte přečtením prvních stránek dokumentace ke knihovnám). Proč je tu možnost struktury nepoužívat netuším. V dalším příkladě pro úplnost předvedu jak by to vypadalo bez používání inicializačních struktur.
// C) ukázka programování s pomocí LL API (bez využití USE_FULL_LL_DRIVER), blikání LED // procesor STM32F051R8T6 na desce STM32F051 Discovery // LEDky na PC8 a PC9 #include "stm32f0xx.h" #include "stm32f0xx_ll_bus.h" // kvůli fcím pro povolování clocku periferiím #include "stm32f0xx_ll_gpio.h" // kvůli fcím pro práci s GPIO void delay(uint32_t del); // hloupý delay #define DELAY_VAL 1000000 int main(void){ // spustit clock pro GPIOC LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOC); // nastavíme PC8 jako výstup LL_GPIO_SetPinMode(GPIOC,LL_GPIO_PIN_8,LL_GPIO_MODE_OUTPUT); // nastavíme PC9 jako výstup LL_GPIO_SetPinMode(GPIOC,LL_GPIO_PIN_9,LL_GPIO_MODE_OUTPUT); // nastavíme rychlost přeběhu na PC8 LL_GPIO_SetPinSpeed(GPIOC,LL_GPIO_PIN_8,LL_GPIO_SPEED_FREQ_HIGH); // nastavíme rychlost přeběhu na PC9 LL_GPIO_SetPinSpeed(GPIOC,LL_GPIO_PIN_9,LL_GPIO_SPEED_FREQ_HIGH); while (1){ LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_8 | LL_GPIO_PIN_9); // zhasni obě LED delay(DELAY_VAL); // chvíli počkej LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_8); // Rozsviť LED na PC8 delay(DELAY_VAL); // chvíli počkej LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_9); // Rozsviť LED na PC9 delay(DELAY_VAL); // chvíli počkej } } // hloupý delay void delay(uint32_t del){ uint32_t i; for(i=0;i<del;i++){}; }
Tady si všimněte že bez využití struktur ztrácíte možnost konfigurovat více pinů zároveň. Čitelnost programu tím však nijak moc netrpí.
// D) ukázka programování s pomocí SPL, blikání LED // mikrokontrolér STM32F051R8T6 na desce STM32F051 Discovery // LEDky na PC8 a PC9 #include "stm32f0xx.h" void delay(uint32_t del); // hloupý delay #define DELAY_VAL 1000000 GPIO_InitTypeDef gp; // struktura s konfigurací GPIO int main(void){ // spusti clock pro GPIOC RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE); gp.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9; // Piny 8 a 9 gp.GPIO_Mode = GPIO_Mode_OUT; // nastavit jako výstupy... gp.GPIO_OType = GPIO_OType_PP; // v push pull konfiguraci gp.GPIO_PuPd = GPIO_PuPd_NOPULL; // bez pullup/pulldown rezistoru gp.GPIO_Speed = GPIO_Speed_Level_3; // na maximální rychlosti (nehraje roli) GPIO_Init(GPIOC, &gp); // nakonfigurovat vybrané piny (8 a 9) na GPIOC while (1){ GPIO_ResetBits(GPIOC,GPIO_Pin_8 | GPIO_Pin_9); // zhasni obě LED delay(DELAY_VAL); // chvíli počkej GPIO_SetBits(GPIOC,GPIO_Pin_8); // Rozsviť LED na PC8 delay(DELAY_VAL); // chvíli počkej GPIO_SetBits(GPIOC,GPIO_Pin_9); // Rozsviť LED na PC9 delay(DELAY_VAL); // chvíli počkej } } // hloupý delay void delay(uint32_t del){ uint32_t i; for(i=0;i<del;i++){}; }
Předem vás upozorňuji že Tato kapitola může zastarávat. STM32 můžete programovat v mnoha různých vývojových prostředích. Bez omezení velikosti kódu to lze minimálně v Atollic TrueStudiu, v CoIDE (který už se dál bohužel nevyvíjí) a v SW4STM32. Jen ve stručnosti uvedu pár informací. "Atollic True Studio for STM32" má k dispozici ze všech jmenovaných nejlepší debugovací nástroje, ale krom vybraných čipů řady F4 automaticky nepodporuje SPL a musíte si je do projektu vkládat sami. SW4STM32 nemá tak dokonalé debugovací prostředky (nicméně na většinu bastlířské práce bohatě stačí), ale má příjemnou nativní podporu HAL i SPL, takže se člověk nemusí při vytváření projektu zdržovat s implementací knihoven. Správně bych se zde ani neměl zabývat tím jak celý vývojový řetězec zprovoznit. Nemám na to totiž kvalifikaci a pořádně tomu nerozumím. Protože to ale není úplně snadné, zkusím vám dát pár tipů a budu doufat že se tím prokoušete. Pokud se vám to podaří bude na vás čekat řada tutoriálů, osvětlujících práci s jednotlivými periferiemi STM32. Doufám že se na českém webu najde někdo povolanější a tutoriál na toto téma zpracuje.
O ST-LINKu už byla řeč, zmíním tedy pouze to že k jeho přímému ovládání slouží aplikace ST-LINK Utility, kterou si určitě stáhněte. Ta vám umožní provádět základní operace jako je mazání, čtení a programování čipu. A bude vám velmi užitečná když si nějakou hloupou chybou vypnete programovací rozhraní. Jinak ovládání ST-LINKu zvládá IDE. Nucleo modulky obsahují vylepšený ST-LINK, který krom role programátoru / debuggeru zastoupí také roli USB->UART bridge a po nahrání příslušných driverů můžete v PC rozběhnout virtuální seriový port a zprostředkovat tak komunikaci mezi PC a STM32 bez potřeby připojovat externí USB->UART převodník (jako třeba čipy od FTDI).
Pro zprovoznění tohoto toolcahinu si budete muset stáhnout Atollic TrueSTUDIO a nainstalovat ho. Během instalace by se vám do PC měly nahrát drivery k ST-LINKu. Studio samo o sobě vám ale moc možností nedává, čipy budete moct programovat pouze s CMSIS knihovnami. Pokud budete chtít používat SPL, LL a nebo HAL knihovny musíte si je stáhnout. Pro jejich stažení googlete STM32Cube a nebo si vyberte zde. Každá rodina má svůj vlastní balík knihoven. Aby to nebylo tak přehledné tak v balíku najdete krom knihoven také kopu vzorových projektů pro různá vývojová prostředí, vzorové příklady a spoustu dalšího. Takže si ji po stažení určitě prohlédněte a trochu se v ní zorientujte.
Jak stvořit nový projekt v TrueSTUDIu nemá smysl moc komentovat protože s každou novou verzí se postup drobně upravuje, odkážu vás proto buď na user manual a nebo na postarší stránky emcu.it, kde je obrázkový návod pro starší verze. Jakmile se vám to podaří můžete směle programovat s knihovnami CMSIS. To ale chtít asi nebudete, takže musíte zvládnout ještě jeden krok. Implementaci knihoven LL nebo HAL.
Alternativní možností je stáhnout aplikaci CubeMX, ve které lze přehledným způsobem nakonfigurovat periferie i clock čipu a nechat si od ní vygenerovat adresářovou strukturu, kterou pak nahrajete do složky s projektem. Spolu s tím totiž nevědomky uděláte krok jedna :) to je také zmíněno v návodu.
Vytvořit projekt s SPL knihovnami v prostředí SW4STM32 je velice jednoduché narozdíl od snahy předat tento postup v textové podobě. Proto si dovolím odkázat čtenáře na několik step-by-step videí:
Až budu mít čas a náladu doplním průvodce jak sprovoznit SPL na AtollicStudiu (je to otravné a fascinuje mě že programátoři studia tuto funkci - v minulosti již naprogramovanou - vyřadili...). Projekt pro STM32F4 lze vygenerovat s SPL, pro ostatní rodiny si musíme SPL importovat sami.
Home
V1.21 26.8.2018
By Michal Dudka (m.dudka@seznam.cz)