Darmowe narzędzia programowe dla mikrokontrolerów STM32.pdf

Darmowe narzędzia programowe dla mikrokontrolerów STM32

NARZĘDZIA KONSTRUKTORA

Darmowe narzędzia

mikrokontrolerów STM32

Mikrokontrolery z rdzeniem ARM7 jeszcze na dobre nie zdążyły

się zadomowić na naszym rynku, a już powoli zastępowane

są przez mikrokontrolery z rdzeniem CORTEX-M3. Sukces ten

zawdzięczamy głównie niskiej cenie, dużej wydajności, oraz

optymalizacji pod względem oszczędności energii. Ze względu na

bardzo dobry stosunek możliwości do ceny szczególnie dobrze zostały

przyjęte mikrokontrolery STM32. Sukces rynkowy danego układu

determinowany jest nie tylko przez jego możliwości, ale również

przez dostępność odpowiednich narzędzi programowych i sprzętowych.

w systemie. Z uwagi na ten dodatkowy atut,

w poniższym artykule skupimy się na wyko-

rzystaniu JTAGa. Do jego obsługi zastosujemy

program openocd ( http://openocd.berlios.de/

web/ ), który umożliwia użycie wielu prostych

i tanich interfejsów sprzętowych.

Najtańszym rozwiązaniem sprzętowym

umożliwiającym obsługę mikrokontrolerów

STM32 z wykorzystaniem programu Ope-

nOCD jest zastosowanie popularnego inter-

fejsu Magicor-Wiggler np. ZL14PRG irmy

Kamami. Interfejs ten zawiera bufor dołącza-

ny do portu drukarkowego, a jego zaletą jest

prostota. Najistotniejszą wadą układu jest

niewielka prędkość działania oraz koniecz-

ność posiadania portu równoległego LPT,

którego większość współczesnych kompu-

terów jest pozbawiona. Zdecydowanie lep-

szym rozwiązaniem jest wykorzystanie na-

rzędzia oocdlink dołączanego do portu USB,

którego przykładem jest układ BF-30 ( http://

www.boff.pl ). Zapewnia on większą prędkość

pracy przy programowaniu oraz debugo-

waniu mikrokontrolerów z rdzeniem ARM

oraz dodatkowo umożliwia programowanie

8-bitowych mikrokontrolerów AVR w trybie

kompatybilności z programatorem USBASP .

Dziś w zasadzie koniecznym warunkiem

jest dostępność kompilatora C, a jeszcze le-

piej C++ , interfejsu JTAG umożliwiającego

wygodne programowanie układu w systemie,

debugowanie oraz odpowiedniego edytora IDE

( Integrated Development Environment ) umożli-

wiającego wygodne pisanie oprogramowania.

Gotowe zintegrowane środowiska programi-

styczne są produkowane przez wiele irm cho-

ciażby KEIL , Rowley , czy Raisonance . Środo-

wiska te są bardzo wygodne w użyciu i umoż-

liwiają utworzenie projektu dla wybranego

mikrokontrolera w zasadzie za pomocą kilku

ruchów myszką, niemniej jednak pełne wersje

komercyjne są poza zasięgiem małych irm,

nie wspominając o miłośnikach mikrokontro-

lerów. Istnieją co prawda wersje demonstra-

cyjne wspomnianych wyżej narzędzi, ale na

darmowe wersje są praktycznie prawie zawsze

nałożone ograniczenia umożliwiające ich peł-

ne wykorzystanie. Dawniej, wspomniane śro-

dowiska IDE najczęściej zawierały komercyjne

kompilatory języka C, które niestety często były

niezgodne ze standardem ISO-C. Na szczęście

współczesne środowiska IDE nie wykorzystują

komercyjnych odmian kompilatorów, a jedynie

integrują doskonały, darmowy kompilator GNU

-GCC ( Gnu Compiler Collection ), który umoż-

liwia obsługę wielu języków programowania

np. C, C++, Ada, Fortran, Java. W przypadku

mikrokontrolerów interesować nas będą głów-

nie języki C i C++. Jedynym znanym autorowi

środowiskiem IDE dla ARMów, który zawiera

własny kompilator, to Keil, ale i on umożliwia

używanie GCC.

GCC przewyższył jakościowo wiele ko-

mercyjnych kompilatorów. Zapewnia on pełną

zgodność ze standardem ISO C/C++ i trudno

dziś znaleźć taką architekturę sprzętową ,na

którą by nie był dostępny. Współczesne środo-

wiska IDE zawierają w zasadzie odpowiednio

opakowany kompilator, GCC z odpowiednimi

kreatorami i skryptami.

Istnieje doskonałe darmowe środowisko

IDE , umożliwiające przygotowanie niewiel-

kim nakładem środków dowolnego środowi-

ska programistycznego. W artykule pokażemy

w jaki sposób, bazując na środowisku ECLIP-

SE i innych narzędziach Open Source , można

przygotować kompletne środowisko dla mikro-

kontrolerów STM32 , w niczym nie ustępujące

komercyjnym IDE. Dodatkową jego zaletą jest

to, że możemy je uruchomić nie tylko pod Win-

dows, ale i pod Linuksem.

Do projektowania aplikacji dla ARM bę-

dziemy stosować zintegrowane środowisko

programistyczne ( IDE ) Eclipse . Do ich kompi-

lowania posłużymy się doskonałym kompi-

latorem języka C/C++ gcc , natomiast do pro-

gramowania mikrokontrolerów STM32 oraz

debugowania programów posłuży doskonałe

narzędzie openocd/gdb . Kompilator, progra-

mator oraz debugger dają się zintegrować ze

środowiskiem Eclipse, dzięki czemu dostajemy

kompletne środowisko do tworzenia aplikacji.

Przygotowanie oprogramowania

dla systemu Windows.

Przed rozpoczęciem instalacji programu

Eclipse w Windows musimy upewnić się, że

na komputerze została zainstalowana maszyna

wirtualna Javy ( JRE – Java Runtime Environ-

ment ), która jest niezbędna do działania środo-

wiska. Obecność JRE możemy sprawdzić po-

przez panel sterowania w zakładce Add/Remove

programs . W przypadku braku maszyny wirtu-

alnej Java musimy pobrać najnowszą wersję ze

strony: http://www.java.com/en/download/ , oraz

Narzędzia sprzętowe

Mikrokontrolery rodziny STM32, jak

większość współczesnych mikrokontrolerów,

są programowane w systemie ISP ( In System

Programming ). STM32 zawiera pamięć ROM,

w której zawarty jest bootloader umożliwiają-

cy programowanie pamięci Flash za pomocą

portu szeregowego, bez konieczności stoso-

wania żadnych specjalistycznych narzędzi.

Inną możliwością jest wykorzystanie inter-

fejsu JTAG, który dodatkowo umożliwia rów-

nież debugowanie programu bezpośrednio

Rys. 1.

ELEKTRONIKA PRAKTYCZNA 2/2010

programowe dla

NARZĘDZIA KONSTRUKTORA

dokonać jej instalacji w sposób typowy dla apli-

kacji systemu Windows ( rys. 1 ).

Po upewnieniu się, że mamy zainstalo-

waną Javę, należy pobrać najnowszą wersję

środowiska IDE eclipse dla programistów

C++ ( Eclipse for C/C++ developers , http://

www.eclipse.org/downloads/ ). Program Eclip-

se jest dostarczany w postaci archiwum ZIP,

które należy rozpakować do wybranego fol-

deru np. C:\Program Files ( rys. 2 ).

Po rozpakowaniu, w zależności od prefe-

rencji, należy utworzyć skrót do programu ec-

lipse.exe (znajduje się w podkatalogu eclipse)

na pulpicie lub w menu start. Od tego momen-

tu edytor Eclipse jest gotowy do pracy, może-

my zatem wstępnie przetestować jego działa-

nie klikając w ikonę skrótu. Po uruchomieniu

powinno pojawić się okno ( rys. 3 ), w którym

należy wprowadzić katalog, w którym będą

przechowywane domyślnie wszystkie projek-

ty. Jeżeli chcemy aby pytanie nie było pona-

wiane przy każdym uruchomieniu edytora, to

należy zaznaczyć opcję Use this as the default

and do not ask again , a następnie zatwierdzić

wybierając OK. Za chwilę na ekranie powinno

pokazać się okno główne programu.

Gdy już upewnimy się, że edytor pracu-

je poprawnie, przystępujemy do dalszych

czynności instalacyjnych. Przystępujemy

do instalacji kompilatora GCC dla architek-

tury ARM. Instalator dla systemu Windows

możemy pobrać ze strony Codesoucery

http://www.codesourcery.com/sgpp/lite/arm/

portal/package5356/public/arm-none-eabi/

arm-2009q3-68-arm-none-eabi.exe . Po uru-

chomieniu instalatora, należy odpowie-

dzieć twierdząco na chęć kontynuacji, oraz

zaakceptować warunki umowy licencyjnej.

Następnie zostaniemy zapytani o wybór ro-

dzaju instalacji, gdzie należy wybrać opcję

Typical ( rys. 4 ).

W oknie wyboru miejsca instalacji zosta-

wiamy lokalizację domyślną, a w oknie zapyta-

nia o dodatnie kompilatora do zmiennej PATH ,

wybieramy opcję Modify PATH for ALL users .

Dalszy proces insta-

lacji przebiega tak jak

w przypadku większo-

ści programów dla sys-

temu Windows i nie

wymaga komentarza.

Prezentowane przy-

kłady do prawidło-

wej pracy wymagają

obecności podstawo-

wych komend Linux,

takich jak np. rm, sed,

make. Ich emulację

w Windows zapew-

nia pakietu MINGW .

Kompletny pakiet za-

wierający wymagany

zestaw poleceń oraz

oprogramowanie do

obsługi jtaga BF-30

( OpenOCD ) w postaci

gotowego instalatora,

można pobrać ze stro-

ny domowej autora

http://bryndza.boff.pl/

downloads/msysopenocd-installer.exe . Insta-

lacja oprogramowania przebiega typowo i nie

wymaga komentarza. Po zakończeniu instalacji

mingw+openocd mamy w zasadzie kompletne

środowisko dla mikrokontrolerów STM32. Po-

zostało nam jeszcze instalacja sterowników dla

JTAG-a, BF-30 . Proces rozpoczynamy od instala-

cji sterowników, które można pobrać ze strony:

http://www.ftdichip.com/Drivers/CDM/CDM%20

2.06.00%20WHQL%20Certiied.zip . Po ściągnię-

ciu pliku należy go rozpakować do wybranego

katalogu. Następnie należy przełączyć BF-30

w tryb JTAG ustawiając odpowiedni przełącznik

na płytce, a potem podłączyć go do gniazda USB

komputera. System powinien wykryć urządze-

nie oraz zażądać instalacji driverów. W przypad-

ku Windows 7 system wyświetla, że nie może

znaleźć odpowiedniego drivera i aby zainsta-

lować go poprawnie należy uruchomić Mana-

gera Urządzeń , kliknąć prawym klawiszem na

urządzeniu OcdLink

i wybrać opcję Install

Hardware Driver , a na-

stępnie Browse my

computer for driver

software i jako ścieżkę

podać miejsce, gdzie

poprzednio rozpako-

waliśmy sterowniki.

System powinien od-

naleźć poprawny ste-

rownik i przystąpić do

jego instalacji. Jeżeli

sterowniki są prawi-

dłowo zainstalowane,

powinniśmy mieć

możliwość zobaczenia

kompletnych urządzeń

Usb serial Converter

A i B ( rys. 5 ).

Rys. 5.

Oprogramowanie dla środowiska

Linux

Instalacja w środowisku Linux jest zdecy-

dowanie prostsza niż w Windows z uwagi na to,

że nie musimy instalować środowiska zapew-

niającego podstawowe komendy oraz sterowni-

ków dla JTAGA BF-30. Instalację opiszemy na

przykładzie systemu Kubuntu Linux 9.10 .

Pierwszą czynnością jest instalacja ma-

szyny wirtualnej Javy z repozytorium. W tym

celu należy w managerze pakietów Kpackage-

Kit zaznaczyć do instalacji pakiet openjdk-6-jre

lub za pomocą konsoli tekstowej wydać pole-

cenie sudo apt-get install openjdk-6-jre . Gdy

już mamy zainstalowaną maszynę wirtualną

Java, przystępujemy do pobrania edytora Ec-

lipse for C/C++ Developers spod adresu http://

www.eclipse.org/downloads/ . Proces instalacji

wygląda w zasadzie identycznie, jak dla śro-

dowiska Windows, czyli należy rozpakować

Eclipse do wybranego folderu np. /usr/local lub

/opt , a następnie za pomocą edytora menu

stworzyć skrót w menu start lub na pulpicie.

Kolejną czynnością jest instalacja kompilatora

ARM GCC dla systemu Linux. Wersję dla ar-

chitektury 64-bit można pobrać z mojej strony

domowej http://bryndza.boff.pl/downloads/cor-

tex-toolchain-20080912_amd64.tar.gz . Dla archi-

tektury 32-bitowej można skorzystać z kompi-

latora dostępnego na stronie CodeSoucery http://

www.codesourcery.com/sgpp/lite/arm/portal/pac-

kage5355/public/arm-none-eabi/arm-2009q3-

68-arm-none-eabi.bin . W przypadku wersji

32-bitowej sposób instalacji przebiega w sposób

analogiczny, jak dla systemu Windows. Insta-

lacja w systemie 64-bitowym sprowadza się do

rozpakowania archiwum za pomocą polecenia

sudo tar xvfz cortex-toolchain-20080912_amd64.

tar.gz . Kolejnym krokiem jest sprawdzenie czy

mamy zamontowany system plików USBFS , za-

Rys. 2.

Rys. 3.

ELEKTRONIKA PRAKTYCZNA 2/2010

Rys. 4.

Darmowe narzędzia programowe dla mikrokontrolerów STM32

Rys. 6.

Po kliknięciu kla-

wisza FINISH zostanie

utworzony pusty projekt,

który następnie należy

dostosować do naszego

kompilatora. W tym celu

w oknie Project Explo-

rer klikamy prawym

klawiszem myszy na

katalogu projektu leds ,

a następnie z menu kon-

tekstowego wybieramy

opcję Properties . Pojawi

się wówczas okno dialo-

gowe , w którym w za-

kładce Discovery Options

należy zaznaczyć opcję

Automate Discovery Path

And Symbols , a w oknie

Compiler invocation

command zmienić nazwę kompilatora gcc na

arm-none-eabi-gcc i potwierdzić wprowadzo-

ne ustawienia klawiszem OK. Wprowadzona

zmiana umożliwia automatyczne wykrywanie

i parsowanie plików nagłówkowych dołączo-

nych do projektu za pomocą dyrektywy include

( rys. 7 ).

Teraz w zakładce C/C++ build–>Settings

w oknie Binary Parsers należy zaznaczyć opcję

Elf Parser , co zapewni środowisku możliwość

parsowania plików wynikowych aplikacji. Po

ustawieniu wymaganych opcji możemy przy-

stąpić do importu projektu stm32-examples.tgz .

W tym celu w oknie Project Explorer klikamy

prawym klawiszem na projekcie i z menu kon-

tekstowego wybieramy opcję Import . Pojawi się

okno źródła importu w którym należy wybrać

opcję Archive File oraz przejść do kolejnego

okna dialogowego (klawisz Next ). W oknie im-

portu należy wcisnąć przycisk Browse i wska-

zać plik stm32-examples.tgz w wyniku czego

zostanie wyświetlona lista plików znajdująca

się w archiwum. Należy wybrać wszystkie pli-

ki, oraz zakończyć import plików za pomocą

klawisza Finish . Po zaimportowaniu projektu

możemy przystąpić do jego kompilacji (kla-

wisze Ctrl+B lub z menu Project–>Build All ).

Jeżeli wszystko przebiegło pomyślnie, na dole

w oknie „ Console ” powinniśmy zobaczyć logi

z kompilacji natomiast w oknie Problems nie

powinno być żadnych informacji.

Po skompilowaniu projektu zostało nam

zaprogramowanie zestawu STM32-Butterly.

Programowanie układu odbywa się poprzez

wywołanie polecenia make install , które moż-

na również wywoływać bezpośrednio z pozio-

mu Eclipse . Odbywa się to poprzez stworzenie

ikonki dla wybranej reguły make w zakładce

make target, znajdującej się po prawej stronie

okna głównego. Aby to zrobić wystarczy klik-

nąć ikonkę z symbolem zielonego okręgu znaj-

dującego się na tej zakładce, co spowoduje wy-

świetlenie okna dialogowego umożliwiającego

skonigurowanie ikony dla wybranej reguły

make. W oknie tym należy wpisać regułę pro-

pewniający obsługę urządzeń USB z przestrzeni

użytkownika, bez konieczności używania ste-

rowników jądra. W tym celu w terminalu wyda-

jemy polecenie stat /proc/bus/usb/devices . Jeżeli

otrzymamy komunikat No such ile or directory ,

do pliku rc.local należy za pomocą edytora dopi-

sać polecenie montujące system USBFS : mount -t

usbfs none /proc/bus/usb. Ostatnią czynnością

jest instalacja programu OpenOCD , który można

pobrać dla obu architektur z mojej strony domo-

wej (i386: http://bryndza.boff.pl/downloads/ope-

nocd-0.3.1_i386.tgz , AMD64: http://bryndza.boff.

pl/downloads/openocd-0.3.1_amd64.tgz ). Proces

instalacji jest trywialny i sprowadza się do roz-

pakowania archiwum z pomocą polecenia sudo

tar xvfz openocd-0.3.1_architektura -C / .

Rys. 7.

gram a następnie wcisnąć klawisz OK ( rys. 8 ).

Po wykonaniu tej czynności w zakładce Make

Targets będziemy mogli zobaczyć ikonę z opi-

sem program ( rys. 9 ).

Aby zaprogramować urządzenie należy do

złącza USB podłączyć JTAG BF-30 z przełączni-

kiem koniguracyjnym ustawionym w pozycję

JTAG, podłączyć zasilanie zestawu STM32-

Butterly , a następnie kliknąć we wspomnianą

wcześniej ikonę. Po krótkiej chwili układ po-

winien zostać zaprogramowany, a diody LED

D1 , D2 powinny migać naprzemiennie.

Potraimy już kompilować programy oraz

programować mikrokontroler, do omówienia

pozostało nam jeszcze debugowanie aplikacji.

Przykładowy projekt – tworzenie,

kompilacja, programowanie

zestawu

Zintegrowane komercyjne środowiska pro-

gramistyczne posiadają wbudowane kreatory

umożliwiające stworzenie projektu za pomo-

cą kilku kliknięć myszką. Niestety, Eclipse nie

ma żadnych ułatwień w tym kierunku, ale ten

problem można rozwiązać bardzo prosto, wy-

korzystując pliki z wzorcowego projektu przy-

gotowanego przez autora.

Zaczynając naukę programowania najczę-

ściej pierwszym przykładem prezentowanym

w książkach jest aplikacja typu „Hello World”

wypisująca tekst na ekranie. Podobnie w przy-

padku mikrokontrolerów zazwyczaj pierwszym

programem jest przykład z mrugającymi dioda-

mi LED. Zatem idąc wydeptaną ścieżką, poka-

żemy krok po kroku jak bazując na wzorcowym

projekcie stworzyć własną aplikację mrugającą

diodami zestawu STM32-Butterly . Przygoto-

waną wzorcową aplikację należy pobrać ze

strony http://bryndza.boff.pl/downloads/stm32-

examples.tgz , a następnie uruchomić środowi-

sko Eclipse . Z menu aplikacji wybieramy opcje:

File–>New–>C Project , co spowoduje wyświe-

tlenie okna kreatora aplikacji. W oknie nazwy

projektu ( Project Name ) wpisujemy przykłado-

wą nazwę projektu, (w tym przypadku leds ),

natomiast pozostałe ustawienia pozostawiamy

jak na rys. 6 .

Przykładowy projekt –

debugowanie

Debugowanie w naszym środowisku od-

bywa się za pomocą programu debugera Ope-

nOCD , którego zadaniem jest bezpośrednia

obsługa interfejsu JTAG oraz mikrokontro-

lera. Program ten nasłuchuje na wybranym

porcie ( 3333 ) na połączenia od programu

Rys. 8.

Rys. 9.

ELEKTRONIKA PRAKTYCZNA 2/2010

NARZĘDZIA KONSTRUKTORA

Rys. 10.

Rys. 12.

należy wybrać projekt,

który chcemy debugo-

wać (w tym przypad-

ku leds ), co powinno

zaowocować automa-

tycznym przypisaniem

pliku binarnego aplikacji w polu C/C++ Appli-

cation . Teraz należy przejść do zakładki Debu-

ger , gdzie w polu debugger należy z listy wybrać

opcję gdbserver debuger , oraz ustawić nazwę

pliku programu debugera GDB ( rys. 12 ).

Następnie w pod-zakładce Connnection

należy wybrać typ połączenia ( Connection

type ) TCP , nazwę hosta ( hostname ) należy usta-

wić na localhost , natomiast w pole port należy

wpisać wartość 3333 ( rys. 13 ).

Koniguracja w zasadzie dobiegła końca

należy jeszcze wcisnąć klawisz Apply , a na-

stępnie zamknąć okno przyciskiem Close .

Przed sprawdzeniem koniguracji w praktyce

jeszcze jedna drobna uwaga odnośnie optyma-

lizacji kompilacji programu. W pliku projektu

ex-led/Makeile na początku pliku znajduje się

zmienna OPT=2, która umożliwia sterowanie

procesem optymalizacji kodu. Opcja 2 jest po-

lecana w przypadku, generowania docelowych

programów, i zdaniem autora zapewnia dobry

wybór pomiędzy wielkością aplikacji a szyb-

kością jej działania. Niestety podczas debugo-

wania wybranie tej opcji może powodować,

iż debugger będzie pomijał niektóre linie pod-

czas pracy krokowej, lub nie będzie dostępny

podgląd niektórych zmiennych. Dzieje się tak

ponieważ kompilator, często optymalizuje

dany fragment kodu tak, że przestaje on bezpo-

średnio mieć odzwierciedlenie w postaci linii

kodu źródłowego. Właśnie ze wspomnianego

wyżej powodu zalecane jest aby przed debugo-

waniem skompilować całą aplikację z opcją 0,

zaprogramować mikrokontroler, a następnie po

tej czynności – rozpocząć sesję debuggera.

Powracając do głównego wątku, spróbuj-

my uruchomić debugger z naszą aplikacją.

W tym celu najpierw uruchamiamy program

OpenOCD (klikając na ikonę Launch External

Tool ), a następnie ikonę z symbolem „robaka”,

co powinno zaowocować uruchomieniem pro-

gramu w trybie Debug oraz zatrzymaniem się

Rys. 13.

Rys. 11.

debugera gdb , który umożliwia bezpośrednią

interakcję z użytkownikiem. GDB komuniku-

je się z użytkownikiem za pomocą konsoli,

więc użytkownicy systemu Windows mogą

z jego obsługą mieć problemy. W przypad-

ku środowiska Eclipse odpowiednie polece-

nia dla debugera wysyła samo środowisko,

umożliwiając wygodną pracę bez konieczno-

ści wpisywania dodatkowych poleceń.

Przygotowanie projektu do debugowa-

nia, rozpoczniemy od dodania programu

OpenOCD , tak aby uruchamiał się po wci-

śnięciu pojedynczego przycisku. W tym

celu z menu start wybieramy opcję Run

–>External Tools–>External Tools Conigura-

tion , co spowoduje wyświetlenie okna dialo-

gowego umożliwiającego konigurację urucho-

mienia zewnętrznych programów. W tym oknie

należy wybrać ikonę New Launch Conigura-

tion , która utworzy nową konigurację urucho-

mieniową. W oknie koniguracyjnym ( rys. 10 ),

należy wprowadzić ścieżkę do programu Ope-

nOcd ,wskazać katalog roboczy, oraz argumen-

ty dla polecenia.

Po wprowadzeniu koniguracji możemy

spróbować uruchomić aplikację wybierając

przycisk Run . Aplikacja zostanie uruchomio-

na w wewnętrznej konsoli, gdzie wypisze ko-

munikat o znalezieniu mikrokontrolera oraz

pozostanie aktywna w tle. Zatrzymanie apli-

kacji możliwe jest po wciśnięciu ikony z sym-

bolem stop ( rys. 11 ).

Potraimy już uruchomić OpenOCD pozo-

stało nam jeszcze skonigurowanie Eclipse, tak

aby potraił połączyć się serwerem OpenOCD

i przejść do trybu debugowania. Aby to zrobić

należy z menu wybrać opcję: Run–>Debug Con-

igurations , co spowoduje wyświetlenie okna

dialogowego z ustawieniami koniguracyjnymi.

W oknie tym, po lewej stronie, należy kliknąć na

ikonę z opisem C/C++ Application , która wyge-

neruje nową konigurację. W oknie koniguracji

aplikacji w funkcji main() ( rys. 14 ). Przy pierw-

szym uruchomieniu sesji należy wybrać opcję

Menu–>Debug Coniguration i wybrać program

ledsDBG , a następnie wcisnąć klawisz RUN. Te-

raz wciskając klawisz F6 ( Step Over ) możemy

śledzić wykonanie poszczególnych linii progra-

mu. Eclipse umożliwia również ustawianie pu-

łapek w określonych miejscach programu po-

przez kliknięcie myszką na niebieskim obszarze

przed wybraną linią. Umożliwia też śledzenie

zmiennych. Inny użyteczny skrótów klawiszo-

wy to F5 ( Step Into ), opcja która umożliwia za-

głębienie się do wnętrza funkcji.

Tryb debugowania Eclipse zapewnia moż-

liwości porównywalne z innymi środowiska-

mi komercyjnymi. Opis wszystkich opcji

przekracza łamy niniejszego artykułu, nie-

mniej jednak środowisko to jest na tyle intu-

icyjne, że nie powinno być większych proble-

mów ze znalezieniem poszukiwanej funkcji.

Budowa projektu

Dla użytkownika używającego zintegro-

wanego środowiska programistycznego jedy-

nym zmartwieniem jest utworzenie plików

źródłowych, ponieważ wszystkie skrypty

potrzebne do pracy generowane są automa-

tycznie. Podejście takie zazwyczaj jest zado-

walające, jeżeli wszystko działa poprawnie.

W przypadku, w którym pojawią się jakieś

problemy, użytkownik tak naprawdę nie

wie w jaki sposób one działają. Nie ma też

wpływu na działanie kreatorów, co może być

przyczyną wielu problemów. Środowisko Ec-

lipse nie zapewnia żadnego specjalistyczne-

go wsparcia w przypadku projektów dla mi-

krokontrolerów, w związku z tym wszystkie

pliki należy stworzyć samodzielnie. Może

to być zadaniem stosunkowo skomplikowa-

nym, dlatego najwygodniej będzie skorzy-

stać z gotowego projektu bazowego dla danej

rodziny mikrokontrolerów, zmieniając tylko

potrzebne opcje. Zaprezentowany projekt

ELEKTRONIKA PRAKTYCZNA 2/2010

Darmowe narzędzia programowe dla mikrokontrolerów STM32

unused_vector, //

MemManageException

unused_vector, //

BusFaultException

unused_vector, //

UsageFaultException

Rys. 14.

W pliku należy przy-

pisać funkcję, która bę-

dzie odpowiedzialna za

realizację obsługi danego

przerwania. Domyślnie

wszystkie wektory mają

zdeiniowaną funkcję

unused_vetor() która za-

wiera nieskończoną pę-

tlę while(1) . W naszym

prostym przykładzie nie

wykorzystujemy żadnych

przerwań więc nie ma po-

trzeby dopisywania tutaj

żadnych funkcji.

bazowy dla mikrokontrolerów STM32 ma

strukturę hierarchiczną ( rys. 15 ). W katalogu

scripts zawarte są skrypty odpowiedzialne

za przebieg kompilacji oraz programowanie

urządzenia docelowego. Plik stm32.mk jest

plikiem dla narzędzia make , zapewniającego

automatyzację procesu kompilacji. Stanowi

on bazę, która jest dołączana do głównego

pliku Makeile. Został napisany w taki spo-

sób, aby wszystkie pliki źródłowe C, C++,

oraz S (assembler) utworzone w pliku pro-

jektu były kompilowane automatycznie.

Plik stm32.cfg jest plikiem konigura-

cyjnym dla programu debugera OpenOCD

i zawiera opis koniguracji JTAG-a BF-30 oraz

mikrokontrolerów rodziny STM32.

Plik stm32.ld jest skryptem linkera, w któ-

rym mamy możliwość zdeiniowania wielko-

ści pamięci, która może być różna zależnie od

wybranego układu z danej rodziny. W linii:

RAM (xrw) : ORIGIN = 0x20000000,

LENGTH = 48K

możemy deiniować adres bazowy oraz rozmiar

wielkości pamięci RAM, natomiast w linii:

FLASH (rx) : ORIGIN = 0x8000000,

LENGTH = 128K

adres bazowy oraz wielkość pamięci FLASH

w zależności od używanego układu

W katalogu lib-stm32 , znajduje się część

biblioteki STM32 Perhipheral library , z której

wyciągnięto pliki nagłówkowe(katalog inc ),

oraz skrypty dla linkera ( *.ld ). Pliki nagłów-

kowe zostały zmodyikowane aby zawierały

tylko struktury opisujące układy peryferyj-

ne. Zdaniem autora biblioteka STM32 Perhi-

pheral Library nie stanowi przejawu kunsztu

programistycznego i niepotrzebnie zajmuje

cenne miejsce w pamięci mikrokontrolera.

Właściwy przykład błyskający diodami LED

zawarty jest w katalogu ex-leds . Głównym pli-

kiem sterującym przebiegiem kompilacji pro-

jektu jest plik Makeile . Plik ten zawiera kilkę

użytecznych opcji, które mogą być zmieniane

przez użytkownika w zależności wymagań.

Najistotniejszy fragment pliku z punktu wi-

dzenia użytkownika przedstawiono niżej:

# Automatic makeile for GNUARM (C/C++)

# Copyright (C) Lucjan Bryndza

<lucjan.bryndza@ep.com.pl>

# http://www.boff.pl

#tutaj wpisz nazwe pliku hex

TARGET = leds-example

#Format wyjsciowy (moze byc

elf,hex,bin)

FORMAT = hex

#Optymalizacja [0,1,2,3,s]

# 0 - brak optymalizacji, s

-optymalizacja rozmiaru

OPT = 2

#Common lags

COMMON_FLAGS = -Wall -pedantic

-DSTM32F10X_CL

W zmiennej TARGET mamy możliwość

wpisania nazwy pliku wynikowego, który po-

wstanie w wyniku kompilacji projektu. Pole

format umożliwia określenie rodzaju pliku

wynikowego wygenerowanego w wyniku

kompilacji. Skrypt przewiduje możliwość

generowania pliku w formatach ELF , Intel

Hex lub bezpośrednio w formacie binarnym.

Kolejną istotną opcją jest tryb optymalizacji

kodu wynikowego, który został opisany we

wcześniejszej części tekstu. Mamy tutaj moż-

liwość sterowania optymalizacją od opcji 0

(brak optymalizacji ) poprzez 3 (maksymalna

optymalizacja na szybkość programu), do s

(optymalizującą program pod kątem jak naj-

mniejszego miejsca zajmowanego w pamięci).

Ostatnią istotną zmienną jest COM-

MON_FLAGS , która umożliwia podanie do-

datkowych wspólnych opcji dla kompila-

tora C oraz C++. Istotna tutaj jest deinicja

-DSTM32F10X_CL , powodująca zdeinio-

wanie typu mikrokontrolera dla biblioteki

STM32 Standard Perhipheral Library . Mamy

tutaj możliwość zdeiniowania następujących

symboli: STM32F10X_LD (mikrokontrolery

STM32 Low Density Line ), STM32F10X_MD

(STM32 Medium Density Line ), STM32F10X_

HD (STM32 Hi Density Line ), STM32F10X_

CL (STM32 Conectivity Line – jak w zestawie

STM32 Butterly ). Pozostałe pliki są plikami

źródłowymi w języku C, i odpowiadają bez-

pośrednio za działanie aplikacji. Warto tutaj

wspomnieć o pliku startup.c , w którym zosta-

ła zdeiniowana globalna tablica przypisująca

funkcję do wektorów przerwań.

/*------------------------------------

----------------------*/

//Interrupt vector table

__attribute__ ((section(“.isr_

vector”)))

void (* const exceptions_vectors[])

(void) =

{

&_estack, // The initial

stack pointer

reset_handler, // The reset

handler

unused_vector, //NMIException

unused_vector, //HardFaultException

Rys. 15.

Zakończenie

Zaprezentowane w tym artykule zintegro-

wane środowisko programistyczne złożone

z komponentów Open Source umożliwia zupeł-

nie wygodne i niczym nieograniczone pisanie

oraz uruchamianie aplikacji dla mikrokontro-

lerów STM32. Po poświęceniu odrobiny czasu

na przygotowanie, dostajemy pełną wersję wy-

godnego środowiska, która w przeciwieństwie

do innych komercyjnych IDE, może pracować

poza systemem Windows, na przykład w Linuk-

sie. Przy tworzeniu nowego projektu musimy

pamiętać, aby przed rozpoczęciem pracy usta-

wić kilka opcji koniguracyjnych we właściwo-

ściach projektu. W Eclipse nie mamy wbudowa-

nych kreatorów, umożliwiających stworzenie

projektu za pomocą kilku kliknięć myszką, ale

bazując na przykładowej aplikacji po nabyciu

odrobiny wprawy, mamy możliwość rozpo-

częcia projektu równie szybko i wygodnie. Co

najważniejsze, mamy pełne panowanie nad

procesem kompilacji oraz skryptami konigu-

racyjnymi. Równie dobrze kompilacje możemy

przeprowadzić poza edytorem, np. w systemie

automatycznego relasowania oprogramowania,

co jest w zasadzie niewykonalne w przypadku

komercyjnych narzędzi.

Lucjan Bryndza, EP

lucjan.bryndza@ep.com.pl

R E K L A M A

ELEKTRONIKA PRAKTYCZNA 2/2010

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: