1 dalis ARM surinkimas TI RSLK Robotikos mokymosi mokymo programa 7 STM32 branduolys: 16 žingsnių

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:45

Šio „Instructable“dėmesio centre yra „STM32 Nucleo“mikrovaldiklis. Motyvacija tam, kad būtų galima sukurti surinkimo projektą iš plikų kaulų. Tai padės mums įsigilinti ir suprasti MSP432 Launchpad projektą (TI-RSLK), apie kurį jau buvo kalbama keliose instrukcijose.

Internete nėra labai daug pagalbos, norint sukurti tik surinkimo projektą MSP432 naudojant „Code Composer Studio“. Iki šiol mes tik kopijavome/įklijavome iš jau esamo surinkimo projekto. Šis požiūris mums pasitarnavo.

Tačiau dabar dėl 7 laboratorijos susidūrėme su tam tikra problema. Arba bent jau laikiną žagsėjimą. „Lab 7“pristato baigtinės būsenos mašinas, ir pirmas dalykas, su kuriuo susiduriame, yra poreikis sukurti ir naudoti daugybę reikšmių. Kadangi TI kursuose daugiausia naudojamas C programavimas - tai nėra problema. Tačiau šios instrukcijos sutelkė dėmesį į surinkimą, o ne į C.

Be to, kadangi masyvas turi tik skaitymo reikšmes, būtų gerai jį įdėti į „flash“atmintį, o ne į RAM.

Atrodo, kad internete yra daug daugiau pagalbos surinkimo projektams, naudojantiems STM32 MCU, todėl mes pradedame nuo šios instrukcijos, siekdami panaudoti tai, kas išmokta, tada kreiptis į MSP432 ir „Code Composer Studio“.

Kelyje į šį tikslą mes taip pat įgijome patirties su dar vienu populiariu mikrovaldikliu.

1 žingsnis: pradinis įrenginio bandymas

Vėlgi, kodėl pasirinkti būtent STM32 Nucleo?

Sąžiningai? Kadangi ieškojau gerų straipsnių apie ARM valdiklių pliko metalo surinkimo projektus ir susidūriau su šia serija. Ir taip pat todėl, kad atrodo, kad STM32 yra populiarus MCU.

Aš padariau kai kuriuos tyrimus (yra daugybė versijų, iš kurių galima rinktis - žr. Paveikslėlį aukščiau), bet galų gale tai tapo tuo, ką iš tikrųjų galiu gauti, nes ketinau naudoti „Amazon“(JAV).

Jis tiekiamas paprastame, bet profesionaliame pakete su kai kuriomis paleidimo instrukcijomis. Buvo šiek tiek juokinga matyti, kad į valdiklį įrašyta demonstracija buvo beveik tokia, kokią mes padarėme ankstesnėse instrukcijose - šviesos diodas mirksi ir keičia greitį, paspaudus vieną mygtuką.

Atrodo, kad ši kūrimo plokštė yra labai panaši į MSP432, nes yra 2 šviesos diodai ir vienas vartotojo mygtukas. MSP432 turi 2 vartotojo mygtukus.

Kaip matote nuotraukose, buvau šiek tiek nustebęs, kad plokštėje yra mini, o ne „micro USB“. Teko bėgti nusipirkti laido.

Kitas geras testas yra tas, kad prijungus jį prie kompiuterio (aš naudoju „Linux“dėžutę), jis rodomas mano failų tvarkyklėje kaip failų sistema, vadinama „NODE_F303RE“. Atidarymas parodo du failus, vieną HTML ir vieną tekstą.

Tai viskas, bet bent jau sakoma, kad ryšys atrodo gana lengvas.

Dabar mes pasiruošę pradėti.

Bandysiu ne pakartoti jokios geros informacijos iš IVONOMICON Bare Metal straipsnių serijos, o ją papildyti.

2 žingsnis: esminiai dalykai

Pirmas dalykas, kurio mums reikia, yra kompiliatorius.

Ir tada mums reikia derinimo priemonės:

devchu@chubox: ~ $ sudo apt-get install gdb-arm-none-eabiPakuočių sąrašų skaitymas … Atlikta Priklausomybės medžio kūrimas Būsenos informacijos skaitymas … Atlikta Bus įdiegti šie nauji paketai: gdb-arm-none-eabi 0 atnaujinta, 1 nauja įdiegta, 0 pašalinta ir 8 neatnaujinta. Reikia gauti 2, 722 kB archyvų. Po šios operacijos bus naudojama 7 738 kB papildomos vietos diske. Gauti: 1 https://us.archive.ubuntu.com/ubuntu xenial/universal amd64 gdb-arm-none-eabi amd64 7.10-1ubuntu3+9 [2, 722 kB] Gauta 2, 722 kB per 1 s (1, 988 kB/s) Pasirinkus anksčiau nepasirinktą paketą gdb-arm-none-eabi. (Skaitoma duomenų bazė … Šiuo metu įdiegti 262428 failai ir katalogai.) Ruošiamasi išpakuoti…/gdb-arm-none-eabi_7.10-1ubuntu3+9_amd64.deb… Išpakavimas gdb-arm-none-eabi (7.10-1ubuntu3+9)… Apdorojama paleidikliai „man-db“(2.7.5-1)… „gdb-arm-none-eabi“nustatymas (7.10-1ubuntu3+9)…

3 žingsnis: pagrindai - „Windows“

Aukščiau pateiktas žingsnis manė, kad naudojame „Linux“. Ką daryti, jei naudojame „Windows“?

Galite apsilankyti kūrėjo svetainėje ir yra keletas atsisiuntimo parinkčių. Aš naudoju „Windows 8“mašiną.

Diegimo metu nusprendžiau jį įdiegti į šakninį „C:“diską, o ne „Program Files“tik todėl, kad taip pat naudoju „cygwin“, ir buvo lengviau sukurti nuorodą iš vietinės dėžės į šakninį C: aplanką nei visus netvarka kelyje į programos failus (su tarpais ir pan.).

Taigi mano Cygwin aplinka ir kelias ir tt atrodo taip:

C: / cygwin64 / home / bin / arm-none-eabi-gcc, kur arm-none-eabi-gcc yra nuoroda į C: / GNUToolsArmEmbedded / 7.2018.q2.update / bin / arm-none-eabi- gcc.

Tada sukūriau „dev“aplanką po „cygwin home“ir ten įdėjau core. S failą ir paleidau kompiliatoriaus komandą. (toliau rasite kompiliatoriaus medžiagą).

Aš padariau tą patį su gdb (arm-none-eabi-gdb).

4 žingsnis: kas yra svarbiausia

Taigi, kas yra „gcc-arm-none-eabi“?

„Gnu“kompiliatorius (GCC) sukurs programavimo kalbas (pvz., C) į mašinos, kurioje ji veikia, gimtąjį kodą. Pvz., Jei „Windows“kompiuteryje sudarytumėte tam tikrą C kodą naudodami GCC, jis būtų sukurtas taip, kad veiktų „Windows“kompiuteryje. Sukurtas vykdomasis failas (paprastai) neveiks naudojant ARM mikrovaldiklį.

Taigi, norėdami sukurti programas, kurias būtų galima atsisiųsti ir įrašyti į ARM mikrovaldiklį (šiuo atveju tai būtų STM32 „Nucelo“), turime suteikti GCC dar ką nors: galimybę „sukompiliuoti“. Tai yra, galimybė generuoti vykdomąjį failą ne savo vietinei sistemai (ir procesoriui), o tikslinei sistemai (ARM mikrovaldiklis). Štai čia ir atsiranda „gcc-arm-none-eabi“.

Taigi, kas yra „gdb-arm-none-eabi“?

Kai atsisiųsime ir įrašysime (perkelsime) naujai sukurtą vykdomąjį failą į mikrovaldiklį, tikriausiai norėsime jį derinti-žingsnis po žingsnio po kodo. GDB yra „gnu“derinimo priemonė, ir jai taip pat reikia būdo atlikti savo darbą, tačiau jis turi būti nukreiptas į kitą sistemą.

Taigi gdb-arm-none-eabi yra GDB, o gcc-arm-none-eabi yra GCC.

Kitas siūlomas diegimo paketas buvo „libnewlib-arm-none-eabi“. Kas tai yra?

„Newlib“yra C biblioteka ir matematikos biblioteka, skirta naudoti įterptosiose sistemose. Tai kelių bibliotekos dalių konglomeratas, turintis nemokamų programinės įrangos licencijų, leidžiančių jas lengvai naudoti įterptiesiems produktams.

Ir galiausiai, paketas „libstdc ++-arm-none-eabi“. Tai gana akivaizdu; tai kryžminio kompiliatoriaus C ++ biblioteka; įterptiesiems ARM mikrovaldikliams.

5 veiksmas: „Linker“failas

Sukurkime nuorodos scenarijų.

Viena iš pagrindinių šio failo dalių ar blokų būtų komanda ATMINTI.

--- iš sourceware.org:

Numatytoji nuorodos konfigūracija leidžia paskirstyti visą turimą atmintį. Tai galite nepaisyti naudodami komandą MEMORY. Komanda MEMORY apibūdina atminties blokų vietą ir dydį taikinyje. Jį galite naudoti norėdami apibūdinti, kuriuos atminties regionus gali naudoti susiejimo priemonė ir kurių atminties regionų ji turi vengti. Tada galite priskirti sekcijas tam tikriems atminties regionams. Nuorodos nustatys skyrių adresus pagal atminties regionus ir įspės apie regionus, kurie tampa perpildyti. Sąsaja nemaišys sekcijų, kad tilptų į turimus regionus. Nuorodos scenarijuje gali būti daug komandų ATMINTIS, tačiau visi apibrėžti atminties blokai laikomi taip, lyg jie būtų nurodyti vienoje komandoje ATMINTIS.:

ATMINTIS

{vardas [(attr)]: KILMĖ = kilmė, LENGTH = len…}

Pavyzdys straipsnyje:

/* Apibrėžkite RAM pabaigą ir kamino atminties ribą* //* (4KB SRAM eilutėje STM32F031x6, 4096 = 0x1000)*//* (RAM prasideda adresu 0x20000000) _estack = 0x20001000;

ATMINTIS

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

Taigi turime išsiaiškinti, kiek FLASH (mūsų programai ir konstantoms ir tt) ir kiek RAM (skirta programai naudoti; krūva ir krūva ir tt) mūsų konkrečiai plokštei. Tai tampa šiek tiek įdomu.

Gražioje mažoje kortelėje, kuri pateikiama kartu su „Nucleo“, sakoma, kad joje yra 512 KB, o SRAM - 80 Kb. Tačiau prijungus jį prie USB, jis bus sumontuotas kaip failų sistema su dviem failais, o failų tvarkyklė ir „GParted“nurodo, kad turi daugiau nei 540 KB. (RAM?).

BET, bandant ištrinti du failus naudojant failų tvarkyklę, atjungus ir vėl prijungus įrenginį, abu failai vis tiek rodomi. (ir failų tvarkyklė kažką atpažino, nes kiekviename faile yra maža „užrakto“piktograma.

Taigi eikime su skaičiais kortelėje. Taigi dabar imkime aukščiau pateiktą pavyzdį ir paverskime jį konkrečia lenta.

Galbūt norėsite naudoti kažką panašaus į šį internetinį atminties keitiklį, kad pereitumėte nuo bendro KB iki tam tikro baitų skaičiaus.

Tada galbūt norėsite naudoti internetinį dešimtainio į šešioliktainį keitiklį.

/ * Nustatykite RAM pabaigą ir kamino atminties ribą */

/* (4KB SRAM eilutėje STM32F031x6, 4096 = 0x1000)* //* pavyzdys*/

/ * 1 žingsnis: (80 KB SRAM ant STM32F303RE, 81920 = 0x14000) * // * mūsų lenta */

/* 2 veiksmas, pridėkite šešiakampį dydį prie šešiakampio pradžios adreso (žemiau). */

/ * (RAM prasideda adresu 0x20000000) */

_stack = 0x20001000; / * pavyzdys */

_stack = 0x20014000; / * mūsų lenta */

ATMINTIS {

Blykstė (rx): KILMĖ = 0x08000000, ILGIS = 512K

RAM (rxw): KILMĖ = 0x20000000, ILGIS = 80K

}

Pavadinkime aukščiau esantį failą „linker.script.ld“.

6 žingsnis: vektorinė lentelė

Dabar mes sukursime nedidelį surinkimo failą (su direktyvomis), kad atliktume labai paprastą pertraukimo tvarkymą. Sekime straipsnio pavyzdžiu ir sukursime failą pavadinimu „core. S“.

Vėlgi, čia yra failo turinio pavyzdys, bet aš pakeičiau konkrečią mūsų lentą:

// Šios instrukcijos apibrėžia mūsų lusto ir

// surinkimo kalba, kurią naudosime:.syntax unified /*Žr. žemiau po šios kodo srities* //*.cpu cortex-m0* / /*komentuokite šią pavyzdžio eilutę* /.cpu cortex-m4 /* vietoj to pridėkite mūsų lentos žievę. žiūrėkite aukščiau esantį paveikslėlį šiame žingsnyje * / /*.fpu softvfp * / / *pakomentuokite šią pavyzdžio eilutę * /.fpu vfpv4 / *vietoj to pridėkite mūsų lentą; jis turi FPU */.thumb // Pasaulinės atminties vietos..global vtable.global reset_handler / * * Tikroji vektorinė lentelė. * Įtrauktas tik RAM dydis ir „reset“tvarkyklė *, kad būtų paprasčiau. */.type vtable, %object vtable:.word _estack.word reset_handler.size vtable,.-vtable

Hmm.. Ne „.align“direktyva

Tačiau tai nėra kritiška. Daugiau apie tai (galbūt) vėliau.

.sintaksė vieninga

.sintaksė [vieninga | padalintas]

Ši direktyva nustato instrukcijų rinkinio sintaksę, kaip aprašyta ARM instrukcijų rinkinio skyriuje

9.4.2.1 Instrukcijų rinkinio sintaksė Dvi šiek tiek skirtingos sintaksės palaiko ARM ir THUMB instrukcijas. Numatytasis, padalintas, naudoja seną stilių, kuriame ARM ir THUMB instrukcijos turėjo savo atskirą sintaksę. Nauja, vieninga sintaksė, kurią galima pasirinkti naudojant.syntax direktyvą.

.fpu vfpv4

GCC kompiliatorius gali sukurti dvejetainius failus su keliomis slankiojo kablelio parinktimis: minkštas - tinka paleisti procesoriuose be FPU - skaičiavimus atlieka programinė įranga kompiliatoriaus sukurta programinė įranga - tinka paleisti CPU su FPU arba be jo - naudos FPU, jei bus. Mūsų konkrečiu atveju (turėsite atlikti savo tyrimą), šios plokštės FPU atitinka vfpv4. Jums gali tekti žaisti su tuo. Arba palikite jį „softfp“.

. nykštis (prieš ginklą)

Šie ARM mikrovaldikliai iš tikrųjų turi instrukcijų rinkinių derinį. Vienas yra ginklas, kitas - nykštys. Vienas skirtumas yra 16 bitų ir 32 bitų instrukcijos. Taigi šioje direktyvoje kompiliatorius nurodomas vėlesnius nurodymus traktuoti kaip THUMB arba ARM.

Mes tiesiog priimsime likusią failo dalį, kokia yra, nes šios „Instructables“dar nesigilino į pertraukimo valdomą surinkimo programavimą.

7 žingsnis: programos „Labas pasaulis“surinkimo versija

Tai taip pat gali patekti į anksčiau sukurtą „core. S“failą. Tai vėlgi iš straipsnio pavyzdžio.

/ * * Atstatymo tvarkyklė. Skambino iš naujo. */.type reset_handler, %function reset_handler: // Nustatykite kamino žymeklį į kamino pabaigą. // Vertė „_estack“apibrėžta mūsų susiejimo scenarijuje. LDR r0, = _krauti MOV sp, r0

// Nustatykite tam tikras netikras vertes. Kai matome šias vertybes

// mūsų derintuve mes žinosime, kad mūsų programa // yra įkelta į lustą ir veikia. LDR r7, = 0x DEADBEEF MOVS r0, #0 main_loop: // Pridėkite 1, kad užregistruotumėte „r0“. ADDS r0, r0, #1 // Atgal. B main_loop.size reset_handler,.-Reset_handler

Taigi aukščiau pateiktos programos tikslas yra įkelti atpažįstamą modelį į vieną pagrindinį MCU registrą (šiuo atveju R7), o didėjančią vertę, pradedant nuo nulio, į kitą pagrindinį MCU registrą (šiuo atveju R0). Jei pereisime prie vykdymo kodo, turėtume matyti R0 duomenų padidėjimą.

Jei sekėte kartu su instrukcijomis dėl MSP432 ir TI-RSLK kurso/laboratorijų, tada beveik visa aukščiau pateikta programa jums turėtų būti žinoma.

Vienas naujas dalykas, kurį matau, yra „=“naudojimas įkeliant „DEADBEEF“į registruojant R7. Mes to nenaudojome.

Čia pridėtame „core. S“faile yra visas šaltinis.

8 žingsnis: kodo sudarymas

Atėjo laikas atlikti kai kuriuos komandinės eilutės dalykus. Pagaliau kažkas tikro.

Tačiau mes ne visai ten. Mes vėl turime pataisyti straipsnyje pateiktą komandą ir pakeisti ją pagal savo situaciją.

Štai kodo pavyzdys:

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

Jei eisime į GCC svetainę gnu.org (šiuo atveju 7.3 versija),

x

-X reiškia kalbą. Priešingu atveju, jei nėra -x, kompiliatorius bandys atspėti naudodamas failo plėtinį. (mūsų atveju *. S).

Aukščiau pateiktame straipsnio pavyzdyje nurodomas surinkėjas-su-cpp, tačiau galėtume tiesiog surinkti.

c

-C sako: „kompiliuokite, bet nesiekite.

O0

-O yra optimizavimo lygio nustatymas. Naudojant -0 (oh -nulis) sakoma: „sutrumpinkite kompiliavimo laiką ir atlikite derinimą, kad gautumėte laukiamus rezultatus. Tai numatytoji nuostata“.

mcpu = žievė-m0

-Mcpu nurodo tikslinio procesoriaus pavadinimą. Mūsų atveju tai būtų žievė-m4.

nykštys

-Mthumb nurodo, ar pasirinkti kodą, kuris vykdo ARM ir THUMB būsenas.

Siena

Siena, žinoma, yra labai paplitusi ir gerai žinoma. Jis įjungia visas įspėjamąsias vėliavas.

Galiausiai, komandos pabaigoje turime įvesties failą core. S ir išvesties failą core.o.

Čia yra nauja komandinė eilutė, atitinkanti mūsų konkretų atvejį.

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

Ir tai sudaryta.

9 veiksmas: susiekite programą

Tiesiogiai iš straipsnio pavyzdžio mes turime tai:

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

Dauguma iš aukščiau išvardytų dalykų, kuriuos matėte. Žemiau yra kas naujo.

specs = nosys.specs

Tai šiek tiek sudėtinga paaiškinti.

Tai susiję su „semihosting“ir „retargeting“, taip pat su įvestimi / išvestimi. Tai taip pat susiję su sistemos skambučiais ir bibliotekomis.

Paprastai įterptosios sistemos neteikia standartinių įvesties/išvesties įrenginių. Tai paveiks sistemos ar bibliotekos skambučius (pavyzdys: printf ()).

Pusiau talpinimas reiškia, kad derintuvas (žr. 11 veiksmo vaizdą su derinimo dalimi, apjuosta raudona spalva) turi specialų kanalą ir naudoja pusiau talpinimo protokolą, o pagrindinėje mašinoje galite pamatyti printf () išvestį (per derintuvą).

Kita vertus, pakartotinis taikymas reiškia, kad tie patys sistemos ar bibliotekos skambučiai reiškia ką kita. Jie daro ką nors kita, tai yra prasminga įterptajai sistemai. Tam tikra prasme, tarkime, printf (), yra naujas įgyvendinimas, pakartotinis šios funkcijos įgyvendinimas.

Visa tai pasakius, --specs = nosys.specs reiškia, kad mes nebepasieksime. Paprastai tai reikštų, kad mes taikomės iš naujo. Tai atveda mus prie kitos vėliavos.

nostdlib

Nuorodos parinktis -nostdlib naudojama norint susieti programą, skirtą paleisti savarankiškai. -nostdlib reiškia atskiras parinktis -nodefaultlibs ir -nostartfiles. Žemiau mes aptariame abi parinktis atskirai, tačiau dažniausiai naudojamas tik „vieno langelio“apsipirkimas. Susiejant priglobtą programą, standartinės sistemos bibliotekos, pvz., „Libc“yra susietos pagal numatytuosius nustatymus, suteikdamos programai prieigą prie visų standartinių funkcijų (printf, strlenas ir draugai). Nuorodos parinktis -nodefaultlibs išjungia susiejimą su tomis numatytosiomis bibliotekomis; vienintelės susietos bibliotekos yra būtent tos, kurias jūs aiškiai įvardijate susiejimo priemonę naudodami -l vėliavą.

lgcc

„libgcc.a“yra standartinė biblioteka, teikianti vidines paprogrames tam tikrų mašinų trūkumams pašalinti. Pavyzdžiui, ARM procesorius neapima padalijimo instrukcijos. „Libgcc.a“ARM versijoje yra padalijimo funkcija, o kompiliatorius prireikus skleidžia skambučius į šią funkciją.

T

Tai tik būdas liepiančiajam nurodyti šį failą naudoti kaip nuorodos scenarijų. Mūsų atveju failo pavadinimas yra linker.script.ld.

o pagrindinis.savas

Galiausiai mes nurodome susiejimui, koks bus galutinio išvesties vaizdo failo, kuris bus įrašytas/įvestas į mūsų įrenginį, pavadinimas.

Čia yra mūsų visos komandinės eilutės versija, pakeista pagal mūsų konkrečią situaciją:

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

Įsitikiname, kad scenarijaus failas ir „core.o“failas yra tame pačiame kataloge, kuriame paleisime aukščiau pateiktą komandų eilutę.

Ir susieja be problemų.

Čekis

Tada bėgame:

arm-none-eabi-nm main.elf

ir gauname:

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

Atrodo gerai. Komanda „arm-none-eabi-nm“yra būdas išvardyti simbolius objektų failuose.

10 veiksmas: bandymas Prisijungimas prie STM32 Nucleo-64

Pirmoji jūsų misija, jei nuspręsite ją priimti, yra tai, kad jūsų sistema matytų jūsų kūrimo lentą.

Naudojant „Windows“

„Windows“atveju nusprendžiau įdiegti „TrueSTUDIO“iš „Atollic“(nemokama versija). Tai buvo neskausmingas diegimas ir automatiškai įdiegė tvarkyklę, kad galėčiau naudoti „st-link“ryšiui išbandyti. Įdiegęs „TrueSTUDIO“ir įrenginių tvarkytuvė pamatė įrenginį, aš atsisiunčiau „texan/stlink“įrankius, kuriuos pasiūlė mūsų plikas metalo straipsnis. Aš vėl įdėjau aplanką tiesiai į „C: \“ir vėl sukūriau keletą nuorodų iš vietinės „Cygwin“namų dėžės į komandas.

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

Kaip pradinį testą, norėdamas išsiaiškinti, ar tikrai galime bendrauti su įrenginiu, atlikau:

st-info-zondas

Ir grįžo:

Rasta 1 stlink programuotojas

Taigi dabar mes žinome, kad galime pasikalbėti/paklausti savo plėtros lentos.

Naudojant „Linux“

„Linux“tvarkyklės jums tikrai nereikia. Bet „Debian“turėsite sukurti „st“įrankius iš šaltinio.

git klonas

Įsitikinkite, kad įdiegėte „libusb-1.0-0-dev“.

tinkamas sąrašas | grep -E "*libusb.*dev*"

Turėtumėte pamatyti:

libusb-1.0-0-dev/xenial, dabar 2: 1.0.20-1 amd64 [įdiegta]

arba kažkas panašaus.

Norėdami jį įdiegti:

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

Atminkite, kad tai, kas išdėstyta aukščiau, nėra tas pats, kas:

sudo apt-get install libusb-dev

Teisingai trūkstamas „libusb“kūrėjas gali sukelti „cmake“problemų.

„CMake“klaida: šiame projekte naudojami šie kintamieji, tačiau jie nustatyti kaip NOTFOUND. Prašome juos nustatyti arba įsitikinti, kad jie teisingai nustatyti ir išbandyti „CMake“failuose: LIBUSB_INCLUDE_DIR (ADVANCED)

Pakeiskite į pagrindinį projekto katalogą (… blah /blah /stlink). Atlikite „išleidimą“.

Po to sukūrimo įrankiai turėtų būti „.. /build /Release“.

Tada galite paleisti „st-info --probe“. Štai išėjimas su prijungtu „Nucleo“, tada ne.

devchu@chubox: ~/Development/stlink $./build/Release/st-info --probeRasta 1 stlink programuotojų serija: 303636414646353034393535363537 openocd: "\ x30 / x36 / x36 / x41 / x46 / x46 / x35 / x30 / x34 / x39 / x35 / x35 / x36 / x35 / x37 "blykstė: 524288 (puslapio dydis: 2048) sram: 65536 chipid: 0x0446 descr: F303 didelio tankio įrenginys devchu@chubox: ~/Development/stlink $./build/Release/st- info --probe Rasta 0 stlink programuotojų devchu@chubox: ~/Development/stlink $

11 veiksmas: naudokime GDB su „Linux“

Jei visa tai bandėte ir pasiekėte taip toli - puiku! Puikiai. Dabar šiek tiek pasilinksminkime.

Perkant šias ARM kūrimo plokštes, nesvarbu, ar tai būtų „MSP432 Launchpad“iš „Texas Instruments“, ar tai, apie kurią dabar diskutuojame, „Nucleo-F303“(„STM32 Nucleo-64“), jos paprastai atkeliauja jau su veikiančia programa, paprastai kai kuri mirksinti programa, kuri taip pat apima jungiklio paspaudimą, kad pakeistumėte šviesos diodų (-ų) mirksėjimo greitį.

Kol dar neskubame perrašyti, pažiūrėkime, ką galima pamatyti ir nuveikti.

Naudodami „Linux“, atidarykite terminalą, pakeiskite ką tik sukurto „stlink git“projekto katalogą ir suraskite „st-util“įrankį.

devchu@chubox: ~/Development/stlink $ find. -pavadinimas st-util

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

Paleiskite tą įrankį. Kadangi jau anksčiau išbandėme ryšį su „st-info --probe“, turėtume gauti tokią išvestį:

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

st-util 1.4.0-50-g7fafee2 2018-10-20T18: 33: 23 INFO common.c: Įkeliami įrenginio parametrai…. 2018-10-20T18: 33: 23 INFO bendroji. C: prijungtas įrenginys yra: F303 didelio tankio įrenginys, ID 0x10036446 2018-10-20T18: 33: 23 INFO bendroji. C: SRAM dydis: 0x10000 baitų (64 KiB), „Flash“: 0x80000 baitų (512 KiB) 2048 baitų puslapiuose 2018-10-20T18: 33: 23 INFO gdb-server.c: lusto ID yra 00000446, pagrindinis ID yra 2ba01477. 2018-10-20T18: 33: 23 INFO gdb-server.c: Klausoma *: 4242…

Tai dabar veikia GDB serveris, kuriame matoma mūsų kūrimo lenta, o dar svarbiau, kad jis klausosi 4242 prievado (numatytasis prievadas).

Dabar esame pasirengę įjungti GDB klientą.

„Linux“atidarykite kitą terminalą, įveskite tai:

arm-none-eabi-gdb -tui

Tai tas pats, kas paleisti „gdb“griežtai komandinę eilutę, tačiau vietoj to sukuriamas tekstinis terminalas (spėju, kad jis naudoja prakeikimus).

Turime GDB klientą ir GDB serverį. Tačiau klientas nėra prijungtas prie serverio. Šiuo metu ji nieko nežino apie mūsų „Nucleo“(arba jūsų pasirinktą plokštę). Mes turime tai pasakyti. Terminale jūsų raginimas dabar turėtų būti „(gdb)“. Įveskite:

padėti taikiniui

Tai suteiks jums sąrašą. Atkreipkite dėmesį, kad mes norime išplėstinio nuotolinio valdymo pulto - naudokite nuotolinį kompiuterį per nuosekliąją liniją.

Bet mes taip pat turime nurodyti vietą. Taigi, (gdb) eilutėje įveskite:

(gdb) tikslinis išplėstinis nuotolinis vietinis kompiuteris: 4242

Turėtumėte gauti tokį atsakymą:

(gdb) tikslinis išplėstinis nuotolinis vietinis kompiuteris: 4242

Nuotolinis derinimas naudojant „localhost“: 4242 0x080028e4 in ?? ()

Tuo tarpu terminale, kuriame veikia st-util gdbserver, gavome tai:

2018-10-20T18: 42: 30 INFO gdb-server.c: Rasta 6 hw lūžio taškų registrai

2018-10-20T18: 42: 30 INFO „gdb-server“. C: prijungtas GDB.

12 žingsnis: Pakartokime, naudodami „Windows“ir „Flash“mūsų programą

„St-util gdbserver“ir „arm-none-eabi-gdb“kliento paleidimo veiksmai iš esmės yra tokie patys, kaip ir ankstesnio veiksmo metu. Atidarote du terminalus („cygwin“, „DOS cmd“arba „Windows Powershell“), surandate „st-util“vietą, paleiskite ją. Kitame terminale paleiskite „arm-none-eabi-gdb“klientą. Skirtumas tik tas, kad režimas -tui (teksto peržiūra terminalu) greičiausiai nepalaikomas.

Jei tai, kas išdėstyta aukščiau, veikė sistemoje „Windows“, tikriausiai turėsite sustoti (tik klientas). Šiuo metu jums kažkaip reikės paleisti GDB klientą, kuriame yra jūsų kūrimo failas („core.out“), arba pridėti visą to failo kelią kaip argumentą GDB klientui.

Aš supaprastinau savo gyvenimą naudodamas „cygwin“ir sukūręs nuorodas iš vietinio $ HOME // bin katalogo į abi šias priemones.

Gerai, mes sudarėme ir susiejome taip pat, kaip ir anksčiau, ir mes turime failą main.elf, paruoštą parodyti.

Viename lange veikia st-util. Šį kartą iš naujo paleidžiame GDB klientą:

arm-none-eabi-gdb main.elf

Mes leidžiame jam paleisti, laukiame (gdb) raginimo, vykdome tą pačią prisijungimo komandą prie GDB serverio (st-util) ir esame pasirengę paleisti vykdomąjį failą. Tai labai prieš klimatą:

(gdb) apkrova

Veikiant su „cygwin“terminalais, yra žinoma problema, dėl kurios kartais konsolės komandos neišvedamos. Taigi mūsų atveju langas, kuriame veikia serveris, buvo visiškai tylus. Tas, kuris vykdo klientą, kuriame vykdėme apkrovą, išvesta taip:

Įkeliama sekcija.tekstas, dydis 0x1c lma 0x8000000Pradžios adresas 0x8000000, įkėlimo dydis 28 Perkėlimo sparta: 1 KB/sek., 28 baitai/rašyti.

13 žingsnis: mirksėjimas naudojant „Linux“- daugiau atlygio: D

14 žingsnis: Nardykime šiek tiek giliau

Jei patekote čia, puiku. Eikime toliau.

Kodėl gi nežiūrint į failą main.elf, vykdomąjį failą? Vykdykite šiuos veiksmus:

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

Turėtumėte pamatyti išvestį maždaug taip:

main.elf: failo formatas elf32-littlearm

Skilties.tekstas išardymas:

08000000:

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

08000008:

8000008: 4802 ldr r0, [pc, #8]; (8000014) 800000a: 4685 mov sp, r0 800000c: 4f02 ldr r7, [pc, #8]; (8000018) 800000e: 2000 judesių r0, #0

08000010:

8000010: 3001 prideda r0, #1 8000012: e7fd b.n 8000010 8000014: 20014000.word 0x20014000 8000018: deadbeef.word 0xdeadbeef

Kokių mažų grynuolių galime gauti iš aukščiau pateikto rezultato?

Jei prisimenate, kai diskutavome ir kūrėme failą linker.script.ld, nurodėme, kad šių ARM įrenginių RAM yra nuo 0x20000000, o FLASH atmintis prasideda nuo 0x08000000.

Taigi matome, kad programa iš tikrųjų yra tokia, kad visa tai yra FLASH atmintyje.

Tada, aukščiau, bet vėliau, kai diskutavome apie „Labas pasaulis“dalį, buvo pareiškimas, kuriame įkeliame tiesioginę, pastovią tiesioginę reikšmę („0xDEADBEEF“) į MCU pagrindinį registrą („R7“).

Pareiškimas buvo toks:

LDR R7, = 0x DEADBEEF

Mūsų kodekse tai yra vienintelė vieta, kur mes net paminėjome DEADBEEF. Niekur kitur. Ir vis dėlto, jei pažvelgsite į aukščiau pateiktas išardytas/rekonstruotas instrukcijas ir tt, ten yra daugiau apie DEADBEEF, nei manėme.

Taigi, kompiliatorius/susiejamasis kažkaip nusprendė visam laikui „DEADBEEF“reikšmę įvesti į FLASH adresą, esantį 0x8000018 vietoje. Tada kompiliatorius pakeitė aukščiau pateiktą LDR instrukciją į:

LDR R7, [PC, #8]

Tai netgi sukėlė mums komentarą. Kaip miela. Ir liepia mums paimti dabartinę programos skaitiklio vertę (kompiuterio registrą), pridėti prie tos vertės 0x8, ir ten DEADBEEF buvo sudeginta, ir gaukite šią vertę ir įdėkite ją į R7.

Tai taip pat reiškia, kad programų skaitiklis (PC) nurodė adresą 0x8000010, kuris yra „main_loop“pradžia, ir kad DEADBEEF vertė yra dviem adresais pasibaigus main_loop.

15 žingsnis: Galiausiai trumpai pažvelkite į programos vykdymą

Net jei išeisite iš GDB, tiesiog iš naujo įveskite komandą. Jums net nereikia jam duoti jokio failo; mes nebemirksime, tik paleisime.

Iš naujo prijungę GDB klientą prie GDB serverio, komandų eilutėje (gdb):

(gdb) informacijos registrai

Turėtumėte pamatyti kažką panašaus:

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 42x498000095

Bet tada (gdb) eilutėje įveskite:

(gdb) tęsti

Ir labai greitai paspauskite CTRL-C. Tai turėtų pristabdyti programą. Dar kartą įveskite komandą „informacijos registrai“.

Šį kartą viskas atrodo kitaip:

(gdb) informacijos registrai

r0 0x350ffa 3477498 r1 0x0 0 r2 0x0 0 r3 0x0 0 r4 0x0 0 r5 0x0 0 r6 0x0 0 r7 0xdeadbeef 3735928559 r8 0x0 0 r9 0x0 0 r10 0x0 0 r11 0x0 0 r12 0x0 0x0x00x000000000000000000 16777216

Kas nutiko? Būtent tai, ko norėjome. DEADBEEF buvo įkelta į R7, o R0 (labai greitai) didėjo. Jei kartosite, vėl matysite R0 su kita reikšme.

16 veiksmas: norėjome „Flash“sukurti tik skaitomą masyvą

Vienas iš būdų sukurti masyvo atitikmenį naudojant surinkimą ir direktyvas yra toks:

.type myarray, %object // pavadinimas arba etiketė „myarray“yra apibrėžta kaip objekto tipas.

myarray: // tai yra „myarray“deklaracijos pradžia // (iš ko ji susidės)..word 0x11111111 // pirmasis narys arba reikšmė, esanti „myarray“..word 0x22222222 // antroji reikšmė (gretimi adresai)..word 0x33333333 // ir pan..size myarray,.-myarray // kompiliatorius/surinkėjas dabar žino, kur yra „myarray“pabaiga arba // riba.

Dabar, kai jį nustatėme FLASH atmintyje, galime jį naudoti programoje. Žemiau yra dalis:

LDR R1, myarray // tai įkelia duomenis, esančius pirmoje „myarray“vietoje. “// tai ne tai, ko mes norime.

LDR R1, = myarray // tai įkelia pačią vietos vertę (1 -asis adresas), // ne duomenys.. // šito mes norime.

MOV R2, #0 // R2 skaičiuos, kad įsitikintume, jog neišeiname

// masyvo pabaiga. LDR R3, = myarrsize // R3 bus „myarrsize“atitikmuo.

// R0 laikys mūsų duomenis

main_loop:

LDR R0, [R1] // Įkelkite R1 nurodytus duomenis („myarray“) į R0. CMP R2, R3 // Ar esame masyvo ribose? BEQ main_loop // Jei mes tai padarysime, mes baigsime, todėl tiesiog amžinai tęsime ciklą.

ADD R2, #1 // Priešingu atveju mes galime nuolat kartoti masyvą.

ADD R1, #4 // Pridėkite 4, kad užregistruotumėte R1, kad jis teisingai nurodytų kitą

// adresas..

B main_loop // Atgal.

Vaizdo įrašas visa tai apeina, ir jame yra klaida. Tai gerai; tai rodo, kad svarbu paleisti ir derinti kodą. Tai rodo klasikinį atvejį, kai nueinama iš masyvo galo.