This post is also available in: en
Tento post je součástí série článků o vývoji pro STM8 s OpenSource nástroji. Celý popis toolchainu najdete v postu Vývoj STM8 s OpenSource nástroji
Nenechte se odradit
Ano, je to textové rozhraní, žádná klikátka ani pouťové efekty. Pouze textové
příkazy.
Toto rozhraní však může být velmi efektivní a díky prográmku
cgdb i krásně barevné a přehledné.
GDB (GNU Debugger) je standardní nástroj na hledání chyb v softwaru. Díky němu můžete program krokovat a za běhu se dívat do proměnných. Pro platformu STM8 budeme potřebovat upravený STM8-GDB ze sady GNU binutils.
Postupně si ukážeme:
- Základy GDB — obecné použití GDB: breakpointy, krokování, nahlížení do proměnných. Platí pro jakýkoliv program v C.
- cgdb — barevnější a přehlednější rozhraní nad GDB.
- Debuging s naším toolchainem —
make debuga prohlížení registrů periferií (GPIOB->ODR,TIM4->CR1, …)
První dvě části jsou obecné a nezávislé na STM8 nebo našem toolchainu: měly by sloužit jako taková malá referenční příručka, kterou můžete rychle prolistovat a najít příkazy a klávesové zkratky nebo si připomenout, jak se program ovládá. Třetí část ukazuje, jak tyto nástroje použít s naším toolchainem. Totéž klikáním v editoru VS Code nebo VSCodium, s rozšířením pro STM8, najdete v článku Vývoj STM8 s OpenSource nástroji.
Tip pro klikače
Doporučuju přečíst článek celý, necméně pokud skočíte rovnou na část Ladění ve VS Code a VSCodium, budete možná spokojenější…
Instalace¶
Instalace stm8-gdb je popsána v článku
Instalace/Kompilace nástrojů pro STM8 toolchain.
Kromě GDB je třeba mít nainstalovaný i Open On-Chip Debugger. Tento nástroj zprostředkovává komunikaci mezi GDB a chipem. GDB je tedy nástroj pro ladění (sem zadáváte příkazy, krokujete, prohlížíte proměnné), zatímco OpenOCD zajišťuje fyzickou komunikaci s mikrokontrolérem.
Základy GDB¶
Tato část popisuje obecné použití GDB. Jak GDB v našem projektu spustit a připojit k chipu, najdete v části Spuštění GDB.
GDB je textový program a ovládá se pomocí textových příkazů, které zadáváte
na příkazové řádce (prompt (gdb)). Pár vlastností, které vám práci usnadní:
V programu funguje tabulátor. To znamená, že při stisku klávesy TAB se
GDB pokusí uhodnout, co chcete napsat a doplní slova tak, aby byla smysluplná.
Pokud je vidět okno se zdrojovým kódem (ve výchozím stavu vidět není, viz
Text User Interface), musí být pro funkčnost TAB fokus
na okně s příkazy a ne na okně se zdrojovým kódem.
Pokud zadáte jen Enter — tedy odentrujete prázdný příkaz, zopakuje se
ten předchozí. Takže nemusíte pořád psát např. next, ale stačí ho napsat jednou
a pak jen Enter.

Výpis zdrojového kódu (list)¶
GDB ve výchozím nastavení zdrojový kód neukazuje. Vidíte jen příkazovou řádku.
Když se program zastaví (na breakpointu nebo po next), GDB vypíše pouze jediný
řádek — ten, který se má vykonat jako další:
1 2 | |
Okolí tohoto řádku zobrazí příkaz list:
list- po zastavení programu vypíše asi 10 řádků kolem aktuální pozice; každé další
list(nebo jenEnter) pokračuje dalšími řádky list -- vypíše řádky před naposledy vypsanými
list main,list main.c:20,list main.c:setup- vypíše kód kolem funkce, řádku nebo funkce v zadaném souboru
set listsize 20- nastaví počet řádků, které ukáže příkaz
list
Text User Interface¶
Pokud chcete mít zdrojový kód na očích pořád, využijte textové rozhraní GDB (TUI).
Okno se rozdělí: nahoře je zdrojový kód s ukazatelem na aktuální řádek, dole
příkazová řádka. TUI zapnete klávesami Ctrl+X A nebo spuštěním gdb --tui
(v našem projektu make gdb). Pohodlnější alternativou je cgdb.

Několik příkazů a klávesových zkratek pro TUI:
Ctrl+X A— zapne/vypne TUI mód (můžete přepínat kdykoliv)Ctrl+X 2— rozdělí okno (split layout)Ctrl+L— překreslí obrazovku (užitečné, když se rozbije)layout src— zobrazí zdrojový kódlayout asm— zobrazí assemblerlayout split— zobrazí obojílayout regs— přidá zobrazení registrůfocus cmd— přepne fokus na příkazový řádekfocus src— přepne fokus na okno se zdrojovým kódemCtrl+X O— přepíná fokus mezisrc,cmd,asm, atd.Ctrl+X S— režim jedné klávesy:n(next),s(step),f(finish),c(continue),r(run),v(info locals),qrežim ukončí
Vizuální markery v TUI:
>— aktuální pozice programu (current execution point)
Breakpoint markery (kombinace hit/not-hit a enabled/disabled):
B+— breakpoint byl zasažen (hit) a je aktivní (enabled)B-— breakpoint byl zasažen (hit) a je vypnutý (disabled)b+— breakpoint nebyl ještě zasažen (not hit) a je aktivní (enabled)b-— breakpoint nebyl ještě zasažen a je vypnutý (disabled)
Hardware breakpointy:
H+/H-— hardware breakpoint hit, enabled/disabledh+/h-— hardware breakpoint not hit, enabled/disabled
Breakpointy¶
Breakpoint (zarážka) je místo v programu — řádek, funkce nebo adresa — na kterém se program zastaví, jakmile k němu při běhu dojde. Než program k breakpointu dojde, běží plnou rychlostí přímo v chipu a GDB se ozve až v okamžiku zastavení. Pak si můžete prohlédnout proměnné a registry, program krokovat nebo nechat běžet dál.
b main,break main- nastaví breakpoint na vstup do funkce
main b 48,break 48- nastaví breakpoint na řádek 48
b milis.c:48,break milis.c:48- nastaví breakpoint na řádek 48 v souboru
milis.c info b,info breakpoints- vypíše informace o breakpointech
d 2,delete 2- vymaže breakpoint 2
disable 2,enable 2- dočasně vypne/zapne breakpoint 2
Pokročilé breakpointy:
tbreak main- temporary breakpoint — smaže se automaticky po prvním zastavení
break main.c:42 if x == 5- podmínkový breakpoint — zastaví se jen když je podmínka splněna
condition 1 x > 10- přidá nebo změní podmínku u existujícího breakpointu číslo 1
ignore 1 5- ignoruje breakpoint číslo 1 příštích 5x (pak se aktivuje)
Ovládání běhu programu¶
r,run- spustí program od začátku (v našem toolchainu navíc zastaví na
main(), viz Příkazy navíc) c,cont,continue- pokračuje v běhu programu, dokud nenarazí na breakpoint
s,step- vykoná jeden příkaz/řádek zdrojového kódu, vstoupí do funkcí
n,next- vykoná jeden příkaz/řádek zdrojového kódu, funkci vykoná jako jeden příkaz — nebude vstupovat do funkce
fin,finish- dokončí funkci, ve které se program právě nachází (pokud v ní není další breakpoint)
interrupt,Ctrl+C- přeruší program, program se zastaví tam, kde zrovna teď je
Proměnné a paměť¶
p time,print time- vypíše obsah proměnné
time p/x time,print/x time- vypíše obsah proměnné v hexadecimálním formátu
p/s string- vypíše řetězec (string)
x/10x array- examine memory — zobrazí 10 hodnot v hexadecimálním formátu od adresy
array x/s string- examine memory jako string (užitečné pro char*)
info locals- vypíše všechny lokální proměnné
info variables- vypíše všechny globální proměnné
Formáty výpisu (použijte /formát za příkazem):
p/d variable— decimal (desítkově)p/x variable— hexadecimal (šestnáctkově)p/o variable— octal (osmičkově)p/t variable— binary (binárně)p/c variable— character (jako znak)p/s variable— string (jako řetězec)
Pole a ukazatele:
p array- vypíše celé pole, pokud GDB zná jeho velikost (
p/x arrayv hexadecimálním formátu) p array[2]- vypíše jeden prvek pole
p array[0]@10- vypíše 10 prvků pole od indexu 0 (operátor
@znamená „tolik prvků od tohoto“) p *ptr@10- vypíše 10 prvků od adresy, na kterou ukazuje pointer
p matrix[1]- u dvourozměrného pole vypíše jeden řádek
x/8xb array,x/4xh array- examine memory — zobrazí 8 bytů, resp. 4 dvoubytová slova (
h) v hexadecimálním formátu od adresyarray; velikost prvku volí písmeno za formátem:b(byte),h(2 byty),w(4 byty)
Na pole zadané jen jako pointer (např. parametr funkce uint8_t *buf) GDB nezná
velikost, takže p *buf vypíše jediný prvek. Počet prvků je nutné zadat pomocí @.
GDB vypíše nejvýše 200 prvků pole, u delších končí výpis třemi tečkami.
Limit změníte příkazem set print elements 500 (hodnota 0 znamená bez omezení).
Pole se dá sledovat i průběžně: display/x array.
Změna hodnoty proměnné:
Hodnotu proměnné můžete za běhu ladění nejen číst, ale i přepsat. Hodí se to třeba pro vyzkoušení jiné hodnoty bez nového překladu a flashování.
set var time = 0- nastaví proměnné
timehodnotu 0 p time = 0- totéž,
printvýraz s přiřazením vykoná a vypíše výsledek set var array[2] = 5,set var *ptr = 5- nastaví prvek pole, případně hodnotu, na kterou ukazuje pointer
set {unsigned char}0x5000 = 0x20- zapíše hodnotu na zadanou adresu paměti (např. do periferního registru)
V našem toolchainu je to pohodlnější: registry periferií jde psát jménem jako v C, např. set var GPIOA->ODR = 0x20, viz Registry periferií.
Změna se týká jen aktuálního běhu programu. Po run, resetu nebo novém
naflashování program začne zase s původními hodnotami. Slovo var je důležité,
když se jméno proměnné shoduje s nějakým příkazem či nastavením GDB.
Průběžné zobrazování (display):
display time- vypíše obsah proměnné
timepokaždé, když se program zastaví display/d time- totéž jako
display, ale vynutí desítkový formát display/x time- zobrazí hodnotu v hexadecimálním formátu při každém zastavení
undisplay 2- už nebude vypisovat display číslo 2, když se program zastaví
info display- vypíše seznam všech
display
Zde něco málo více k příkazům print a display.
Zjištění pozice¶
where,backtrace,bt- zobrazí call stack s aktuální pozicí (soubor, funkce, řádek)
frame,info frame- zobrazí detailní informace o aktuálním frame (včetně souboru a řádku)
frame 2,f 2- přepne se na frame číslo 2 v call stacku
info line- zobrazí přesnou informaci o aktuálním řádku
info sources- vypíše seznam zdrojových souborů
Doběhnutí na místo (advance)¶
advance 56- pustí program plnou rychlostí a zastaví ho na řádku 56 aktuálního souboru
advance main.c:56,advance foo,advance *0x82d4- totéž pro řádek v jiném souboru, vstup do funkce nebo adresu
Je to zkratka pro tbreak 56 a continue: program běží, dokud nedojde na zadané
místo, a tam se zastaví. Dočasný breakpoint se po zastavení sám smaže. Program
se zastaví i dříve, pokud narazí na jiný breakpoint nebo opustí funkci, ve které
advance zadáte. Podobný je příkaz until <místo>, ten ale vyžaduje, aby cíl
byl ve stejné funkci.
next na řádku s milis() vypadá, že se zasekl
Typický kód čeká na čas takto:
1 2 3 4 5 | |
Pokud podmínka neplatí, next se z řádku s if nevrátí — smyčka vede
zpátky na týž řádek, takže next krokuje dál a dál. Každý krok přes ST-LINK
trvá desítky milisekund a čas z milis() se při krokování prakticky
nezvyšuje (přibude asi 1 ms za průchod smyčkou). Než uplyne 1234 ms,
trvají kroky minuty. Nejde o chybu milis() ani o přerušení, skip tomu
nepomůže a problém má stejně každý next na čekání na čas.
Řešení je nechat program běžet plnou rychlostí až za podmínku:
advance 56, kde 56 je řádek zaif,- nebo
tbreak 56acontinue.
Přeskakování funkcí (skip)¶
Příkaz step vstupuje do každé funkce, která má ladicí informace. Často to ale
není žádoucí — například u knihovních funkcí nebo u funkcí, které pracují s
přerušením. Příkaz skip určí funkce (nebo soubory), do kterých step
nevstoupí. Funkci provede celou jako jeden příkaz, podobně jako next.
skip- přeskakovat bude funkci, ve které právě stojíte
skip function foo- přeskakovat bude funkci
foo()(stejné jeskip foo) skip file src/foo.c- přeskakovat bude všechny funkce ze souboru (bez argumentu aktuální soubor)
skip -gfi "*/stm8s_*.c"- přeskakovat bude všechny soubory odpovídající glob vzoru, např. celou SPL knihovnu
skip -rfu "^TIM4_"- přeskakovat bude funkce, jejichž jméno odpovídá regulárnímu výrazu
info skip- vypíše seznam pravidel včetně jejich čísel
skip disable 1,skip enable 1,skip delete 1- vypne, zapne nebo smaže pravidlo číslo 1 (bez čísla se příkaz týká všech pravidel)
Co je dobré vědět:
skipovlivňuje jenstep. Příkaznextfunkce překračuje vždy.- Breakpoint uvnitř přeskakované funkce zastaví program normálně. Pravidlo se uplatní jen při vstupu do funkce krokováním.
- Pravidla platí do konce sezení. Stálá pravidla patří do
.make/gdbinit.
Watchpointy¶
Watchpoint zastaví program při změně/čtení proměnné.
Omezení STM8
OpenOCD pro STM8 podporuje pouze watchpointy délky 1 byte. Pro větší datové typy (např. uint16_t, uint32_t) budete muset sledovat jednotlivé byty
(jak na to) nebo použít
podmínkové breakpointy. Pokud se pokusíte nastavit watchpoint na větší typ,
dostanete chybu: Error: Only watchpoints of length 1 are supported
watch variable- zastaví program při zápisu do proměnné (pouze 1 byte!)
rwatch variable- zastaví program při čtení z proměnné (pouze 1 byte!)
awatch variable- zastaví program při čtení i zápisu do proměnné (pouze 1 byte!)
Hlídání jednoho bytu větší proměnné¶
U vícebajtové proměnné (uint16_t, uint32_t, pole, struktura) zvolíte jeden
byte, na ten ukážete pointerem na unsigned char a sledujete to, co je na adrese:
watch *(unsigned char *)&counter- hlídá první byte (na nejnižší adrese) proměnné
counter watch *((unsigned char *)&counter + 1)- hlídá druhý byte,
+ 2třetí atd. watch *(unsigned char *)0x0010- hlídá byte na zadané adrese (adresu proměnné zjistíte příkazem
p &counter) rwatch *((unsigned char *)&counter + 1),awatch *((unsigned char *)&counter + 1)- totéž pro čtení, resp. čtení i zápis
watch *((unsigned char *)&counter + 1) if counter > 100- podmínka může používat celou proměnnou; program se zastaví, jen když je splněna
Důležité je pořadí bytů. STM8 je big-endian a SDCC ukládá vícebajtové
hodnoty stejně: nejvyšší byte leží na nejnižší adrese. Pro uint16_t counter = 0x1234
tedy platí:
| adresa | obsah | význam |
|---|---|---|
&counter |
0x12 |
horní byte (MSB) |
&counter + 1 |
0x34 |
dolní byte (LSB) |
U uint32_t je dolní byte na &proměnná + 3. Obsah paměti po bytech si
zobrazíte příkazem x/2xb &counter. Pokud chcete zachytit každou změnu
čítače, hlídejte dolní byte (ten se mění nejčastěji). Horní byte se mění
jen při přetečení dolního, takže je vhodný pro zachycení vzácných událostí.
GDB zastaví program až po dokončení instrukce, která byte zapsala. Větší
proměnná se zapisuje po částech (např. uint32_t dvěma instrukcemi ldw, vždy po
dvou bytech), takže v tu chvíli může být přepsaná jen napůl.
cgdb¶
cgdb je curses-based rozhraní pro GDB. Práce s ním je o něco málo příjemnější a barevnější než když používáte TUI vestavěné přímo v GDB. Dokumentaci naleznete na domovské stránce projektu.

Instalace¶
Instalace je popsána zde.
Spuštění¶
Ručně se cgdb spouští zhruba takto:
1 | |
V našem projektu stačí zavolat:
1 | |
(make cgdb je totéž.) OpenOCD se spustí samo, viz Spuštění GDB.
Ovládání¶
cgdb je jen nadstavba nad GDB — má dvě okna: v dolním okně běží plnohodnotný GDB,
takže platí vše, co je popsáno v části Základy GDB: breakpointy, watchpointy, print, display, monitor příkazy i veškerá další syntaxe jsou naprosto
stejné. V horním okně se zobrazuje zdrojový kód.
Přepínání mezi okny se děje takto:
Esc— přepne fokus do okna se zdrojovým kódem (vim-like mód)i— vrátí fokus zpět do GDB příkazového řádkuCtrl+W— přepíná horizontální a vertikální layout oken=/-,+/_— zvětšuje/zmenšuje velikost okna se zdrojovým kódem (➕ ➖)
V okně se zdrojovým kódem platí vim klávesy:
Space— přidá/odebere breakpoint na aktuálním řádkut— přidá/odebere dočasný (temporary) breakpoint na aktuálním řádkuj/k, 🡇 /🡅 — pohyb dolů/nahoruCtrl+F/Ctrl+B— stránkování dolů/nahorugg/G— skok na začátek/konec souboru/pattern— hledání,n/Npřeskakuje výsledkyo— otevře dialog pro výběr souboru
Funkční klávesy (v okně se zdrojovým kódem) se používají pro řízení běhu. Nemusíte
tedy používat GDB příkazy run, continue nebo next:
F5—run, vmake debugznovu od začátkumain()F6—continueF7—finishF8—nextF10—step
Debuging s naším toolchainem¶
Všechno výše platí pro libovolný program v C. Náš STM8 toolchain k tomu přidává
automatizaci: jedním příkazem přeloží, spustí OpenOCD, naflashuje program a
zastaví ho na main(). K tomu navíc GDB zná registry periferií pod jmény ze
stm8s.h (GPIOB->ODR, TIM4->CR1), takže se do nich dá dívat a zapisovat stejně
jako v Céčku.
Spuštění GDB¶
Ladění se spouští jedním příkazem:
1 | |
Ten udělá vše potřebné:
- přeloží projekt s debug informacemi (
make elf) a připraví popis registrů periferií (sfr.elf, viz Registry periferií), - spustí OpenOCD — běží jen po dobu ladění, druhý terminál není potřeba,
- naflashuje program do chipu,
- resetuje chip a zastaví program na začátku funkce
main(), - otevře cgdb (když cgdb není nainstalované, tak GDB v TUI módu).
Po spuštění GDB vypíše blok STM8 debug s nejdůležitějšími klávesami a příkazy. Hodí se jako rychlá nápověda, než si zvyknete.
Když GDB ukončíte (quit nebo Ctrl+D), skončí i OpenOCD a program v chipu
se spustí znovu od začátku.
Když se GDB nepřipojí
Pokud se nepodaří připojit k chipu, GDB vypíše
Nepodařilo se připojit k čipu. Je ST-Link připojený a čip napájený?
a pod to poslední chyby OpenOCD (celý log je v build-*-elf/openocd.log).
Zkontrolujte ST-LINK, kabel (SWIM, GND) a napájení čipu. Ladění pak
spusťte znovu přes make debug.
Další varianty:
make gdb- totéž, ale v GDB s TUI (Text User Interface) místo cgdb
make cgdb- totéž co
make debug make openocd- spustí samostatný OpenOCD na portu 3333.
make debuganimake gdbho nepotřebují, ale když běží, připojí se k němu. Hodí se pro nástroje, které se na port 3333 připojují samy. Rozšíření pro VS Code ho nepotřebuje, OpenOCD si spustí samo stejně jakomake debug.
Starší verze toolchainu
Ve starších verzích toolchainu bylo nutné nejdřív v jiném terminálu spustit
make openocd a teprve potom make gdb nebo make cgdb.
Příkazy navíc¶
Náš toolchain přidává do GDB několik příkazů:
flash- přeloží projekt (
make elf), naflashuje ho do chipu a zastaví namain(). Když překlad selže, do chipu se nic nenaflashuje. reset,r,run,start- resetuje chip a nechá program doběhnout na
main()(v cgdb je to klávesaF5). Pokud je na disku novější program než v chipu, nejdřív ho naflashuje. vars- vypíše argumenty a lokální proměnné aktuální funkce. Po každém zastavení se
vypisují automaticky;
vars offto vypne,vars onzase zapne. Hodnoty typuuint8_tse píšou jako čísla, ne jako znaky. regs- vypíše registry procesoru (
info registers: A, X, Y, SP, PC, CC). Registry periferií vypíšesfr. sfr- vypíše registry periferií (GPIO, časovače, UART, …) s rozpisem bitů, viz Registry periferií
bm- nastaví breakpoint na
main()
Příkazy, které jste zadávali, si GDB pamatuje i do příštího ladění (soubor
~/.gdb_history_stm8). Šipka nahoru nebo Ctrl+R je najde.
Nový kód za běhu ladění¶
Debugger nemusíte zavírat. Upravte zdroják a v jiném terminálu (nebo z editoru) zavolejte:
1 | |
Program se naflashuje a zastaví na main(). Totéž udělá příkaz flash
přímo v GDB.
Breakpointy i display zůstávají nastavené. Breakpoint je ale vázaný na číslo
řádku, takže po větší úpravě zdrojáku může ukazovat jinam.
display si pamatuje i příště¶
Seznam display se ukládá a příští make debug ho obnoví. display lokální
proměnné jiné funkce než main() se vytvoří, až program v té funkci zastaví.
Registry periferií¶
GDB zná periferie ze stm8s.h pod stejnými jmény jako Céčko. Můžete je číst, zapisovat,
dávat do display a hlídat watchem. Tabulátor doplňuje jména periferií, registrů
i bitových masek.
p GPIOB->ODR- vypíše výstupní registr portu B
p GPIOB- vypíše celou periferii (všechny její registry)
display GPIOB->ODR- vypisuje registr po každém zastavení (ukládá se do
.debug-displayjako každýdisplay) set var GPIOD->ODR |= 0x10- nastaví bit v registru, stejně jako v Céčku
p/t SPI->CR2 & SPI_CR2_SSM- bitové masky ze
stm8s.hfungují také, výraz vypíše hodnotu bitu SSM (binárně) p TIM4_CR1_RESET_VALUE- hodnota registru po resetu ze
stm8s.h p TIM<Tab>,p TIM4-><Tab>,p SPI_CR2_<Tab>- doplní periferii, její registry, resp. masky bitů
Místo -> jde psát i tečku: SPI->CR1 a SPI.CR1 je v GDB totéž. (V Céčku to
záměnné není, GDB je jen shovívavější.)
V Céčku je SPI makro ((SPI_TypeDef *) 0x5200), tedy ukazatel na strukturu, a
*SPI je celá struktura. V GDB je SPI rovnou struktura umístěná na adrese
0x5200, žádný ukazatel. Hvězdička jde použít jen na ukazatel, takže p *SPI
skončí chybou. Celou periferii vypíšete bez ní: p SPI v GDB odpovídá *SPI v Céčku.
Jak výpis vypadá: registr se vypíše šestnáctkově, binárně a se jmény
nastavených bitů. Vícebitové pole má hodnotu, třeba PSC=7. Co se změnilo od
minulého zastavení, je zvýrazněné žlutě a ukáže se původní hodnota:
1 2 | |
Díky tomu hned vidíte, co po next nebo finish program v registrech změnil.
Když se registr mezi dvěma zastaveními nezměnil, zvýraznění zmizí.
Použijte display bez /x
display/x a p/x obcházejí formátování registrů: dostanete jen holé číslo,
bez rozpisu bitů a bez zvýraznění změny. Pro registry proto pište
display GPIOB->ODR. Hex stejně vidíte vždycky.
Příkaz sfr¶
sfr- vypíše seznam periferií, které má zvolený čip, i s adresami
sfr TIM4,sfr TIM4 GPIOB- vypíše registry jedné nebo více periferií a nastavené bity
sfr TIM4.CR1- vypíše jeden registr bit po bitu, s popisem, hodnotou po resetu a komentáři ke každému bitu
help sfr- krátká nápověda
Malá písmena fungují (sfr tim4) a tabulátor doplňuje jména (sfr TIM4.<Tab>).
Program musí stát, za běhu sfr skončí chybou „Program běží“. Zastavíte ho Ctrl+C.
Registry časovače TIM4 s běžícím milis():
1 2 3 4 5 6 7 8 9 | |
Když se bit od minulého výpisu vynuloval, ukáže se jako -CEN (tlumeně). U 16bitových
registrů, které jsou po bytech (CNTRH/CNTRL), sfr přidá i celou hodnotu (CNTR=0x04d2 (1234)).
Detail jednoho registru, tady nastavení hodinového děliče:
1 2 3 4 5 6 7 | |
Čtení, které maže příznaky
U některých registrů čtení mění stav periferie: UART1->DR maže příznak
RXNE (a tedy přijatý znak), podobně SPI->DR, I2C->DR a I2C->SR3,
FLASH->IAPSR a AWU->CSR. Příkaz sfr UART1 je proto nečte a napíše
nečteno, čtení maže příznaky. Vypsat je můžete výslovně: sfr UART1.DR. Pozor, p UART1 a display UART1 (celá periferie) je přečtou.
Časovače běží i při zastaveném programu
Procesor stojí, ale periferie ne. TIM4->CNTR se proto mění i mezi dvěma
výpisy při jednom zastavení. Není to chyba výpisu.
Pod kapotou¶
Tato část je pro zvědavé a pro případ, že něco nefunguje. Pro běžné ladění ji číst nemusíte.
Konfigurační soubory¶
.make/gdbinit— konfigurace GDB (hezký výpis struktur, historie příkazů,set print symbol offproti hlášceInternal error: pc ... in read in CU, kterou GDB kvůli ladicím informacím ze SDCC občas vypisuje u adres dat),.make/stm8gdb.py— přidává do GDB příkazy navíc,.make/stm8sfr.py— registry periferií: příkazsfr, výpis bitů a zvýraznění změn, viz Registry periferií,.make/sfr_gen.py— generátor popisu registrů (viz Jak GDB zná registry),build-*-elf/sfr.elf,build-*-elf/sfr.json— jeho výstup. Vytváří se přimake debuga znovu jen když se změnístm8s.h, generátor neboMakefile,.debug-display— seznamdisplayz minulého ladění (v adresáři projektu). Obsahuje jeden výraz na řádek, takže ho jde editovat i ručně..debug-session— PID běžícího GDB. Podle nějmake flashpozná, že běží ladění (viz Flash za běhu ladění),build-*-elf/openocd.log— log OpenOCD.
Barevné hodnoty: na začátku .make/stm8gdb.py je VALUE_COLOR = "". Když tam
dáte kód barvy (třeba "35" pro fialovou), GDB obarví hodnoty v print, display,
watch a info locals. p/x a display/x zůstanou bez barvy.
Ruční spuštění GDB¶
GDB můžete spustit i ručně. Přesně tohle dělá make gdb.
1 | |
Takto spuštěné GDB si ale OpenOCD samo nespustí (příkaz pro OpenOCD mu předává
až Makefile) a připojí se jen k již běžícímu make openocd. Registry periferií se
načtou, jen když vedle programu (out.elf) leží sfr.elf se sfr.json. Vytvoří je
make debug, takže stačí ho jednou spustit. Jinak GDB při startu varuje, že
registry periferií nejsou k dispozici.
Připojení a spuštění programu¶
O připojení k chipu se postará make debug. Pod kapotou dělá zhruba toto:
1 2 3 4 5 6 | |
target extended-remote | openocd ...— GDB si OpenOCD spustí sám a komunikuje s ním rourou (pipe) místo TCP portu 3333. Když GDB skončí, skončí i OpenOCD.load— naflashuje program (ELF) do paměti chipu.monitor reset halt— resetuje chip a zastaví ho.maintenance flush register-cache— GDB neví, že reset změnil registry (hlavně PC), a ukazoval by starou pozici programu. Proto se musí jeho cache zahodit.tbreak mainacontinue— program doběhne na začátekmain()a zastaví se.
Jak GDB zná registry¶
SDCC do ELF nedává makra ani typy periferií (GPIO_TypeDef, TIM4_TypeDef), takže
GDB by GPIOB nepoznal. Generátor .make/sfr_gen.py proto vytvoří pomocný program:
- projde
stm8s.hpro zvolený čip a najde periferie (GPIOB,TIM4, …), - pro každou napíše
__at(TIM4_BaseAddress) TIM4_TypeDef TIM4;, tedy proměnnou na adrese periferie, - přeloží to SDCC do
sfr.elf. Je v něm jen ladicí informace, žádný kód, takže se neplete s vaším programem (abreak mainmá jedno místo), - vedle uloží
sfr.jsons bitovými maskami, hodnotami po resetu a komentáři zestm8s.h.
GDB si sfr.elf při startu přidá příkazem add-symbol-file, masky nadefinuje jako
makra (macro define SPI_CR2_SSM 0x02) a od té chvíle zná TIM4->CR1 i SPI_CR2_SSM.
Načtení trvá asi 10 ms, generování sfr.elf asi 0,1 s a jen po změně stm8s.h.
Při krokování se nic navíc nečte: registr se z chipu čte, až když ho vypíšete
nebo máte v display.
Flash za běhu ladění¶
Když běží make debug, make flash program jen přeloží — ST-LINK totiž drží
debugger. Do chipu program naflashuje GDB: hlídá soubor s programem, a jakmile se
změní, zastaví běžící program, naflashuje nový a zastaví na main().
Ruční ovládání chipu (OpenOCD)¶
Příkazy monitor předává GDB přímo OpenOCD.
monitor reset halt- resetuje chip a zastaví ho. GDB ale neví, že se změnily registry, a ukazuje
starou pozici programu. Proto potom zadejte
maintenance flush register-cache. monitor reset run- resetuje chip a spustí program. Pozor: přes GDB (s OpenOCD 0.12) hlásí
Protocol error with Rcmda chip zůstane stát. Spolehlivější jemonitor reset halta potommonitor resume. monitor resume- rozběhne zastavený chip (GDB o tom neví — při ladění použijte raději
continue) monitor halt- zastaví běžící program
load- ručně naflashuje program do chipu (obvykle není potřeba, dělá to
make debugaflash) target extended-remote localhost:3333- ručně se připojí k OpenOCD spuštěnému přes
make openocd(obvykle není potřeba, připojení zařídímake debug)