Entwicklungsumgebung: Eclipse für STM32 unter Ubuntu

Evaluation Board: STM32-P152

Nachfolgend wird erläutert, wie eine freie Programmierumgebung für STM32 unter Ubuntu eingerichtet werden kann. In diesem Beispiel baut die Entwicklungsumgebung auf Eclipse mit diversen Erweiterungen auf.
In diesem Tutorial beziehen ich mich auf das Olimex STM32-P152 Evaluation-Board, welches einen STM32L152VBT6 Mikrocontroller enthält. An einigen Stellen gibt es allerdings auch Verweise für die Familien F0, F1, F2, F3 und F4.

1. Verwendete Komponenten

Evaluation Board: Olimex STM32-P152
JTAG-Debugger: Olimex ARM-USB-TINY-H

2. Verwendete Programme

Ubuntu 14.10
Eclipse Kepler 4.3 (Service Release 2)
OpenOCD 0.9.0
ARM GCC Toolchain 5.0
ARM GCC Plugin 2.8.1 (Eclipse Plugin)
Zylin 4.16 (Eclipse Plugin)

3. Vorgehensweise

installiere „OpenOCD“
installiere „GCC ARM Embedded Toolchain”
installiere Eclipse für C/C++ (Kepler)
Eclipse add-ons hinzufügen
ein neues Projekt in Eclipse beginnen
Einrichten von OpenOCD in Eclipse
Einrichten des Debuggers in Eclipse

4. Installiere OpenOCD

OpenOCD steht für Open On-Chip Debugger. Dieses Tool stellt die Verbindung zwischen Board, Debugger und PC her.

Installation

Terminal: ~$ sudo apt-get install openocd

Mehr Informationen

http://openocd.org/

JTAG-Debugger: ARM-USB-TINY-H

5. Installiere GCC ARM Embedded Toolchain

Die GCC ARM Toolchain wird benötigt, um den C-Quellcode in maschinenlesbaren Code zu übersetzen. Sie übernimmt in Eclipse das Builden und einen Teil des Debuggens.

Installation

Terminal:
~$ sudo apt-get install dh-autoreconf libusb-1.0-0-dev libftdi-dev
~$ sudo add-apt-repository ppa:terry.guo/gcc-arm-embedded
~$ sudo apt-get update
~$ sudo apt-get install gcc-arm-none-eabi

Mehr Informationen

https://launchpad.net/~terry.guo/+archive/ubuntu/gcc-arm-embedded
http://wiki.ubuntuusers.de/Archiv/GNU_ARM-Toolchain
http://fab.cba.mit.edu/classes/4.140/tutorials/EmbeddedProgramming/stm32.html

6. Installiere Eclipse für C/C++

Eclipse wird von uns als Entwicklungsumgebung für C/C++ verwendet. Eine Entwicklungsumgebung ist ein Programm, in dem der Quellcode geschrieben, gebuildet und debuggt wird. Es ist damit die Hauptoberfläche mit der sich ein Programmierer beschäftigt.

Automatische Installation

Terminal: ~$ sudo apt-get install eclipse

Falls keine aktuelle Version von Eclipse installiert werden sollte, (Eclipse 4.3 Kepler oder höher) muss Eclipse manuell installiert werden.

Manuelle Installation

gehe auf die Eclipse Homepage: www.eclipse.de
lade Eclipse Kepler oder eine höhere Version für Linux herunter (achte dabei auf 32 Bit / 64 Bit)
installiere ROOT-Befehl für graphische Anwendungen:
~$ sudo apt-get install gksu
starte Nautilus mit ROOT-Rechten:
~$ gksudo nautilus
navigiere zum Verzeichnis /opt/
Extrahieren des Eclipse-Archivs hier in einen Ordner (eine eindeutige Namenswahl ist immer gut, z.B. eclipse_kepler)
Nach dem Entpacken muss der Datenpfad, in dem Eclipse abgelegt wurde, für den Benutzer freigegeben werden.
Im folgenden Terminal-Befehl muss $USER durch den Benutzernamen des Kontos ersetzt werden, welcher für die Verwendung von Eclipse freigegeben werden soll (z.B. jochen). Der Ordner „eclipse_kepler“ muss durch den gerade erstellten Ordnernamen ersetzt werden.
~$ sudo chown -R $USER:$USER /opt/eclipse_kepler

Mehr Informationen

https://eclipse.org/
http://wiki.ubuntuusers.de/eclipse
http://ubuntuhandbook.org/index.php/2014/06/install-latest-eclipse-ubuntu-14-04/
https://wiki.ubuntuusers.de/chown/

7. Eclipse Plugins

Um Eclipse für die geplante Aufgabe tauglich zu machen, ist es notwendig einige Plugins zu installieren. Plugins können meistens auf mehreren Wegen installiert werden. In diesem Dokument wurde versucht, die jeweils einfachste und schnellste Variante zu wählen.

7.1. CDT

Zu Beginn erweitert man Eclipse um die Plugins „CDT“ (C/C++ Development Tools) und „G++“ (GNU-C/C++ Compiler). Dabei handelt es sich um die C/C++Software Development-Funktion und einen C/C++ Compiler von GNU. Diese Plugins machen ein Programmieren in C/C++ möglich.

Installation

Terminal: ~$ sudo apt-get install eclipse eclipse-cdt g++

Mehr Informationen

https://eclipse.org/cdt/
https://de.wikipedia.org/wiki/GNU_Compiler_Collection

7.2. GNU ARM Eclipse Plugins

Das „GNU ARM Eclipse Plugin“ erweitert Eclipse um einige Bibliotheken und bietet für die STM32-Familien F0xx, F10x, F2xx, F3xx und F4xx vorgefertigte Template-Projekte an. Des Weiteren werden für diese Familien auch die Standard Peripherie Bibliotheken geladen. Die von mir Verwendete Familie L1 gibt es leider nicht in den fertigen Templates, für sie werden auch keine Standard Peripherie Bibliotheken geladen. Diese Templates und Bibliotheken müssen selbst geschrieben (bzw. als fertiges Template von dieser Seite eingebunden) werden.

Installation aus dem Internet

starte Eclipse ⇒ Menüleiste > Help > Install New Software ...
Work with: klicke „Add...“

Name: GNU ARM Eclipse Plug-ins
Location: http://gnuarmeclipse.sourceforge.net/updates

setze einen Haken bei „GNU ARM C/C++ Cross Development Tools“
klicke 2x Next, bestätige die Lizenzvereinbarung und beende die Installation mit einem Klick auf Finish

Mehr Informationen

http://gnuarmeclipse.livius.net/blog/plugins-install/
http://sourceforge.net/projects/gnuarmeclipse/
http://community.arm.com/groups/tools/blog/2014/07/17/gnu-arm-eclipse-open-source-tools-with-experimental-cmsis-pack-support

7.3. Zylin

Das Zylin-Plugin ist ein GDB-Server. Es ist dafür verantwortlich, dass das Debuggen auf dem Entwicklungsboard vonstattengehen kann. Dazu verwendet es teile der GCC ARM Toolchain und OpenOCD.

Installation

starte Eclipse ⇒ Menüleiste > Help > Install New Software ...
work with: klicke „Add...“

Name: (leer lassen)
Location: http://opensource.zylin.com/zylincdt

setze einen Haken bei „Zylin Embedded CDT“
klicke 2x Next, bestätige die Lizenzvereinbarung und beende die Installation mit einem Klick auf Finish

Mehr Informationen

http://opensource.zylin.com/embeddedcdt.html
http://vedder.se/2012/12/debugging-the-stm32f4-using-openocd-gdb-and-eclipse/
http://repo.or.cz/w/zylincdt.git

8. Ein neues Projekt beginnen

Nachdem wir nun viele Programme und Programmbestandteile installiert haben, bekommen wir erstmals das eigentliche C-Projekt zu Gesicht. Für das Erstellen eines neuen Projekts gibt es je nach Mikrocontroller-Familie verschiedene Möglichkeiten. Hier wird eine Möglichkeit für die Familie L1 und eine zweite Möglichkeit für die Familien F0, F1,F2, F3 und F4 vorgestellt.

8.1. STM32-Familie L1

zuerst muss das folgende STM32L1-Template herunter geladen werden
https://www.dropbox.com/s/1l40vgzjdt5i876/TempEclipseSTM32L1-MH.zip?dl=0
kopiere das Template an einen beliebigen Ort (z.B. ~/Schreibtisch/)
öffne Eclipse ⇒ Menüleiste > File > Import...
wähle: General > Existing Projects into Workspace, klicke Next
navigiere zum Template und klick anschließend Finish:

Select arcive file: (Ort des Templates, z.B. /home/(benutzer)/Schreibtisch/TempEclipseSTM32L1-MH-LaBP.zip)
Projects: ✔ TempEclipseSTM32L1-MH (TempEclipseSTM32L1-MH)

Nun wird das Projekt noch umbenannt und der Postprocessor des Builders an den neuen Namen angepasst:

Menüleiste >File >Rename...
wähle den Namen für den Projekt und Klicke OK
jetzt muss der Postprocessor an den neuen Namen angepasst werden
Menüleiste >Project >Properties
Navigiere zu: C/C++ Build >Settings
wähle den Tab „Build Steps“
ändere im Abschnitt „Post-build steps“ die Zeile „Command:“, der alte Projektname muss durch den neu gewählten ersetzt werden, Klicke Apply und anschließend OK

Alt: arm-none-eabi-objcopy -S -O binary TempEclipseSTM32L1-MH-LaBP.elf TempEclipseSTM32L1-MH-LaBP.bin
Neu: arm-none-eabi-objcopy -S -O binary (Projektname).elf (Projektname).bin

8.2. STM32-Familie F0, F1, F2, F3 und F4

öffne Eclipse ⇒ Menüleiste > File > New > C Project und klick Next
benenne dein Projekt und benutze „Cross ARM GCC“ als Toolchain, klick Next

Project name: (Der Name deines Projektes)
Project type: (je nach Chip)

STM32F0xx C/C++ Project
STM32F1xx C/C++ Project
STM32F2xx C/C++ Project
STM32F3xx C/C++ Project
STM32F4xx C/C++ Project

Toolchain: Cross ARM GCC

Nun werden die Target processor settings eingestellt, diese Daten müssen mit den Daten des Boards und des Mikrocontrollers abgeglichen werden. Eclipse trifft zwar meist die richtigen Einstellungen automatisch, darauf sollte man sich jedoch nicht verlassen.

Processor core: (Datenblatt Chip)
Flash size (kB): (Datenblatt Chip)
RAM size (kB): (Datenblatt Chip)
clock(Hz): (Datenblatt Board)
content: Blinky (blink a led)
use system calls: Freestanding (no POSIX system calls)
trace output: Semihosting DEBUG channel
enable Boxes: ✔Check some warnings, ✔Use newlib nano

Als nächstes wird die Ordnerstruktur festgelegt

include folder: inc
source folder: src
system folder: system
CMSIS library folder: cmsis
C library folder: newlib
linker script folder: ldscripts
vendor CMSIS name: DEVICE

bei Set Configurations wird ✔Debug und ✔Relase ausgewählt, klick Next
wähle die vorher installierte GNU ARM Toolchain, klick Finish

toolchain name: GNU Tools for ARM Embedded Processors (arm-none-eabi-gcc)
toolchain path: (Der Pfad zu den Ausführbaren Dateien der Toolchain, er sollte in folgendem Verzeichnis zu finden sein: /usr/bin/arm-none-eabi-gcc)

9. Einrichten von OpenOCD in Eclipse

OpenOCD steht für „Open On Chip Debugger“ und ist für die Verbindung zwischen Mikrocontroller, JTAG-Debugger und PC verantwortlich. Um dieser Aufgabe nachzugehen muss das Programm auf die vom Nutzer verwendeten Hardware eingestellt werden.

lade die Config-Datei des Boards vom Hersteller runter (stm32l.cfg)

Seite des Boards: https://www.olimex.com/Products/ARM/ST/STM32-P152/
Config-Datei: https://www.olimex.com/Products/ARM/ST/STM32-P152/resources/stm32l.cfg

kopiere die Datei ins Verzeichnis: /usr/share/openocd/scripts/target/
falls die Datei schon vorhanden ist, wird die alte Datei ersetzt
öffne Eclipse und navigiere dich zu
Menüleiste > Run > External Tools > External Tools Configuration
Rechtsklick auf Programm > New
gehe auf den neu entstandenen Unterpunkt und gib ihm einen aussagekräftigen Namen (z.B. connect-ARM-USB-TINY-H)
Einstellungen für den Main-Tab:

Location: /usr/bin/openocd
Working Directory: ${workspace_loc}
Arguments:
-f /usr/share/openocd/scripts/interface/ftdi/olimex-arm-usb-tiny-h.cfg -f /usr/share/openocd/scripts/target/stm32l.cfg -00

In Arguments gibt es keinen Zeilenumbruch!
Achte darauf, dass die Dateien in Location und Arguments auch wirklich da sind, die Pfade müssen ggf. an die vorgenommene Installation angepasst werden!

Einstellung für den Common-Tab:

save as: Local file
Display in Favorites menu: ✔External Tools
Die Restlichen Einstellungen können in Standardposition bleiben

Einstellung der anderen Tabs ist nicht nötig, klick Apply und danach Close
Im Favoriten-Menü (Button-Leiste) gibt es einen Button für die External Tools, in seiner Auswahl ist jetzt das von uns definierte OpenOCD-Makro „connect-ARM-USB-TINY-H“ enthalten.
Mit einem Klick darauf kann nun die Verbindung zum Board per OpenOCD hergestellt werden. Die Console sollte folgende Meldung ausgeben:

Open On-Chip Debugger 0.8.0 (2014-05-10-23:20)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.sourceforge.net/doc/doxygen/bugs.html
/usr/bin/openocd: invalid option -- ’0’
/usr/bin/openocd: invalid option -- ’0’
Info : only one transport option; autoselect ’jtag’
adapter speed: 100 kHz
adapter_nsrst_delay: 100
jtag_ntrst_delay: 100
cortex_m reset_config sysresetreq
Info : clock speed 100 kHz
Info : JTAG tap: stm32l.cpu tap/device found: 0x4ba00477
(mfg: 0x23b, part: 0xba00, ver: 0x4)
Info : JTAG tap: stm32l.bs tap/device found: 0x06416041
(mfg: 0x020, part: 0x6416, ver: 0x0)
Info : stm32l.cpu: hardware has 6 breakpoints, 4 watchpoints

Während einer Eclipsesitzung brauch die Verbindung per OpenOCD nur ein Mal hergestellt werden, sie bleibt erhalten, bis man sie manuell trennt

10. Einrichten des Debuggers in Eclipse

öffne Eclipse und navigiere dich zu:
Menüleiste > Run > Debug Configurations...
Rechtsklick auf Zylin Embedded debug(Nativ) > New
gehe auf den neu entstandenen Punkt und gib ihm einen aussagekräftigen Namen z.B. (Projekt)-Debug-Zylin
Einstellungen im Main-Tab

Project (optional): (Projektname, z.B. HelloWorld)
C/C++Application: Debug/(Projektbinary, z.B. HelloWorld.elf)

Einstellungen im Debugger-Tab

Debugger: Embedded GDB
✔Stop on startup at: main
GDB debugger: arm-elf-gdb
GDB command file: .gdbinit
GDB command set: Standard
Protocol: mi

Einstellungen im Commands-Tab

’Initialize’ commands:

01 target remote localhost:3333
02 monitor reset
03 monitor halt
04 monitor flash protect 0 0 11 off
05 monitor flash write_image erase /home/benutzer/Dokumente/Eclipse/Workspace/(Dein Projekt)/Debug/(Binary 06 Name (z.B. Projekt.bin)) 0x08000000
07 disconnect
08 target remote localhost:3333
09 monitor reset
10 monitor halt

Der Pfad in Zeile 5 muss angepasst werden und zum Projekt-Binary (z.B. HelloWorld.bin) führen

’Run’ commands: (leer)

Einstellungen im Common-Tab

✘Local file
Display in favorites menu: ✔Debug

Einstellung der anderen Tabs ist nicht nötig, klick Apply und danach Close
Im Favoriten-Menü (Button-Leiste) gibt es einen Button für Debug, er kann nun jeder Zeit verwendet werden um das Projekt zu debuggen.

vor dem Debuggen (!) ist es wichtig ein OpenOCD-Verbindung herzustellen

11. Sie haben Ihr Ziel erreicht!

Wenn alle vorangegangenen Schritte richtig ausgeführt worden sind, sollte es jetzt möglich sein, das Projekt fehlerfrei zu builden und zu debuggen. Dabei ist der Ablauf immer wie folgt:

Code schreiben (.c und .h Dateien)
builden (Menü-Button „Hammer“)
mit OpenOCD die Verbindung zum Board herstellen (Menü-Button „Koffer“)
mit Zylin debuggen (Menü-Button „Käfer“)

In der von ST bereitgestellten STM32L1xx_StdPeriph_Lib gibt es viele nützliche Programmierbeispiele, die einem das Arbeiten wesentlich leichter machen. Ein Streifzug durch die unter dem nachfolgenden Link geführte Bibliothek ist daher sehr zu empfehlen.

http://www.st.com/web/catalog/tools/FM147/CL1794/SC961/SS1743/LN1939/PF257913

Herzlichen Glückwunsch zur eingerichteten Entwicklungsumgebung und viel Spaß beim Programmieren!

12. Anmerkungen

Das Tutorial wurde verschiedenen Quellen entnommen und komprimiert aufgearbeitet.

Buch

Ralf Jesse, ARM Cortex-M3 Mikrocontroller, mitp Verlag München

Online

https://balau82.wordpress.com/2014/02/23/stm32-p152-development-with-eclipse-on-linux/
http://vedder.se/2012/12/debugging-the-stm32f4-using-openocd-gdb-and-eclipse/
http://nyatekniken.blogspot.de/2012/09/setting-up-olimex-arm-usb-tiny-h-with.html
http://elk.informatik.fh-augsburg.de/pub/stm32lab/Hauffe-Fischer-Eclipse/bericht.html

Ätzen - Löten - Programmieren

Mittwoch, 23. März 2016