Časť 1 Zostava ARM TI RSLK Robotics Learning Curriculum Lab Lab 7 STM32 Nucleo: 16 Steps

2024 Autor: John Day | [email protected]. Naposledy zmenené: 2024-01-30 11:57

Tento návod je zameraný na mikrokontrolér STM32 Nucleo. Motivácia k tomu, aby bolo možné vytvoriť montážny projekt z holých kostí. Pomôže nám to preniknúť hlbšie a porozumieť projektu MSP432 Launchpad (TI-RSLK), ktorý je už témou niekoľkých inštrukcií.

Online pomoc pri vytváraní projektu iba pre zostavy pre MSP432 pomocou Code Composer Studio nie je k dispozícii. Doteraz sme len kopírovali/vkladali z už existujúceho projektu montáže. Tento prístup nám dobre slúžil.

Teraz sme však v prípade laboratória 7 narazili na malý problém. Alebo aspoň dočasnú škytavku. Lab 7 predstavuje stroje konečných stavov a prvá vec, s ktorou sa stretávame, je potreba vytvoriť a používať množstvo hodnôt. Pretože kurz TI používa hlavne programovanie v jazyku C - nie je to problém. Tieto inštrukcie sa však zamerali na montáž, nie na C.

Ďalej, pretože pole má hodnoty iba na čítanie, bolo by dobré ho vložiť do pamäte Flash, nie do pamäte RAM.

Zdá sa, že online je oveľa väčšia pomoc pri montážnych projektoch pomocou MCU STM32, a preto začíname týmto návodom, s cieľom použiť naučené, a potom použiť na MSP432 a Code Composer Studio.

Na ceste k tomuto cieľu získame skúsenosti aj s ďalším, obľúbeným mikro-ovládačom.

Krok 1: Počiatočný test zariadenia

Opäť, prečo si vybrať konkrétne STM32 Nucleo?

Úprimne? Pretože som hľadal dobré články o montážnych projektoch z holého kovu na radiče ARM a narazil som na túto sériu. A tiež preto, že sa zdá, že STM32 je populárny MCU.

Urobil som malý prieskum (na výber je veľa verzií - pozri obrázok vyššie), ale nakoniec sa ukázalo, čo vlastne môžem získať, pretože som používal Amazon (v USA).

Dodáva sa v jednoduchom, ale profesionálnom balení s niekoľkými pokynmi na spustenie. Bolo trochu zábavné sledovať, že demo napálené do ovládača bolo takmer presne to, čo sme robili v minulosti Instructables - LED dióda bliká a mení rýchlosť podľa stlačenia tlačidla.

Zdá sa, že táto vývojová doska je veľmi podobná MSP432 v tom, že sú tam 2 LED diódy a jedno užívateľské tlačidlo. MSP432 má 2 užívateľské tlačidlá.

Ako vidíte na fotografiách, trochu ma zarazilo, že doska má mini a nie micro USB. Museli sme vyčerpať kúpiť šnúru.

Ďalším dobrým testom je, že keď ho pripojíte k počítaču (používam Linux), zobrazí sa v mojom správcovi súborov ako súborový systém s názvom „NODE_F303RE“. Otvorenie, ktoré odhalí dva súbory, jeden HTML a jeden text.

To je všetko, ale aspoň sa tiež hovorí, že konektivita sa zdá byť celkom jednoduchá.

Teraz sme pripravení začať.

Pokúsim sa neopakovať niektoré z dobrých informácií zo série článkov IVONOMICON Bare Metal, ale skôr ich rozšíriť.

Krok 2: Základy

Prvá vec, ktorú potrebujeme, je kompilátor.

A potom potrebujeme debugger:

devchu@chubox: ~ $ sudo apt-get install gdb-arm-none-eabiPrečítanie zoznamov balíkov … Hotovo Budovanie stromu závislostí Informácie o stave čítania … Hotovo Budú nainštalované nasledujúce NOVÉ balíky: gdb-arm-none-eabi 0 aktualizovaných, 1 novo nainštalované, 0 na odstránenie a 8 neaktualizovaných. Potrebujete získať 2 722 kB archívov. Po tejto operácii sa použije 7, 738 kB dodatočného miesta na disku. Získajte: 1 https://us.archive.ubuntu.com/ubuntu xenial/universe amd64 gdb-arm-none-eabi amd64 7.10-1ubuntu3+9 [2, 722 kB] Načítané 2, 722 kB za 1 s (1, 988 kB/s) Výber predtým nevybraného balíka gdb-arm-none-eabi. (Číta sa databáza… 262428 súborov a adresárov je aktuálne nainštalovaných.) Príprava na rozbalenie…/gdb-arm-none-eabi_7.10-1ubuntu3+9_amd64.deb… Rozbaľovanie gdb-arm-none-eabi (7.10-1ubuntu3+9)… spracovanie spúšťače pre man-db (2.7.5-1)… Nastavenie gdb-arm-none-eabi (7.10-1ubuntu3+9)…

Krok 3: Základy - Windows

Vyššie uvedený krok predpokladal, že používame Linux. Čo keď používame Windows?

Môžete ísť na stránku Arm Developer a je k dispozícii niekoľko možností sťahovania. Používam počítač so systémom Windows 8.

Počas inštalácie som sa rozhodol nainštalovať ho na koreňovú jednotku „C: \“namiesto programových súborov len preto, že tiež používam cygwin, a bolo jednoduchšie vytvoriť odkaz z môjho lokálneho priečinka na koreňový priečinok C: ako všetky neporiadok na ceste k programovým súborom (s medzerami atď.).

Moje prostredie a cesta cygwin atď. Vyzerá takto:

C: / cygwin64 / home / bin / arm-none-eabi-gcc, kde arm-none-eabi-gcc je odkaz na C: / GNUToolsArmEmbedded / 7.2018.q2.update / bin / arm-none-eabi- gcc.

Potom som vytvoril priečinok „dev“pod cygwin home a tam som umiestnil súbor core. S a spustil príkaz kompilátora. (veci kompilátora nájdete nižšie).

Presne to isté som urobil pre gdb (arm-none-eabi-gdb).

Krok 4: Aké sú náležitosti

Čo je teda „gcc-arm-none-eabi“?

Kompilátor gnu (GCC) skomplikuje programovacie jazyky (ako C) do natívneho kódu pre stroj, na ktorom beží. Ak by ste napríklad na počítači so systémom Windows skompilovali nejaký kód C pomocou GCC, bol by postavený tak, aby bežal na počítači so systémom Windows. Generovaný spustiteľný súbor nebude (spravidla) bežať na mikrokontroléri ARM.

Aby sme teda mohli vytvárať programy, ktoré sa majú stiahnuť a napáliť do mikrokontroléra ARM (v našom súčasnom prípade by to bol STM32 Nucelo), musíme dať GCC niečo iné: schopnosť „krížovo skompilovať“. To znamená, že je možné vygenerovať spustiteľný súbor nie pre jeho natívny systém (a procesor), ale pre cieľový systém (mikrokontrolér ARM). Tu vstupuje do hry „gcc-arm-none-eabi“.

Čo je teda „gdb-arm-none-eabi“?

Akonáhle stiahneme a vypálime (flashujeme) novo generovaný spustiteľný súbor do mikrokontroléra, pravdepodobne ho budeme chcieť odladiť-prechádzať riadok po riadku kódu. GDB je debugger GNU a tiež potrebuje spôsob, ako vykonávať svoju prácu, ale zameriava sa na iný systém.

Gdb-arm-none-eabi je teda pre GDB, čo je gcc-arm-none-eabi pre GCC.

Ďalšou navrhovanou inštaláciou balíka bolo „libnewlib-arm-none-eabi“. Čo je to?

Newlib je knižnica C a matematická knižnica určená na použitie vo vstavaných systémoch. Je to konglomerát niekoľkých častí knižnice, všetky pod licenciami bezplatného softvéru, ktoré ich robia ľahko použiteľnými vo vstavaných produktoch.

A nakoniec balík „libstdc ++-arm-none-eabi“. Ten je celkom očividný; je to knižnica C ++ pre krížový prekladač; pre vstavané mikrokontroléry ARM.

Krok 5: Súbor linkera

Vytvorme skript linkera.

Jednou kľúčovou časťou alebo blokom v tomto súbore by bol príkaz MEMORY.

--- zo zdroja sourceware.org:

Predvolená konfigurácia linkera umožňuje pridelenie všetkej dostupnej pamäte. Môžete to prepísať pomocou príkazu MEMORY. Príkaz MEMORY popisuje umiestnenie a veľkosť blokov pamäte v cieli. Môžete ním popísať, ktoré pamäťové oblasti môže linker použiť a ktorým pamäťovým oblastiam sa musí vyhnúť. Potom môžete priradiť sekcie ku konkrétnym oblastiam pamäte. Linker nastaví adresy sekcií na základe oblastí pamäte a upozorní na oblasti, ktoré sú príliš plné. Linker nebude miešať sekcie, aby sa zmestili do dostupných oblastí. Skript linkera môže obsahovať mnoho použití príkazu MEMORY, ale so všetkými definovanými blokmi pamäte sa zaobchádza tak, ako keby boli zadané v rámci jedného príkazu MEMORY. Syntax pre MEMORY je:

PAMÄŤ

{name [(attr)]: ORIGIN = pôvod, LENGTH = len …}

Príklad v článku:

/* Definujte koniec RAM a limit zásobníkovej pamäte* //* (4KB SRAM na riadku STM32F031x6, 4096 = 0x1000)*//* (RAM začína na adrese 0x20000000) _estack = 0x20001000;

PAMÄŤ

{FLASH (rx): ORIGIN = 0x08000000, LENGTH = 32K RAM (rxw): ORIGIN = 0x20000000, LENGTH = 4K}

Musíme teda zistiť, koľko FLASH (pre náš program a konštanty atď.) A koľko pamäte RAM (pre použitie programom; halda a zásobník atď.) Pre našu konkrétnu dosku. Začína to byť trochu zaujímavé.

Pekná malá karta, ktorá sa dodáva s Nucleo, hovorí, že má flash pamäť 512 kB a SRAM je 80 kB. Po pripojení k USB sa však pripojí ako súborový systém s dvoma súbormi a správca súborov aj GParted naznačujú, že má viac ako 540+ kB. (RAM?).

ALE, pokus o odstránenie dvoch súborov pomocou správcu súborov, odpojenie a opätovné pripojenie zariadenia, stále zobrazuje tieto dva súbory. (a správca súborov niečo rozpoznal, pretože na každom súbore je malá ikona „zámku“.

Poďme teda k figúrkam na karte. Teraz teda vezmeme vyššie uvedený príklad a prevedieme ho na našu konkrétnu dosku.

Možno budete chcieť použiť niečo ako tento online prevodník pamäte, aby ste prešli zo všeobecnej KB na konkrétny počet bajtov.

Potom možno budete chcieť použiť online prevodník desatinných miest na hex.

/ * Definujte koniec pamäte RAM a limit zásobníkovej pamäte */

/* (4KB SRAM na riadku STM32F031x6, 4096 = 0x1000)* //* príklad*/

/ * krok 1: (80 kB SRAM na STM32F303RE, 81920 = 0x14000) * // * naša doska */

/* krok 2, pridajte veľkosť hexu na počiatočnú adresu hex (nižšie). */

/ * (RAM začína na adrese 0x20000000) */

_estack = 0x20001000; / * príklad */

_estack = 0x20014000; / * naša rada */

PAMÄŤ {

FLASH (rx): ORIGIN = 0x08000000, DĹŽKA = 512K

RAM (rxw): PÔVOD = 0x20000000, DĹŽKA = 80K

}

Nazvime vyššie uvedený súbor „linker.script.ld“.

Krok 6: Vektorová tabuľka

Teraz vytvoríme malý súbor zostavy (so smernicami), ktorý bude vykonávať niekoľko základných činností spojených s prerušením. Nasledujeme príklad článku a vytvoríme súbor s názvom „core. S“.

Opäť je tu príklad obsahu súboru, ale vykonal som zmenu pre našu konkrétnu tabuľu:

// Tieto pokyny definujú atribúty nášho čipu a

// jazyk zostavy, ktorý použijeme:.syntax zjednotený /*Pozri ďalej za touto oblasťou kódu* //*.cpu cortex-m0* / /*komentuj tento riadok príkladu* /.cpu cortex-m4 /* namiesto toho pridajte kôru našej dosky. pozri obrázok vyššie v tomto kroku * / /*.fpu softvfp * / / *komentujte tento riadok príkladu * /.fpu vfpv4 / *pridajte namiesto toho naše nástenky; má FPU */.thumb // Globálne pamäťové miesta..global vtable.global reset_handler / * * Aktuálna vektorová tabuľka. * Pre jednoduchosť je zahrnutá * iba veľkosť pamäte RAM a obslužný program „reset“. */.typ vtable, %objekt vtable:.word _estack.word reset_handler. veľkosť vtable,.-vtable

Hmm.. Žiadna smernica „.align“

To však nie je kritické. O tom (možno) neskôr.

.syntax zjednotený

.syntax [zjednotený | rozdelený]

Táto smernica nastavuje syntax inštrukčnej sady podľa popisu v sekcii ARM-Instruction-Set

9.4.2.1 Syntax sady inštrukcií Dve mierne odlišné syntaxe podporujú pokyny ARM a THUMB. Predvolený, rozdelený, používa starý štýl, v ktorom mali pokyny ARM a THUMB svoje vlastné, oddelené syntaxe. Nová, zjednotená syntax, ktorú je možné vybrať prostredníctvom smernice.syntax.

.fpu vfpv4

Kompilátor GCC môže vytvárať binárne súbory s niekoľkými možnosťami týkajúcimi sa pohyblivej rádovej čiarky: mäkký - vhodný na spustenie na procesoroch bez FPU - výpočty sa vykonávajú v softvéri na základe softvéru generovaného kompilátorom softfp - vhodný na beh na CPU s alebo bez FPU - bude používať FPU, ak je k dispozícii. Pre náš konkrétny prípad (budete si musieť urobiť vlastný prieskum) je FPU tejto konkrétnej dosky v súlade s vfpv4. S týmto sa možno budete musieť pohrať. Alebo to dokonca nechajte na softfp.

. thumb (vs. arm)

Tieto mikrokontroléry ARM majú v skutočnosti kombináciu inštrukčných sád. Jeden je ARM, druhý PALEC. Jedným rozdielom sú 16-bitové inštrukcie oproti 32-bitovým inštrukciám. Táto smernica teda prikazuje kompilátoru, aby s nasledujúcimi pokynmi zaobchádzal buď ako PALEC alebo ARM.

Vezmeme zvyšok súboru tak, ako je, pretože tieto inštrukcie sa ešte nezačali zaoberať programovaním zostáv riadených prerušením.

Krok 7: Verzia zostavy programu „Hello World“

Do predtým vytvoreného súboru „core. S“môže ísť aj nasledujúci text. Toto je opäť z príkladu v článku.

/ * * Obslužný program Reset. Volá sa pri resetovaní. */.type reset_handler, %function reset_handler: // Nastaví ukazovateľ zásobníka na koniec zásobníka. // Hodnota '_estack' je definovaná v našom skripte linkera. LDR r0, = _estack MOV sp, r0

// Nastavte nejaké hodnoty figuríny. Keď vidíme tieto hodnoty

// v našom debuggeri budeme vedieť, že náš program // je načítaný na čipe a funguje. LDR r7, = 0xDEADBEEF MOVS r0, #0 main_loop: // Pridajte 1 k registrácii 'r0'. PRIDÁVA r0, r0, #1 // Slučka späť. B main_loop.size reset_handler,.-Reset_handler

Cieľom vyššie uvedeného programu je načítať rozpoznateľný vzor do jedného jadrového registra MCU (v tomto prípade R7) a prírastkovú hodnotu začínajúcu od nuly do iného jadrového registra MCU (v tomto prípade R0). Ak prejdeme vykonávacím kódom, mali by sme vidieť prírastok údajov R0.

Ak ste sa riadili pokynmi týkajúcimi sa kurzov/laboratórií MSP432 a TI-RSLK, mal by vám byť známy takmer celý vyššie uvedený program.

Jedna nová vec, ktorú vidím, je použitie „=“pri načítaní „DEADBEEF“do registra R7. To sme nepoužili.

Tu priložený súbor „core. S“teraz obsahuje kompletný zdroj.

Krok 8: Zostavenie kódu

Je načase urobiť pár vecí v príkazovom riadku. Konečne niečo skutočné.

Nie sme tam však celkom. Znovu musíme vyladiť príkaz uvedený v článku a prispôsobiť ho našej vlastnej situácii.

Tu je ukážkový kód:

arm -none -eabi -gcc -x assembler -with -cpp -c -O0 -mcpu = cortex -m0 -mthumb -Wall core. S -o core.o

Ak prejdeme na stránku gnu.org pre GCC, (v tomto prípade verzia 7.3),

X

-X je na zadanie jazyka. V opačnom prípade, ak nie je -x, kompilátor sa pokúsi uhádnuť pomocou prípony súboru. (v našom prípade *. S).

Vyššie uvedený príklad z článku špecifikuje assembler-s-cpp, ale mohli by sme urobiť len assembler.

c

-C hovorí: „skompilovať, ale neprepojiť.

O0

-O je nastavenie úrovne optimalizácie. Použitie -O0 (oh -nula) hovorí "skrátiť čas kompilácie a dosiahnuť, aby ladenie prinieslo očakávané výsledky. Toto je predvolené nastavenie".

mcpu = kôra-m0

Parameter -mcpu určuje názov cieľového procesora. V našom prípade by to bol cortex-m4.

mumlat

-Mthumb Špecifikuje výber medzi generovaním kódu, ktorý vykonáva stavy ARM a THUMB.

Stena

-Stena je samozrejme veľmi bežná a známa. Zapne všetky výstražné vlajky.

Nakoniec na konci príkazu máme vstupný súbor core. S a výstupný súbor core.o.

Tu je výsledný nový príkazový riadok, ktorý vyhovuje nášmu konkrétnemu prípadu.

arm -none -eabi -gcc -x assembler -c -O0 -mcpu = cortex -m4 -mthumb -Wall core. S -o core.o

A to bolo zostavené.

Krok 9: Prepojenie programu

Priamo z príkladu v článku máme toto:

arm -none -eabi -gcc core.o -mcpu = cortex -m0 -mthumb -Wall --specs = nosys.specs -nostdlib -lgcc -T./STM32F031K6T6.ld -o main.elf

Väčšinu z vyššie uvedeného ste už videli. Nižšie je uvedené, čo je nové.

-specs = nosys.specs

Toto je trochu zložité vysvetliť.

Súvisí to s „semihostingom“a „retargetingom“a súvisí so vstupom / výstupom. Súvisí to aj so systémovými hovormi a knižnicami.

Vstavané systémy spravidla neposkytujú štandardné vstupno -výstupné zariadenia. To by malo vplyv na volania systému alebo knižnice (príklad: printf ()).

Semihosting znamená, že debugger (pozri obrázok kroku 11 s časťou debuggera zakrúžkovanou červenou farbou) má špeciálny kanál a používa protokol semihosting a výstup printf () môžete vidieť na hostiteľskom počítači (prostredníctvom debuggera).

Retargeting, na druhej strane, znamená, že tie isté systémové alebo knižničné hovory znamenajú niečo iné. Robia niečo iné, čo dáva zmysel pre vstavaný systém. V istom zmysle, povedzme pre printf (), existuje nová implementácia, presmerovaná implementácia tejto funkcie.

Keď už sme to všetko povedali, --specs = nosys.specs znamená, že nebudeme semihostingmi. To by potom normálne znamenalo, že sa znova zameriavame. Tým sa dostávame k ďalšej vlajke.

nostdlib

Voľba linkera -nostdlib sa používa na prepojenie programu určeného na samostatné spustenie. -nostdlib implikuje jednotlivé možnosti -nodefaultlibs a -nostartfiles. Nasledujúce dve možnosti diskutujeme oddelene, ale najtypickejším použitím je iba jednoduchý nákup na jednom mieste. Pri prepojení hostiteľského programu sú štandardne prepojené štandardné systémové knižnice, ako napríklad libc, čo programu poskytuje prístup ku všetkým štandardným funkciám (printf, strlen a priatelia). Možnosť linkera -nodefaultlibs zakáže prepojenie s týmito predvolenými knižnicami; jediné prepojené knižnice sú presne tie, ktoré explicitne pomenujete pomocou linkera -l.

lgcc

libgcc.a je štandardná knižnica, ktorá poskytuje interné podprogramy na prekonanie nedostatkov konkrétnych počítačov. Napríklad procesor ARM neobsahuje inštrukciu delenia. ARM verzia libgcc.a obsahuje funkciu delenia a prekladač podľa potreby vysiela túto funkciu.

T

Toto je len spôsob, ako povedať linkerovi, aby použil tento súbor ako skript linkera. V našom prípade je názov súboru linker.script.ld.

o main.elf

Nakoniec odkazovaču povieme, aký bude názov konečného výstupného obrazového súboru, ktorý bude napálený/flashovaný do nášho zariadenia.

Tu je naša verzia úplného príkazového riadka, upravená pre našu konkrétnu situáciu:

arm -none -eabi -gcc core.o -mcpu = cortex -m4 -mthumb -Wall --specs = nosys.specs -nostdlib -lgcc -T./linker.script.ld -o main.elf

Zaisťujeme, aby súbor skriptu a súbor core.o boli v rovnakom adresári, kde spustíme vyššie uvedený príkazový riadok.

A spája sa bez problémov.

Kontrola

Potom spustíme:

arm-none-eabi-nm main.elf

a dostaneme:

devchu@chubox: ~/Development/Atollic/TrueSTUDIO/STM32_workspace_9.1 $ arm-none-eabi-nm main.elf 20014000 A _estack 08000010 t main_loop 08000008 T reset_handler 08000000 T vtable

Vyzerá dobre. Príkaz arm-none-eabi-nm je spôsob, ako vytvoriť zoznam symbolov v súboroch objektov.

Krok 10: Testovanie pripojenia k STM32 Nucleo-64

Ak sa ho rozhodnete prijať, vašou prvou misiou je nechať váš systém vidieť vývojovú dosku.

Používanie systému Windows

Pre Windows som sa rozhodol nainštalovať TrueSTUDIO z Atollic (bezplatná verzia). Bola to bezbolestná inštalácia a automaticky sa nainštaloval ovládač, aby som mohol použiť st-link na testovanie pripojenia. Hneď ako som nainštaloval TrueSTUDIO a správca zariadenia zariadenie videl, stiahol som si nástroje texan/stlink navrhnuté v článku o holých kovoch, ktorý sme sledovali. Priečinok som znova umiestnil priamo pod „C: \“a znova som vytvoril niekoľko odkazov z miestneho domáceho bin cygwin na príkazy.

ln -s /c/STM32. MCU/stlink-1.3.0-win64/bin/st-info.exe ~/bin/st-info

Ako počiatočný test, aby sme zistili, či môžeme so zariadením skutočne komunikovať, som spustil:

st-info-sonda

A vrátil sa:

Našiel sa 1 stlink programátor

Teraz teda vieme, že sa môžeme rozprávať/dotazovať na našej vývojovej doske.

Používanie Linuxu

V prípade Linuxu nepotrebujete žiadny ovládač. Ale pre Debian budete musieť vytvoriť prvé nástroje zo zdroja.

klon git

Uistite sa, že máte nainštalovaný libusb-1.0-0-dev.

výstižný zoznam | grep -E "*libusb.*dev*"

Mali by ste vidieť:

libusb-1.0-0-dev/xenial, teraz 2: 1.0.20-1 amd64 [nainštalované]

alebo niečo podobné.

Ak ho chcete nainštalovať:

sudo apt-get install libusb-1.0-0-dev

Uvedomte si, že vyššie uvedené nie je rovnaké ako:

sudo apt-get install libusb-dev

Správne chýbajúci libusb dev môže spôsobiť problémy s cmake.

Chyba CMake: V tomto projekte sú použité nasledujúce premenné, ale sú nastavené na NOTFOUND. Nastavte ich alebo sa uistite, že sú správne nastavené a testované v súboroch CMake: LIBUSB_INCLUDE_DIR (ADVANCED)

Prejdite do koreňového adresára projektu (… blah /blah /stlink). Vykonajte „uvoľnenie“.

Potom sa nástroje vytvoria pod „.. /build /Release“.

Potom môžete spustiť „st-info --probe“. Tu je výstup s pripojeným Nucleo, potom nie.

devchu@chubox: ~/Development/stlink $./build/Release/st-info --probeFound 1 stlink programmers serial: 303636414646353034393535363537 openocd: "\ x30 / x36 / x36 / x41 / x46 / x46 / x35 / x30 / x34 / x39 / x35 / x35 / x36 / x35 / x37 "blesk: 524288 (veľkosť stránky: 2048) sram: 65536 čipid: 0x0446 descr: F303 zariadenie s vysokou hustotou devchu@chubox: ~/Development/stlink $./build/Release/st- info --probe Found 0 stlink programmers devchu@chubox: ~/Development/stlink $

Krok 11: Používajme GDB s Linuxom

Ak ste to všetko skúšali a dostali ste sa až sem - skvelé! Vynikajúce. Teraz sa trochu pobavíme.

Keď si kúpite tieto vývojové dosky ARM, či už sú to MSP432 Launchpad od Texas Instruments, alebo tento, o ktorom teraz diskutujeme, Nucleo-F303 (STM32 Nucleo-64), zvyčajne dorazia už nabité spusteným programom, zvyčajne nejaký blinky program, ktorý zahŕňa aj stlačenie spínača na zmenu rýchlosti blikania diód LED.

Skôr než to rýchlo napíšeme, pozrime sa, čo je potrebné vidieť a robiť.

V systéme Linux otvorte terminál, zmeňte adresár projektu stlink git, ktorý sme práve vytvorili, a nájdite nástroj st-util.

devchu@chubox: ~/Development/stlink $ find. -názov st-util

./build/Release/src/gdbserver/st-util

Spustite ten nástroj. Pretože sme už predtým testovali naše spojenie so st-info --probe, mali by sme získať nejaký výstup takto:

devchu@chubox: ~/Development/stlink $./build/Release/src/gdbserver/st-util

st-util 1.4.0-50-g7fafee2 2018-10-20T18: 33: 23 INFO spoločné.c: Načítavajú sa parametre zariadenia…. 2018-10-20T18: 33: 23 INFO common.c: Pripojené zariadenie je: zariadenie s vysokou hustotou F303, id 0x10036446 2018-10-20T18: 33: 23 INFO common.c: veľkosť SRAM: 0x10000 bytes (64 KiB), Flash: 0x80000 bajtov (512 KiB) na stránkach s 2 048 bajtmi 2018-10-20T18: 33: 23 INFO gdb-server.c: ID čipu je 00000446, ID jadra je 2ba01477. 2018-10-20T18: 33: 23 INFO gdb-server.c: Počúvame o *: 4242…

To je teraz spustený server GDB, ktorý vidí našu vývojovú dosku, a čo je dôležitejšie, počúva na porte 4242 (predvolený port).

Teraz sme pripravení na spustenie klienta GDB.

V systéme Linux otvorte iný terminál a zadajte tento:

arm-none-eabi-gdb -tui

To je to isté ako spustenie príkazového riadka gdb prísne, ale namiesto toho produkuje textový terminál (myslím, že používa kliatby).

Máme spusteného klienta GDB a server GDB. Klient však nie je pripojený k serveru. V súčasnosti nevie nič o našom Nucleo (alebo doske podľa vášho výberu). Musíme to povedať. V termináli by teraz mala byť vaša výzva „(gdb)“. Zadajte:

pomocný cieľ

Poskytne vám zoznam. Všimnite si, že ten, ktorý chceme, je cieľový rozšírený -diaľkový - Použite vzdialený počítač cez sériovú linku.

Musíme mu však dať aj miesto. Na výzvu (gdb) teda zadajte:

(gdb) cieľ rozšíreného vzdialeného lokálneho hostiteľa: 4242

Odpoveď by ste mali dostať približne takto:

(gdb) cieľ rozšíreného vzdialeného lokálneho hostiteľa: 4242

Vzdialené ladenie pomocou localhost: 4242 0x080028e4 v? ()

Medzitým sme na termináli, na ktorom je spustený server st-util gdbserver, získali toto:

2018-10-20T18: 42: 30 INFO gdb-server.c: Nájdených 6 registrov zarážok hw

2018-10-20T18: 42: 30 INFO gdb-server.c: GDB pripojené.

Krok 12: Zopakujme si, s Windows a Flash náš program

Kroky na spustenie servera st-util gdbserver a klienta arm-none-eabi-gdb sú v zásade rovnaké ako v predchádzajúcom kroku. Otvoríte dva terminály (cygwin, DOS cmd alebo Windows Powershell), nájdete umiestnenie st-util a spustíte ho. Na druhom termináli spustite klienta arm-none-eabi-gdb. Jediným rozdielom je, že režim -tui (zobrazenie textu založené na termináloch) s najväčšou pravdepodobnosťou nie je podporovaný.

Ak vyššie uvedené fungovalo v systéme Windows, pravdepodobne budete musieť zastaviť (iba klient). V tomto okamihu budete nejako musieť spustiť klienta GDB, kde je váš súbor buildu („core.out“), alebo pridať celú cestu k tomuto súboru ako argument pre klienta GDB.

Zjednodušil som si život používaním cygwin a vytváraním odkazov z môjho miestneho adresára $ HOME // bin, kde sa oba tieto nástroje nachádzajú.

Ok, skompilovali sme a prepojili sme rovnako ako predtým a máme súbor main.elf pripravený na spustenie.

V jednom okne máme spustený st-util. Reštartujeme klienta GDB, tentoraz urobíme:

arm-none-eabi-gdb main.elf

Necháme ho spustiť, počkáme na výzvu (gdb), urobíme rovnaký príkaz pripojenia k serveru GDB (st-util) a sme pripravení na spustenie spustiteľného súboru. Je to veľmi proti klimatické:

(gdb) zaťaženie

Pri prevádzke s terminálmi cygwin je známy problém s tým, že sa niekedy nevydávajú príkazy konzoly. Takže v našom prípade bolo okno spustené na serveri úplne tiché. Ten, na ktorom je spustený klient, kde sme spustili zaťaženie, vydá toto:

Načítava sa sekcia.text, veľkosť 0x1c lma 0x8000000Začiatočná adresa 0x8000000, veľkosť načítania 28 Prenosová rýchlosť: 1 KB/s, 28 bajtov/zápis.

Krok 13: Blikanie v systéme Linux - viac odmeňovania: D

Krok 14: Ponorme sa trochu hlbšie

Ak ste sa sem dostali, vynikajúce. Poďme ďalej.

Prečo sa nepozrieť do spustiteľného súboru main.elf? Spustite nasledujúce:

arm-none-eabi-objdump -d main.elf

Mali by ste vidieť výstup niečo takéto:

main.elf: formát súboru elf32-littlearm

Demontáž sekcie.text:

08000000:

8000000: 00 40 01 20 09 00 00 08.@. ….

08000008:

8000008: 4802 ldr r0, [ks, #8]; (8000014) 800000a: 4685 mov sp, r0 800000c: 4f02 ldr r7, [ks, #8]; (8000018) 800000e: 2 000 pohybov r0, #0

08000010:

8000010: 3001 pridá r0, #1 8000012: e7fd b.n 8000010 8000014: 20014000.slovo 0x20014000 8000018: mŕtve hovädzie mäso.slovo 0xdeadbeef

Aké malé nugety môžeme získať z vyššie uvedeného výstupu?

Ak si pamätáte, keď sme diskutovali a vytvárali súbor linker.script.ld, uviedli sme, že tieto zariadenia ARM majú RAM od 0x20000000 a že pamäť FLASH začína od 0x08000000.

Vidíme teda, že program je skutočne taký, že je celý uložený v pamäti FLASH.

Potom, vyššie, ale v neskoršom kroku, keď sme diskutovali o časti „Hello World“, došlo k vyhláseniu, v ktorom načítame okamžitú, konštantnú, doslovnú hodnotu („0xDEADBEEF“) do jadrového registra MCU („R7“).

Vyhlásenie bolo:

LDR R7, = 0xDEADBEEF

V našom kóde je to jediné miesto, kde dokonca spomíname DEADBEEF. Nikde inde. A napriek tomu, keď sa pozriete na vyššie uvedené rozobraté/zrekonštruované pokyny atď., Existuje viac vecí, ktoré sa týkajú DEADBEEF, ako sme si mysleli.

Kompilátor/linker sa teda nejakým spôsobom rozhodol natrvalo blikať hodnotu DEADBEEF na adresu FLASH, na mieste 0x8000018. A potom kompilátor zmenil našu vyššie uvedenú inštrukciu LDR na:

LDR R7, [PC, č. 8]

Dokonca nám to vytvorilo komentár. Aké milé. A hovorí nám, aby sme zobrali aktuálnu hodnotu počítadla programu (register PC), k tejto hodnote pripočítali 0x8 a tam bolo vypálené DEADBEEF, a aby sme túto hodnotu získali a napchali do R7.

To tiež znamená, že počítadlo programov (PC) smerovalo na adresu 0x8000010, čo je začiatok súboru main_loop, a že hodnota DEADBEEF je na dvoch adresách po skončení main_loop.

Krok 15: Nakoniec sa stručne pozrite na spustený program

Aj keď ukončíte GDB, znova zadajte príkaz. Dokonca mu nemusíte dávať žiadny súbor; už sa neblikáme, iba to spustíme.

Po opätovnom pripojení klienta GDB k serveru GDB na príkazovom riadku (gdb):

(gdb) informačné registre

Mali by ste vidieť niečo také:

r0 0x0 0

r1 0x0 0 r2 0x0 0 r3 0x0 0 r4 0x0 0 r5 0x0 0 r6 0x0 0 r7 0x0 0 r8 0x0 0 r9 0x0 0 r10 0x0 0 r11 0x0 0 r12 0x0 0 sp 0x20014000 0x20014000 lr 0xffffffff 4294967295

Potom však na výzvu (gdb) zadajte:

(gdb) pokračovať

A veľmi rýchlo stlačte CTRL-C. To by malo pozastaviť program. Znova zadajte príkaz "informačné registre".

Dnes to vyzerá inak:

(gdb) informačné registre

r0 0x350ffa 3477498 r1 16777216

Čo sa stalo? Presne to, čo sme chceli. DEADBEEF bol načítaný do R7 a R0 sa (extrémne rýchlo) zvyšoval. Ak budete opakovať, znova uvidíte R0 s inou hodnotou.

Krok 16: Chceli sme vytvoriť pole iba na čítanie vo formáte Flash

Jeden zo spôsobov, ako vytvoriť ekvivalent poľa pomocou zostavy a smerníc, je nasledujúci:

.type myarray, %object // názov alebo štítok 'myarray' je definovaný ako typ objektu.

myarray: // toto je začiatok deklarácie 'myarray' // (z čoho bude pozostávať)..word 0x11111111 // prvý člen alebo hodnota obsiahnutá v 'myarray'..word 0x22222222 // druhá hodnota (susediace adresy)..word 0x33333333 // a tak ďalej..size myarray,.-myarray // kompilátor/assembler teraz vie, kde je koniec alebo // hranica 'myarray'.

Teraz, keď sme ho nastavili v pamäti FLASH, môžeme ho použiť v programe. Nasleduje časť:

LDR R1, myarray // toto načíta údaje obsiahnuté v 1. mieste 'myarray'. ' // toto nechceme.

LDR R1, = myarray // toto načíta samotnú hodnotu polohy (1. adresa), // nie údaje.. // toto je to, čo chceme.

MOV R2, #0 // R2 bude počítať, aby sme neodišli

// koniec poľa. LDR R3, = myarrsize // R3 bude ekvivalentom 'myarrsize'.

// R0 bude uchovávať naše údaje

main_loop:

LDR R0, [R1] // Do R0 načítajte údaje, na ktoré ukazuje R1 ('myarray'). CMP R2, R3 // Sme na hranici poľa? BEQ main_loop // Ak sme, skončili sme, takže sa budeme navždy opakovať.

ADD R2, #1 // V opačnom prípade môžeme iterovať cez pole.

PRIDAJTE R1, #4 // Pridajte 4, aby ste zaregistrovali R1, aby správne ukazovalo na ďalšie

// adresa..

B main_loop // Slučka späť.

Video týmto všetkým prechádza a je v ňom chyba. Je to dobré; ukazuje, že je dôležité spustiť a ladiť kód. Ukazuje klasický prípad vychádzania z konca poľa.