Z biegiem czasu gdy tworzy się coraz większe projekty, na coraz to lepsze i bardziej rozbudowane mikrokontrolery panowanie nad kodem staje się coraz trudniejsze. Często ciężko przewidzieć pewne rzeczy, a to prowadzi z kolei do błędów, które później bardzo ciężko znaleźć. Aby przyspieszyć tworzenie oprogramowania i skrócić tzw. „time to market” producenci wyposażają swoje układy w interfejsy które pozwalają debugować program podczas wykonywania. Daje to niesamowite możliwości i bardzo ułatwia tworzenie bezbłędnego kodu. Obecnie prawie każdy mikrokontroler, który kosztuje więcej niż 10zł ma na pokładzie jakiś interfejs do debugowania. Najczęściej jest to popularny JTAG, ale coraz częściej pojawiają się też inne, np. Serial Wire Debug, które zaczynają z nim konkurować. Żeby moc debugować program przez JTAG potrzebujemy dwóch rzeczy: po pierwsze interfejsu JTAG podłączanego do komputera (przez LPT bądź USB), a po drugie oprogramowania. W tym artykule zajmę się tylko tą drugą częścią…

Dlaczego OpenOCD?!?

Na rynku istnieje wiele komercyjnych środowisk, niektóre nawet w darmowych wersjach. Jest tylko jeden problem… Mianowicie istnieją dwie możliwości… Pierwsza jest taka, że środowisko jest płatne i obsługuje większość JTAG’ów na rynku, a druga jest taka, że środowisko jest darmowe i obsługuje tylko jeden konkretny JTAG sprzedawany za ciężkie pieniądze przez twórców tego środowiska. Tak więc nie wygląda to zbyt kolorowo. Nie mniej jednak nie jest, aż tak źle. Tak samo, jak w przypadku kompilatorów i IDE (zapraszam do posta gościnnie napisanego przez mojego kolegę: Integracja Eclipse CDT z CodeSourcery dla ARM Cortex-M3) trzeba będzie się trochę natrudzić i nie wszystko będzie podane na tacy, ale można mieć całkiem sprawny aparat do debugowania całkowicie za darmo. Jak zapewne się już domyślacie mowa tutaj o OpenOCD. No to zaczynamy :)

Cygwin

Podstawowy problem (a może raczej wyzwanie :P) z OpenOCD polega na tym, że trzeba je sobie skompilować :) Jako, że będziemy to robić pod windowsem, będziemy potrzebować cygwina, więc musimy sobie go najpierw ściągnąć (np. z oficjalnej strony: http://cygwin.com/, a dokładnie stąd) i zainstalować. Instalacja jest dość prosta, a po kolei wygląda to tak:

• uruchamiamy plik setup.exe
• wybieramy instalację z internetu
• wybieramy ścieżkę instalacji cygwina (najlepiej zostawić domyślną C:\cygwin), tutaj pragnę zwrócić uwagę na to, by przy instalowaniu wszelkiego rodzaju kompilatorów i narzędzi konsolowych raczej unikać ścieżek zawierających spacje, gdyż może to przysporzyć wielu problemów
• wybieramy katalog do którego instalator ściągnie sobie pliki
• wybieramy połączenie bezpośrednie, czyli „Direct Connection”
• wybieramy serwer z którego chcemy ściągnąć cygwina
• gdy otworzy nam się okno wyboru pakietów które chcemy zainstalować musimy dodatkowo zaznaczyć (warto skorzystać z „szukaczki”):
  • autoconf: Wrapper scripts for autoconf commands
  • automake: Wrapper scripts for automake and aclocals
  • gcc: C compiler upgrade helper
  • libtool: A shared library generation tool
  • make: The GNU version og the ‘make’ utility
• klikamy „Dalej” i następnie „Install”

Licencje i takie tam…

Jak mamy już zainstalowanego cygwina to zanim się weźmiemy do konkretnej roboty to jeszcze chciałem napisać parę słów co i jak. W tym artykule chcę opisać kompilowanie OpenOCD ze sterownikami JTAG’ów opartych o układy firmy FTDI. Generalnie istnieją dwie drogi. Jako, że OpenOCD jest na licencji GPL to każdy rozpowszechniany program, który korzysta z OpenOCD musi mieć całkiem otwarte źródła. Aby spełnić to wymaganie do kompilacji musimy użyć sterowników o otwartym kodzie. Jedyne znane mi sterowniki o otwartym kodzie obsługujące układy FTDI, to LibUSB (wersja win32: http://libusb-win32.sourceforge.net/) w połączeniu z biblioteką libftdi (http://www.intra2net.com/en/developer/libftdi/). Tak skompilowaną wersję można rozpowszechniać, bez żadnych problemów i możecie ją ściągnąć np z blogu Freddiego: http://www.freddiechopin.info/). Druga opcja to użycie oficjalnych sterowników i biblioteki firmy FTDI, czyli ftd2xx. Jedyny problem z tą biblioteką jest to, że producent udostępnia ją tylko w wersji skompilowanej, nie pokazując źródeł. Co pociąga za sobą fakt, że tak skompilowane OpenOCD nie spełnia warunku, że cały kod produktu musi być otwarty i udostępniony. Tak więc nie można rozpowszechniać tak skompilowanego programu. Nie oznacza to natomiast, że nie można sobie skompilować OpenOCD z taką biblioteką. Dlatego też opiszę dokładnie jak to zrobić, tak by każdy mógł sobie skompilować kod we własnym zakresie. No to na tyle ględzenia i lecimy dalej.

Instalujemy sterowniki do JTAG’a

Najpierw musimy ściągnąć i zainstalować sterowniki do urządzenia i dopiero później możemy kompilować bibliotekę. Trochę to dziwne, ale podczas konfiguracji biblioteki skrypty do tego stworzone testują jakoś tą bibliotekę i jeżeli nie ma w tej chwili zainstalowanych sterowników test się nie powiedzie i nie będzie można ukończyć kompilacji. Najdziwniejsze jest to, że przy kompilacji z bibliotekami libftdi nie ma żadnego testu tylko wszystko ładnie idzie :/ Sterowniki ściągamy z  ze strony producenta ukladów (http://www.ftdichip.com/, dokładnie stąd – obecnie jest to wersja 2.06.02). Musimy je teraz wypakować, ale żeby łatwiej było nam się później (przy kompilacji) dogadać co do ścieżek to proponuje stworzyć katalog „C:\tmp” do niego wypakować zawartość archiwum, a następnie zmienić nazwę wypakowanego katalogu z „CDM 2.06.00 WHQL Certified” na „ftd2xx”. Skoro już wzięliśmy się za ściąganie to odrazu proponuję pobrać źródła OpenOCD (stąd) w tym momencie najnowszą wersją jest: „openocd-0.4.0„, jest to co prawda wersja RC, ale działa całkiem sprawnie, więc nie widzę powodów by korzystać ze starszej (jeżeli jednak ktoś bardzo chce, może pobrać starszą wersję – cała procedura kompilacji wygląda dokładnie tak samo). No więc ściągamyOpenOCD i rozpakowujemy do naszego folderu „C:\tmp”. Dla jasności obok przedstawiam jak powinno wyglądać drzewo katalogów. Potrzebujemy jeszcze jednego małego programiku, do wygenerowania plików inf sterowników. Programik nazywa się FT_INF i możemy go pobrać ze stronki FTDI (http://www.ftdichip.com/Resources/Utilities.htm). Programik pobieramy, rozpakowujemy gdziekolwiek, instalujemy i uruchamiamy. Naszym oczom ukazuje się tajemnicze okno w którym nie wiemy co wpisać :P Ale spokojnie, zaraz będziemy wiedzieli. Jedyne co musimy wiedzieć to jakiego JTAG’a mamy, jeżeli wiemy to szukamy w katalogu „C:\tmp\openocd-0.4.0-rc2\tcl\interface” pliku *.cfg odpowiedniego dla naszego JTAG’a. W moim przypadku to „jtagkey.cfg” (Posiadam JTAG’a projektu Freddiego Choppina, opartego o Amontec JTAGkey). Otwieramy ten plik i patrzymy co  jest w nim popisane. U mnie wygląda to tak jak na rysunku. Teraz wystarczy przepisać odpowiednie informacje do okienka programu FT_INF. Jak to wygląda u mnie, możecie zobaczyć na screenie. Układ (pole chip) należy wybrać zgodnie ze screenem, Następnie wpisać odpowiednie dane w sekcji „Vendor ID / Product ID” zgodnie z plikiem *.cfg. Później klikamy „>>” aby dodać nasze urządzenie do list. Musimy jeszcze wskazać pliki „ftdibus.sys” oraz „ftser2k.sys” które znajdują się w katalogu ze sterownikami, a dokładnie: „C:\tmp\ftd2xx\i386″ (lub „C:\tmp\ftd2xx\amd64″ w zależności od architektury).

Ustawiamy także folder „Output” najlepiej na „C:\tmp\ftd2xx” i klikamy „Generate Files”. Program spyta czy nadpisać pliki *.ini, oczywiście się zgadzamy. Po tych operacjach mamy już gotowe sterowniki do swojego JTAG’a w katalogu „C:\tmp\ftd2xx”. Tak, więc podłączamy JTAG’a i instalujemy stworzone przed chwilą sterowniki. Jeżeli wszystko pójdzie dobrze możemy kontynuować. Kolejnym krokiem będzie już kompilacja.

Czas na kompilację

Ten etap wbrew pozorom jest chyba najprostszy :) Odpalamy więc konsole cygwina (przy instalacji na pewno wepchał nam jakiś skrót do menu start) i przechodzimy do naszego katalogu, a dokładnie do katalogu z OpenOCD wpisując komendę:

cd /cygdrive/c/tmp/openocd-0.4.0-rc2

po czym wywołujemy plik konfigurujący komendą:

./configure --enable-maintainer-mode --disable-werror --disable-shared
--enable-ft2232_ftd2xx --with-ftd2xx-win32-zipdir=/cygdrive/c/tmp/ftd2xx

chwile to potrwa, więc musimy być cierpliwi. Jeżeli w czasie konfigurowania dostaniemy komunikat taki jak na screenie,

oznacza to, że nie zainstalowaliśmy dobrze sterowników przed rozpoczęciem procesu konfigurowania (to muszą być dokładnie te same sterowniki – ta sama wersja biblioteki – te które instalujemy i te które używamy do kompilacji) Natomiast jeżeli wszystko poszło jak należy odpalamy komendę:

make

i znów czekamy :) … aż się skompiluje. Jeżeli wszystko się uda to w katalogu „C:\tmp\openocd-0.4.0-rc2\src” znajdziemy plik „openocd.exe”. Teraz wystarczy zebrać wszystko razem i mamy gotowe skompilowane OpenOCD. No więc do dzieła. Tworzymy sobie gdzieś katalog „OpenOCD0.4.0rc2″, w nim tworzymy katalog „bin” do którego kopiujemy plik „openocd.exe”, oraz pliki „cygwin1.dll”, oraz „cyggcc_s-1.dll” z katalogu „bin” cygwina (najczęściej C:\cygwin\bin), aby uniezależnić się od cygwina. Dodatkowo do katalogu „OpenOCD0.4.0rc2″ kopiujemy całą zawartość folderu „C:\tmp\openocd-0.4.0-rc2\tcl”. To wszystko. Katalog „OpenOCD0.4.0rc2″ zawiera teraz wszystko co jest potrzebne do działania OpenOCD. Wystarczy go przenieść w dowolne miejsce na dysku.

A teraz podpinamy do Eclipse

Zanim zaczniemy proponuję postawić sobie Eclipse’a i CodeSourcery zgodnie z opisem we wcześniejszym wpisie (Integracja Eclipse CDT z CodeSourcery dla ARM Cortex-M3). Jeżeli mamy już postawione IDE z podpiętym kompilatorem, to możemy zabierać się za kolejny ważny element Toolchain’u, czyli Debugger.

Pierwszym krokiem jest instalacja odpowiednich wtyczek do Eclipse’a pozwalających używać debuggera sprzętowego i OpenOCD. Pierwsza z nich to Eclipse C/C++ GDB Hardware Debugging. Aby go zainstalować wybieramy Help->Install New Software.Możemy go pobrać z oficjalnego update site’u Eclipse’a. Aby to zrobić wpisujemy w pole „Work with” http://download.eclipse.org/tools/cdt/releases/galileo i zaznaczamy plugin, aby go zainstalować (znajduje się on w kategorii „CDT Optional Features”). Następnie postępujemy zgodnie ze wskazówkami, co praktycznie sprowadza się do klikania „Next”. Kolejny plugin to Zylin Embedded CDT .Update site tego plugina to: http://opensource.zylin.com/zylincdt. Zaznaczamy plugin i kontynuujemy instalacje. Oczywiście godzimy się na niepodpisane oprogramowanie i restartujemy eclipse zgodnie z sugestią.

Gdy mamy zainstalowane obie wtyczki możemy przystąpić do podpinania OpenOCD. Otwieramy sobie jakiś projekt (proponuję przykładowy z wpisu Integracja Eclipse CDT z CodeSourcery dla ARM Cortex-M3), lub tworzymy nowy. Następnie klikamy w menu „Run->External Tools->External Tools Configuration…”. Wybieramy „New launch configuration”, by dodać nowe narzędzie. Następnie musimy wpisać nazwę narzędzia (np. OpenOCD), ścieżkę do pliku openocd.exe, oraz parametry z jakimi zostanie odpalony program. Jako parametry musimy przede wszystkim podać pliki konfiguracyjne, odpowiednie dla mikrokontrolera z którym się łączony, oraz JTAG’a. Wpisane przeze mnie parametry przedstawiam na screen’ie. Na pozostałych zakładkach nie musimy nic zmieniać. Gotowe :) Teraz podłączamy JTAG’a do komputera i do debugowanego układu i odpalamy narzędzie np. poprzez menu „Run->Configuration Tools”. Jeżeli wszystko się powiedzie powinniśmy w konsoli zobaczyć komunikat podobny jak na screen’ie.

Jeżeli OpenOCD już działa możemy się zabrać za stworzenie odpowiedniej konfiguracji do debugowania. Klikamy „Run->Debug configurations…”. Tworzymy nową konfigurację, podobnie jak poprzednio (ja nadałem jej nazwę gbd(flash)). Następnie ustawiamy odpowiednie parametry. Na zakładce „Main” wybieramy projekt, który chcemy debugować klikając „Browse…” obok pola „Project”. Przechodzimy do zakładki „Debugger”, gdzie musimy podać ścieżkę do gdb pochodzącego z Code Sourcery, oraz zmienić numer portu na 3333. Później ustawiamy odpowiednie opcje na zakładce „Startup” zgodnie ze screen’em.

Następnie tworzymy identyczną konfigurację tylko dopisujemy jeszcze komendę load na zakładce „Startup” w polu poniżej opcji „Halt”. Ta konfiguracja pozwoli nam załadować program do pamięci mikrokontrolera.

Aby debugować program musimy najpierw włączyć OpenOCD, robimy to jednorazowo. Później wybieramy odpowiednia konfigurację debugowania – samo debugowanie, lub debugowania z ładowaniem programu do pamięci. Samego debugowania w Eclipse nie będę opisywał, gdyż można znaleźć wiele informacji na ten temat w internecie.

Źródła:

• http://www.plugcomputer.org/plugwiki/index.php/Main_Page
• http://forum.sparkfun.com/viewtopic.php?t=11221&postdays=0&postorder=asc&start=0&sid=89cf3e590ac8185041bdbcc7ec2732e4

• Poprzedni wpis: Integracja Eclipse CDT z CodeSourcery dla ARM Cortex-M3
• Następny wpis: Moduł z mikrokontrolerem STM32F103RBT