STM8 toolchain Vývoj STM8 s OpenSource nástroji

This post is also available in: en

Vývojové nástroje jsou asi největší slabinou celého ekosystému STM8. Výrobce dodává vývojové prostředí STVD (návod zde), které je sice dostačující, ale staré a již nevyvíjené. Navíc se občas stane, že na nějakém PC je problém to rozjet. Kompilátor Cosmic sice funguje, ale ta neustálá kontrola licence je fakt opruz; … a jeho chybová hlášení mi taky nepřišla úplně srozumitelná.
A to jsem ještě nezmínil to hlavní: Na Linuxu to nejede!

Proto jsem vytvořil toolchain, který se spoléhá na OpenSource nástroje. Pokud chcete tento toolchain použít, je třeba si tyto nástroje nainstalovat:

1. Vývojové prostředí
2. Kompilátor
3. Programátor/Flasher — software, kterým program do chipu naflashuju
4. Debugger

Když jsem to celé tvořil, hodně mi pomohla tato stránka, tak se tam můžete mrknout: https://github.com/hbend1li/stm8_started.

Předpřipravená instalace¶

Připravil jsem pro vás výukový image systému Devuan Linux, kde je vše již nastaveno a nainstalováno. Nemusíte tedy vše ručně instalovat, stačí:

1. nainstalovat VirtualBox
2. do VirtualBoxu doinstalovat Extension Pack
3. stáhnout si připravený image: Devuan-X+MIT.ova a importovat si ho.

Něco málo o obrazu:

• aktualizováno dne 2. listopadu 2026
• velikost 5722 MB
• sestaveno na VirtualBox 7.2.22
• release: Devuan 6 Excalibur (založený na Debianu 13 Trixie)
• desktop: Openbox + xfce4-panel
• https://mamut.spseol.cz/nozka/public/virtual-img-ova/Devuan-X+MIT.ova

Jak použít Virtualbox a předpřipravený image:

MIT-Virtualbox

… i tak si ale přečtěte následující text, ať víte, jak to máte použít.

Předpřipravené balíčky¶

Připravený repozitář:

https://mamut.spseol.cz/debian/

Stačí zadat:

1
2
3
4
5
6

sudo curl -fsSL https://mamut.spseol.cz/debian/mamut-archive-keyring.gpg -o /etc/apt/keyrings/mamut-archive-keyring.gpg
echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/mamut-archive-keyring.gpg] https://mamut.spseol.cz/debian mamut main" | sudo tee /etc/apt/sources.list.d/mamut.list

sudo apt update
sudo apt install make openocd git fzf python3-serial cgdb ccls
sudo apt -t mamut install stm8flash stm8-binutils-gdb stm8newproject sdcc sdcc-libraries glabproject

… a vše, co potřebujete nainstalovat, je nainstalováno.

Pokud používáte jinou linuxovou distribuci nebo jiný OS nebo prostě chcete mít více kontroly nad tím, co instalujete, podívejte se do samostatného článku: Instalace/Kompilace nástrojů pro STM8 toolchain.

Co jste si v připravených balíčcích vlastně nainstalovali:

• sdcc, sdcc-libraries — kompilátor (detail instalace)
• openocd — flashování a ladění (detail instalace)
• stm8flash — flashování (detail instalace)
• stm8-binutils-gdb — debugger stm8-gdb (detail instalace)
• cgdb — rozhraní pro GDB (instalace)
• ccls — LSP server pro editor (volitelný) (detail instalace)
• stm8newproject — automatizace zakládání projektu
• glabproject — interaktivní vytváření GitLab projektů z CLI
• make, git, fzf, python3-serial — pomocné nástroje pro toolchain

Toolchain¶

Jádrem celého toolchainu je Makefile, doplněný o několik pomocných skriptů (adresář .make) a startovací strom zdrojových kódů projektu:

https://gitlab.com/spseol/mit-no/STM8S-toolchain

Toolchain se dá použít v Linuxu, v MacOS i ve Windows. Je ale vyvíjen a primárně určen pro Linux, a tam také funguje nejlépe.

Používá se velmi jednoduše: repozitář s toolchainem stačí stáhnout, rozbalit nebo naklonovat. Tím vznikne složka s novým projektem a v ní už jen voláte příkazy make (přehled najdete v části Použití).

Projekty a knihovna SPL¶

Adresářová struktura jednotlivých projektů vypadá takto:

MIT
├── Projekt-1
│   ├── inc
│   ├── lib
│   └── src
├── Projekt-blikblik
│   ├── inc
│   ├── lib
│   └── src
├── SPL
│   ├── inc
│   └── src
└── SPLSPL
    ├── inc
    └── src

Udělejte si adresář, kde budou všechny vaše projekty — v uvedeném příkladu je to MIT. V tom stejném adresáři budou i adresáře nazvané SPL a SPLSPL. V SPL adresářích je Standard peripheral library od firmy ST. Tato knihovna má dost divnou licenci, a proto vám ji nemůžu jen tak dát. Měli byste si ji najít a stáhnout. Pak je třeba ještě aplikovat patch, který knihovnu předělá tak, aby se dala použít s naším SDCC kompilátorem. Celé je to docela pracné, … ale zkuste napsat make spl, třeba se to zařídí samo.

Použití¶

Vše se ovládá pomocí programu make. V adresáři s projektem tedy jen voláte následující příkazy:

• make spl — stáhne a nachystá knihovny
• make — provede kompilaci
• make flash — naflashuje program do chipu (když běží make debug, program jen přeloží a do chipu ho naflashuje debugger)
• make clean — smaže všechno, co nakompiloval
• make rebuild — smaže vše a znovu zkompiluje
• make debug — ladění jedním příkazem: přeloží, naflashuje, zastaví na main() a otevře cgdb

Toolchain toho umí víc… stačí číst další text nebo README projektu.

Vývojové prostředí¶

Já používám Vim respektive Neovim. Ne každému ovšem toto prostředí vyhovuje, takže jako editor a vývojové prostředí doporučuji VScodium/VScode.

Instalace je popsána zde.

Pro funkce jako automatické doplňování kódu, přecházení na definici nebo zobrazování chyb přímo v editoru slouží LSP server. Zde doporučuji použít ccls místo rozšíření C/C++ od Microsoftu. C/C++ se s embedded platformami ne vždy chová korektně, zatímco ccls funguje IMHO spolehlivě.

ccls je volitelný. Toolchain při překladu sám vytváří soubor compile_commands.json, ze kterého ccls zjistí přepínače kompilátoru a cesty k hlavičkovým souborům, takže nemusíte nic ručně nastavovat. Na Debianu a odvozených distribucích ho nainstalujete z balíčku ccls (je v příkazu v části Předpřipravené balíčky), pro ostatní systémy je instalace popsána zde.

Do editoru VSCode/Codium pak nainstalujete rozšíření ccls — ve VSCode z Marketplace, ve VSCodium z Open VSX.

Kompilace — SDCC¶

SDCC - Small Device C Compiler je kompilátor pro různé, více či méně známé 8-bitové architektury. Z hlediska STM8 má jednu zásadní nevýhodu: nedokáže odstranit nepoužívaný (mrtvý) kód. Co to znamená? No… pokud si všechno píšete sami, tak to prakticky neznamená nic. Pokud ovšem použijete nějakou knihovnu (jako například SPL), tak už vám to začne hodně vadit, protože výsledný strojový kód obsahuje spoustu funkcí, které jste kompilovali jen proto, že byly součástí knihovny a ne proto, že jste je chtěli použít. Tyto funkce nejsou nikde volány a proto by je měl linker odstranit. No a to je přesně to, co se nestane :-(. Ve výsledku program, který by mohl mít cca 2-3 kB, má 30 kB.

Naštěstí existuje jeden hack, který funguje asi takto: Knihovna SPL se rozdělí do malých souborů (co funkce, to soubor) a každý se kompiluje jako samostatný modul. Z těchto modulů se udělá knihovna, se kterou SDCC linker už umí správně pracovat. Proto je v adresářové struktuře knihovna SPL dvakrát. SPLSPL znamená SPLit SPL a používá se právě na toto.

Existují i další řešení, SDCC-gas a sdccrm. Jsou to ale historická řešení: projekty jsou neudržované a SPLSPL dnes bohatě stačí. Pro zajímavost je najdete v samostatném článku Odstranění mrtvého kódu v SDCC.

Instalace SDCC pro Linux, MacOS i Windows je popsána zde.

Flashing¶

Program do chipu se nahrává přes programátor ST-LINK. V toolchainu to umí tři nástroje a který se použije, závisí na příkazu a operačním systému:

• make flash — v Linuxu a v MacOS OpenOCD, ve Windows STVP. Je to výchozí volba, která funguje na všech systémech.
• make stm8flash — vždy stm8flash.
• make debug — program naflashuje debugger sám, ruční flashování tedy nepotřebujete.

STVP¶

STVP je software od výrobce chipů ST pro Windows. Umožňuje přístup do všech částí paměti mikrokontrolérů. Má grafickou verzi i verzi pro příkazový řádek. Právě na verzi pro příkazový řádek (STVP_CmdLine.exe) se spoléhá náš toolchain; pokud ho používáte ve Windows, příkaz make flash ji použije pro flashnutí chipu. Stačí mít STVP nainstalované.

OpenOCD¶

Open On-Chip Debugger je nástroj pro debug a krokování programu přímo na chipu. openocd umí program i naflashovat do paměti zařízení. Funguje v Linuxu, v MacOS i ve Windows.

Instalace a skript pro samotné flashování (ten je součástí toolchainu) jsou popsány zde.

stm8flash¶

Druhá možnost je program stm8flash. My ho máme v našem repozitáři.

https://github.com/vdudouyt/stm8flash

stm8flash je malý nástroj pro příkazový řádek, který s chipem komunikuje přes rozhraní SWIM programátoru ST-LINK. Dlouho byl na Linuxu jediný, kdo to uměl; OpenOCD zvládá flashování až od roku 2018 a stm8flash má dodnes širší podporu chipů a lepší práci s pamětí (umí ji číst, ověřovat a zapisovat i do EEPROM). V toolchainu ho použijete příkazem make stm8flash, který naflashuje přeložený program (out.ihx). Příkaz make stm8flash-unlock zapíše do option bytes hodnoty, které vypnou ochranu čtení (ROP) — hodí se, když je chip “zamčený” a nejde flashovat.

Instalace pro ostatní systémy a build ze zdrojových kódů jsou popsány zde.

Debugging — Ladění¶

Komunikaci s chipem zajišťuje OpenOCD¶

openocd tedy Open On-Chip Debugger je nástroj, pomocí kterého komunikujeme s chipem a spouštíme/zastavujeme/krokujeme program. Tento nástroj zprostředkovává komunikaci mezi debugerem a chipem přes debugovací rozhraní ST-LINK. Instalace je popsána zde.

Samostatně se OpenOCD pouští takto:

1

openocd -f .make/stm8s-flash.cfg -f interface/stlink-dap.cfg -f target/stm8s103.cfg -c "init" -c "reset halt"

(Příklad je pro čip STM8S103; pro jiné čipy se mění soubor target/*.cfg — stm8s003.cfg, stm8s105.cfg, obecně stm8s.cfg.)

Nebojte se, nemusíte to vždy znovu vypisovat. Je to napsané v Makefile, který správný target vybere podle čipu, takže stačí zavolat:

1

make openocd

Samostatné spuštění OpenOCD se hodí jen pro ruční připojení GDB nebo pro grafické nástroje jako VSCode, které se připojují na port 3333.

Pro ladění nemusíte OpenOCD spouštět ručně: příkaz make debug si ho spustí sám a po skončení ladění ho zase ukončí (detaily v článku Malý kurz STM8-GDB).

1

make debug

STM8-GDB¶

GDB (GNU Debugger) je standardní nástroj na hledání chyb v softwaru. Umožňuje program zastavit, krokovat a za běhu se dívat do proměnných nebo je dokonce měnit. Pro platformu STM8 je třeba mít upravený STM8-GDB ze sady GNU binutils. Instalace je popsána zde.

GDB je textový nástroj. Mé doporučení zní: nenechte se odradit a používejte přímo GDB, nebo jeho lehoučkou nadstavbu cgdb. Oba nástroje jsou podrobně popsány v samostatném článku Malý kurz STM8-GDB.

V našem toolchainu se ladění spouští jedním příkazem:

1

make debug

Tento příkaz přeloží projekt, spustí OpenOCD, naflashuje program do chipu, zastaví na začátku main() a otevře cgdb. Když za běhu ladění upravíte program, stačí v jiném terminálu zavolat make flash a debugger nový program do chipu naflashuje sám.

Malý kurz STM8-GDB¶

Podrobnější informace najdete v samostatném článku: Malý kurz STM8-GDB.

Všechny ostatní grafické nástroje používají GDB jako backend. Jejich výhodou i nevýhodou je klikání, které může být pro mnohé lákavější — na druhou stranu můžete přijít o některé funkce jako například podmíněné breakpointy.

Ladění ve VS Code a VSCodium¶

Ladění z make debug — breakpointy, krokování, proměnné i registry periferií, viz Malý kurz STM8-GDB — jde ovládat i klikáním v editoru VSCodium nebo VS Code (instalace editoru je popsána zde). K tomu slouží rozšíření STM8 Toolchain Debugger. Pod kapotou spouští stejný stm8-gdb a stejný OpenOCD jako make debug, takže vše z Malého kurzu STM8-GDB platí i tady. Debug konzole dokonce přijímá příkazy GDB, včetně sfr a p TIM4->CR1.

Rozšíření je testované na Linuxu. Všechno kromě STM8 binutils-gdb je otestované i na macOS, takže pokud se vám tam podaří rozjet stm8-gdb, poběží to také. Na macOS jen musíte nainstalovat všechny závislosti. Windows není podporovaný ani testovaný.

Instalace rozšíření¶

Pro ladění potřebujete totéž co pro make debug: make, python3, git, SDCC, OpenOCD a stm8-gdb ve verzi 15 nebo novější s podporou Pythonu a DAP (viz Instalace) a ST-LINK. Node.js ani npm nejsou potřeba.

stm8-gdb není součástí rozšíření, musíte ho mít nainstalovaný předem. Je to zvláštní build GDB pro STM8 (STM8 binutils-gdb), postup je v článku Instalace/Kompilace nástrojů pro STM8 toolchain.

Rozšíření se jmenuje spseol.stm8-toolchain. V editoru ho najdete v panelu Extensions hledáním STM8 Toolchain:

• ve VSCodium je z Open VSX,
• ve VS Code z Visual Studio Marketplace.

Rozšíření jde nainstalovat i z projektu založeného z našeho toolchainu, bez marketplace:

1

make vscode

Příkaz rozšíření zabalí a nainstaluje do všech nalezených editorů code a codium (make vscode IDES=codium vybere jen jeden). Po instalaci editor restartujte.

Nový projekt¶

Spusťte paletu příkazů (Ctrl+Shift+P) a zvolte STM8: New Project…. V prázdném okně editoru, kde ještě nemáte otevřenou žádnou složku, stačí kliknout na tlačítko New STM8 Project v panelu Explorer. Rozšíření:

1. se zeptá na složku pro projekty (nastavení stm8.projectsFolder) a na název projektu. Všechny projekty mají ležet v jedné složce, protože sdílejí knihovnu SPL v ../SPLSPL,
2. naklonuje toolchain z GitLabu, připraví git repozitář s jedním commitem (původní historie toolchainu zůstane ve větvi upstream),
3. projekt otevře. První překlad stáhne knihovnu SPL, k tomu je potřeba internet.

Cílový čip vyberete klikem v dolní stavové liště (změní DEVICE_FLASH v Makefile).

Starší projekt¶

Projekt založený dříve aktualizujete příkazem STM8: Update Toolchain. Rozšíření ho samo nabídne, když otevřete projekt se starším toolchainem. Totéž umí z terminálu make upgrade, ale ten cíl mají až projekty, které už jednou novým toolchainem prošly.

Aktualizace nahradí .make/ a .vscode/launch.json, doplní chybějící řádky do .gitignore a váš Makefile slije s novou verzí: vaše nastavení čipu, frekvence a cesty ke kompilátoru zůstanou. Když se vaše úpravy s novými srazí, nechá v Makefile značky konfliktu (<<<<<<<) a projekt se nepřeloží, dokud je neopravíte. Zdrojové soubory (src/, inc/) ani README se nemění. Nic se nekomituje, takže výsledek můžete zkontrolovat přes git diff. Změny v .make/, Makefile a launch.json musíte mít před aktualizací commitnuté, jinak ji rozšíření odmítne.

Ladění¶

Zmáčkněte F5 (konfigurace STM8 debug). Rozšíření stejně jako make debug:

1. přeloží projekt s ladicími informacemi (chyby překladače se ukážou v panelu Problems),
2. spustí OpenOCD a naflashuje program do chipu,
3. zastaví program na začátku main().

Pak ladíte jako v jiných editorech: breakpoint nastavíte klikem vedle čísla řádku, krokujete tlačítky na liště (nebo F10, F11), proměnné vidíte v postranním panelu, v Watch a po najetí myší na výraz v kódu.

V postranním panelu Run and Debug přibude pohled STM8 Peripherals. Je to sfr ve stromu: periferie vašeho čipu, jejich registry a bity. Hodnoty se čtou při každém zastavení a to, co se od minulého zastavení změnilo, je zvýrazněné žlutě. Zaškrtnutím jednobitového pole bit zapíšete, tužkou na registru nebo na vícebitovém poli zadáte novou hodnotu (desítkově, 0x… nebo 0b…).

U registrů, jejichž čtení maže příznaky (UART1->DR, SPI->DR, …), platí totéž co u příkazu sfr: strom je sám nečte. Přečtete je ikonou Read. Stejně tak je nepřečte ani najetí myší na výraz v kódu.

Dolní stavová lišta má tlačítka Build, Flash, Debug a výběr čipu.

Když něco nejde¶

Výstup GDB najdete v panelu Output v kanálu STM8 debug.

Podrobnosti o rozšíření, jeho nastavení a omezeních jsou v jeho README.

Další VScode/Codium extensions¶

Můžete si pohrát a vyzkoušet různá rozšíření pro VSCode/Codium. Budete jistě muset upravit soubor .vscode/launch.json v projektu a správně ho propojit s stm8-gdb.

Zde je nástřel několika rozšíření, se kterými by to možná mohlo fungovat. Různě po internetu jsou návody, ze kterých se zdá, že to funguje. Mně osobně se to nikdy nepodařilo rozjet k plné spokojenosti a držím se svého oblíbeného cgdb. Pokud se vám poštěstí, jistě mi dejte vědět.

• C/C++
• Kylin Native Debug
• Native Debug

Zde ještě nástřel mého .vscode/launch.json pro Native Debug.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "gdb-stm8",
            "type": "gdb",
            "request": "attach",
            "executable": "${workspaceRoot}/out.elf",
            "gdbpath": "stm8-gdb",
            "remote": true,
            "target": ":3333",
            "cwd": "${workspaceRoot}",
            "autorun": [
            ]
        }
    ]
}