Index 🏠 || 🔝 Nahoru


Publikováno:

Aktualizováno

Série »STM8S toolchain«

Kategorie:

MITka

Tagy:

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 maskot >>

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:

  1. Základy GDB — obecné použití GDB: breakpointy, krokování, nahlížení do proměnných. Platí pro jakýkoliv program v C.
  2. cgdb — barevnější a přehlednější rozhraní nad GDB.
  3. Debuging s naším toolchainem — make debug a 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.

GDB %%

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
(gdb) next
52      if (milis() - time > 1234) {

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 jen Enter) 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.

GDB-TUI %%

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ód
  • layout asm — zobrazí assembler
  • layout split — zobrazí obojí
  • layout regs — přidá zobrazení registrů
  • focus cmd — přepne fokus na příkazový řádek
  • focus src — přepne fokus na okno se zdrojovým kódem
  • Ctrl+X O — přepíná fokus mezi src, cmd, asm, atd.
  • Ctrl+X S — režim jedné klávesy: n (next), s (step), f (finish), c (continue), r (run), v (info locals), q rež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/disabled
  • h+ / 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 array v 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 adresy array; 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é time hodnotu 0
p time = 0
totéž, print vý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é time pokaž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
while (1) {
    if (milis() - time > 1234) {
        ...
    }
}

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 za if,
  • nebo tbreak 56 a continue.

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é je skip 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:

  • skip ovlivňuje jen step. Příkaz next funkce 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, + 2 tř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.

cgdb %%

Instalace

Instalace je popsána zde.

Spuštění

Ručně se cgdb spouští zhruba takto:

1
cgdb -d stm8-gdb -- -x .make/gdbinit build-STM8S208-elf/out.elf

V našem projektu stačí zavolat:

1
make debug

(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 řádku
  • Ctrl+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 řádku
  • t — přidá/odebere dočasný (temporary) breakpoint na aktuálním řádku
  • j / k, 🡇 /🡅 — pohyb dolů/nahoru
  • Ctrl+F / Ctrl+B — stránkování dolů/nahoru
  • gg / G — skok na začátek/konec souboru
  • /pattern — hledání, n / N přeskakuje výsledky
  • o — 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, v make debug znovu od začátku main()
  • F6 — continue
  • F7 — finish
  • F8 — next
  • F10 — 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
make debug

Ten udělá vše potřebné:

  1. přeloží projekt s debug informacemi (make elf) a připraví popis registrů periferií (sfr.elf, viz Registry periferií),
  2. spustí OpenOCD — běží jen po dobu ladění, druhý terminál není potřeba,
  3. naflashuje program do chipu,
  4. resetuje chip a zastaví program na začátku funkce main(),
  5. 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 debug ani make gdb ho 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ě jako make 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í na main(). 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ávesa F5). 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 off to vypne, vars on zase zapne. Hodnoty typu uint8_t se píšou jako čísla, ne jako znaky.
regs
vypíše registry procesoru (info registers: A, X, Y, SP, PC, CC). Registry periferií vypíše sfr.
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
make flash

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-display jako 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.h fungují 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
1: GPIOB->ODR = 0x21 0010 0001  (bylo 0x01)
2: TIM4->CNTR = 0x3d 0011 1101  CNT=61  (bylo 0x31)

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
(gdb) sfr TIM4
TIM4  0x5340
  CR1    0x5340  0x81 1000 0001  ARPE CEN
  IER    0x5341  0x01 0000 0001  UIE
  SR1    0x5342  0x00 0000 0000
  EGR    0x5343  0x00 0000 0000
  CNTR   0x5344  0x2e 0010 1110  CNT=46
  PSCR   0x5345  0x07 0000 0111  PSC=7
  ARR    0x5346  0xf9 1111 1001  ARR=249

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
(gdb) sfr CLK.CKDIVR
CLK->CKDIVR  0x50c6  Clock Divider Register  (po resetu 0x18)
  = 0x00 0000 0000
  bit  7 6 5 4 3 2 1 0
       0 0 0 0 0 0 0 0
  4:3   HSIDIV   0  High speed internal clock prescaler
  2:0   CPUDIV   0  CPU clock prescaler

Č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 off proti hlášce Internal 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říkaz sfr, 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ři make debug a znovu jen když se změní stm8s.h, generátor nebo Makefile,
  • .debug-display — seznam display z 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ěj make flash pozná, ž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
stm8-gdb --tui -x .make/gdbinit build-STM8S208-elf/out.elf

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
(gdb) target extended-remote | openocd -f ... -c "gdb_port pipe"
(gdb) load
(gdb) monitor reset halt
(gdb) maintenance flush register-cache
(gdb) tbreak main
(gdb) continue
  • 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 main a continue — program doběhne na začátek main() 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:

  1. projde stm8s.h pro zvolený čip a najde periferie (GPIOB, TIM4, …),
  2. pro každou napíše __at(TIM4_BaseAddress) TIM4_TypeDef TIM4;, tedy proměnnou na adrese periferie,
  3. 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 (a break main má jedno místo),
  4. vedle uloží sfr.json s bitovými maskami, hodnotami po resetu a komentáři ze stm8s.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 Rcmd a chip zůstane stát. Spolehlivější je monitor reset halt a potom monitor 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 debug a flash)
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)

Související posty