Mikrocontroller.net - Benutzerbeiträge [de]

Mini2440

2012-10-05T08:03:24Z

Avr-frickler: Hinweis für arm-linuc-gcc-4.4.3.tgz hinzugefügt.

[http://www.friendlyarm.net/products/mini2440 Mini2440 von friendlyarm ]

Das [[Mini2440]] ist ein [[ARM]]-Board mit [http://www.samsung.com/global/business/semiconductor/productInfo.do?fmly_id=229&partnum=S3C2440&ppmi=PartnoSearch s3c2440] '''S'''ystem '''o'''n '''C'''hip von Samsung.

Das '''Board''' bietet:
* 3,5", 7" Touchscreen-[[TFT]] oder [[VGA]] "Karte"
* ARM920T, 400Mhz standard Taktfrequenz, bis zu 533Mhz
* 64MB-1GB NAND Flash (User App/OS), 2MB NOR Flash (BIOS)
* 64MB RAM
* Audio (Stereo Out, 2xMono In)
* SD-Slot
* [[USB]] Host, USB Device
* 10/100MBit LAN (DM9000)
* 3 Serial Ports
* [[SPI]], [[PWM]], [[I2C]], ...
* ...

[[Bild:mini2440.jpg|300px]][[Bild:mini2440_35.jpg|300px]][[Bild:mini2440_7.jpg|300px]]

== Software ==

Als das passende Entwicklungswerkzeug ist ein Linux-Rechner mit passendem Cross-Compiler sowie ein paar Tools vorgesehen.
Was wirklich benötigt wird:
* Serial Terminal (picocom, minicom, cutecom, gtkterm, komport, ...)
* [http://www.mikrocontroller.net/articles/Mini2440#Toolchain Toolchain]
* s3c_boot_usb oder [ftp://gediam.de/Projekte/Mini2440/mini2440_usb_upload.tar.gz mini2440_usb_upload] (aktueller; mit Status-Anzeige etc.) zum Hochladen von Bootloader, Kernel etc. über USB

Empfehlenswert ausserdem noch:
* ncurses-dev-Dateien und dialog (Für Kernel-menuconfig)
* screen, midnight commander
* Editor mit root-Rechten (z.B. [http://home.in.tum.de/~lazarov/files/research/papers/vi_ausarbeitung.pdf vim])

=== Vorbereitungen am/mit dem Board ===

Ganz wichtig ist es, eine gute Spannungsversorgung zu verwenden. Es kam anscheinend schon öfter vor, dass kleine Spannungseinbrüche das Board aus dem Gleichgewicht bringen.
Ich verwende normalerweise das mitgelieferte Netzteil oder ein '''5V'''/'''2A''' Schaltnetzteil, funktionieren beide einwandfrei.
Gerade das grosse, 7", Display braucht ein starkes Netzteil.

{| class="wikitable"
|+ '''ungefährer Stromverbrauch'''
|-
! Board konfig. || Stromverbrauch
|-
| mini2440 || 140mA
|-
| mini2440 + 3,5" TFT || 410mA (T35 Display)
|-
| mini2440 + 7" TFT || 1000mA
|-
| mini2440 + VGA Board || mA
|}

==== Verbindung zum PC ====

Um vernünftig arbeiten zu können, braucht man auf jeden Fall diese Kabel:
* 1 USB A<->USB B-Kabel
* 1 9 poliges SUB-D Kabel mit zwei Buchsen
* eventuell einen USB-RS232 Adapter, falls man keinen Anschluss am Rechner hat

Einen Zugriff auf die Konsole hat man - nach Anpassung der IP - über Telnet sowie über die serielle Konsole.

Die serielle Konsole ist in der Standardkonfiguration aktiviert und '''sollte''' auch während des Entwickelns '''immer aktiv''' sein - so verhindert man ein ungewolltes Ausperren.

==== Netzwerk ====
Entweder klickt man sich quer durch die chinesische/japanische Software und stellt diese auf Englisch um, oder aber man klickt sich blind zu der Stelle, an der man IP Adresse, Gateway und Netzmaske angeben kann.

Etwa genauso einfach sieht es über die Konsole aus. 
Die folgenden drei Zeilen, dürften das soweit bewerkstelligen, dass das Netzwerk-Device die IP-Adresse '''192.168.0.55''', die Netzmaske '''255.255.255.0''' zugeteilt bekommt. Die beiden anderen Anweisungen sagen dem System, welches Netzwerkgerät der Router ist. In diesem Fall '''192.168.0.1'''.

Es ist darauf zu achten, was bisher vielleicht schon in der ''/etc/resolv.conf'' steht. Das lässt sich einfach mit ''cat /etc/resolv.conf'' ansehen. Wenn diese bereits den richtigen Inhalt hat, kann man die ''echo "nam...''-Anweisung weglassen. 
Wenn die resolv.conf nicht existiert oder einen falschen Wert enthält, '''überschreibt''' man diese, in dem man nur '''ein''' "''>''" nach das echo setzt. Stehen dort zwei "''>''" wird die nameserver-Info nur an die Datei angehängt und es kann zu Problemen kommen.

<pre> $ ifconfig eth0 192.168.0.55 netmask 255.255.255.0
$ route add default gw 192.168.0.1
$ echo "nameserver 192.168.0.1" > /etc/resolv.conf
</pre>

==== Benutzeraccounts ====

Linux legt wie alle Unix-artigen Betriebssysteme sehr grossen Wert auf eine ordentliche Benutzer- und Rechteverwaltung. 
Daher sollte man sich überlegen, ob es nicht vielleicht besser wäre, wenn man einen extra Benutzer zum Arbeiten/Basteln/Produktiv-Sein/Bier-Trinken/... anlegt. 
Wenn nicht unbedingt nötig, sollte man auf das Arbeiten als '''root''' (oder auch Superuser, Admin, ...) verzichten. Dadurch dass man uneingeschränkt '''alle''' Rechte auf dem System besitzt kann es durch Programmierfehler oder auch Schadsoftware zu ernsthaften Schäden kommen (Datenverlust, eventuell Hardwareschäden). 
Die Entscheidung ob man wirklich root sein muss, ist eigentlich relativ einfach. Sie wird normalerweise '''immer''' erstmal mit '''nein''' beantwortet. Sollte sich im Lauf der Zeit doch herausstellen, dass man root sein muss, kann man diesen Weg immer noch einschlagen. 
Für einige Aufgaben sind jedoch auch root-Rechte erforderlich.
Zum Beispiel, wenn man direkt mit outporb()/inportb()/outb()/inb()/... arbeiten will. 
Für diese Fälle gibt es ein gutes Tool, es nennt sich [http://de.wikipedia.org/wiki/Sudo sudo].
Man kann sudo z. B. sagen, dass Benutzer ''xy'' das Programm /usr/bin/blubb mit root-Rechten immer ausführen darf. Benutzer ''ab'' darf das aber nur, wenn er '''sein''' Passwort eingibt. Dann gibt es vielleicht noch Benutzer ''zz'', der alles ohne Passwort als root ausführen darf.

===== Anlegen eines neuen Benutzeraccounts =====
Ich gehe davon aus, dass ein Image mit busybox auf dem Board installiert ist. Wenn das Image von FriendlyARM installiert ist, ist das der Fall.

Ein Auszug aus der [http://linux.die.net/man/1/busybox Manpage] von busybox:
<pre>adduser
adduser [ OPTIONS ] user_name

Adds a user to the system

Options:

-h DIR Assign home directory DIR
-g GECOS Assign gecos field GECOS
-s SHELL Assign login shell SHELL
-G Add the user to existing group GROUP
-S create a system user (ignored)
-D Do not assign a password (logins still possible via ssh)
-H Do not create the home directory

</pre>

Heisst um einen Benutzer ''banana_joe'' mit dem Heimatverzeichnis ''/home/banana_joe'' anzulegen, muss man folgendes '''als root''' eingeben:
<pre> $ adduser -h /home/banana_joe -s /bin/sh banana_joe
$ passwd banana_joe
</pre>
''adduser'' legt den Benutzer an, ''passwd'' vergibt ein Passwort.

=== Übertragen von Daten/Programmen in den Flash-Speicher ===

Das übertragen gestaltet sich auf ganz unterschiedliche Weise. Aus Gründen der Einfachheit werde ich hier nur die sinnvollsten/einfachsten/schnellsten Wege beschreiben. Andere Möglichkeiten wären noch ''lrzsz'', USB und [[JTAG]].
Wer zuviel Zeit hat, kann sich ja auch ein eigenes Protokoll auf TCP/IP Ebene basteln oder den Kristallspeicher erfinden ;)

Wenn man eine Datei übertragen hat, muss man sich vergewissern, dass diese auch Ausführrechte besitzt, wenn sie ein Programm oder ein Ordner ist. Die Lese- und Schreibrechte müssen ebenfalls richtig gesetzt sein.
Normalerweise stimmt dies alles so wie es ist, aber manchmal muss man ein wenig nachhelfen.
Wenn sich ein Programm nicht ausführen lässt, oder man nicht in einen Ordner wechseln kann, fehlen die Rechte zum Ausführen. Geändert wird das so:
<pre> $ chmod +x <datei/ordner></pre>
Da hier aber nicht die Unix-Rechte erklärt werden sollen, verweise ich [http://linuxwiki.de/DateiRechte hierauf]

==== http ====
Für diese Methode muss natürlich das [http://www.mikrocontroller.net/articles/Mini2440#Netzwerk Netzwerk] eingerichtet sein. Man braucht auf einem PC im Netz einen laufenden Werbserver, auf den man die zu übertragenden Dateien legt.
Nun kann man diese in ein Verzeichnis seiner Wahl "herunterladen":
<pre> $ cd /tmp
$ wget http://10.2.5.29/datei
</pre>

==== ftp ====
Sobald auf dem Board ein FTP-Server läuft, kann man sich "ganz normal" mit einem FTP-Client (zum Beispiel '''gftp''' oder '''ncftp''') verbinden und die Dateien hochladen.
Ebenso kann man sich auch vom Board auf einen FTP-Server verbinden.
Nennenswerte Programme sind z.B. '''ftp''' für die Linux-Konsole, welches im FriendlyARM Image bereits enthalten ist oder der ncurses-basierende Client '''ncftp'''. Allerdings sollte man sich für ncurses-Programme per Telnet oder SSH einloggen, da die serielle Konsole nur rudimentäre Terminal-Emulation unterstützt und die Bildschirmausgabe nicht gerade schön wirkt.

==== scp/ssh ====
Dazu muss zuerst einmal ein SSH Server auf dem Board laufen.
[http://www.openssh.com openSSH] ist dafür die erste Wahl. Mit [http://matt.ucc.asn.au/dropbear/dropbear.html dropbear] gibt es einige Probleme, da man für SCP auch noch die SCP Binary von openSSH braucht.

Sobald der ssh server läuft, ist alles ganz einfach:
<pre>$ scp datei user@ziel:/pfad</pre>
Bei einem Board mit der IP 10.0.0.69 und dem User ''root'' wäre das die Befehlszeile:
<pre>$ scp datei root@10.0.0.69:/root</pre>
... und die Datei ''datei'' landet im Heimatverzeichnis von ''root''

Um nicht jedes mal das Passwort eingeben zu müssen, lohnt es sich SSH so zu konfigurieren, dass es mit [http://wiki.unixboard.de/index.php/SSH_ohne_Passwort Key-Files] läuft.

=== Toolchain ===
Toolchains gibt es im Netz und auf der CD/DVD zum Board mehrere fertig übersetzte - natürlich lässt sich die Toolchain auch selbst compilieren.
Das Risiko beim selbst compilieren einer Toolchain liegt darin, dass man eventuell einen fehlerhaften Compiler produziert.
Gründe hierfür sind z.B.:
* fehlende, wichtige Patches
* Verwenden von Entwicklerversionen mit eventuellen Bugs
* ein schon fehlerhafter Host-Compiler
* falsche Einstellungen (Prozessor-Architektur, Optimierung, ...)
 
Das sogenannte Bootstrappen eines Compilers erkennt solche Probleme in den meisten Fällen. Bootstrappen heißt, dass zuerst mit dem Host-Compiler der Quellcode des neuen übersetzt wird und mit diesem zweiten Compiler wird ein dritter Compiler übersetzt. Wenn dies klappt, kann man im Normalfall davon ausgehen, dass der dritte Compiler in Ordnung ist. 
Jedoch ist dies bei einem Crosscompiler so nicht möglich, da der zweite Compiler ja keinen Code für den Host-Computer, sondern nur für das Target produzieren kann. Somit würde man sich einen Compiler für das Board bauen. 
Wer auf Nummer sicher gehen will, nimmt am besten eine der bekannten ARM-Toolchains oder natürlich die von FriendlyARM.

==== old ABI / new EABI ? ====

'''ABI''' steht für '''''A'''pplication '''B'''inary '''I'''nterface'', also eine Art "Standard" wie das compilierte Programm, die Binärdatei, auszusehen hat.

Die ABI ist schon etwas älter und wurde von der EABI ('''''E'''mbedded '''A'''pplication '''B'''inary '''I'''nterface'') abgelöst.

Da nahezu jede verfügbare Toolchain auf der EABI aufbaut, würde ich diese auch nutzen. Alte, für die ABI, compilierte Programme, lassen sich mit der Kernel-Unterstützung zum Ausführen von ABI Programmen trotzdem noch verwenden.

Durch das verwenden der EABI entstehen normalerweise keine unüberwindbaren Hürden, beim compilieren von älteren Quellcodes. Jedenfalls nicht durch den Unterschied ABI/EABI.

==== Kernel FPE / softfloat ? ====

Irgendwann stolpert jeder, der mit ARM-CPUs und Linux arbeitet über mehrere Fragen.
* Was ist softfloat/FPE?
* Was ist schneller?
* Kann man beides nutzen?

'''Was ist softfloat/FPE''' 
Dadurch, dass eine ARM-CPU normalerweile keine [http://de.wikipedia.org/wiki/Gleitkommaeinheit Gleitkommaeinheit/FPU] besitzt, müssen alle Berechnungen, welche Kommazahlen enthalten in Software gelöst werden. Bei einem PC-System übernimmt diese Aufgabe eben die FPU und ist somit um einiges schneller. 
''softfloat'' ist die Umsetzung durch den Compiler. 
''FPE'' bedeutet '''''F'''loating '''P'''oint '''E'''mulation'' und wird durch den Kernel bereit gestellt. 

'''Was ist schneller''' 
Beim FPE-Verfahren wird der Code, welcher die Gleitkomma-Anweisungen enthält auch so übersetzt. Da die CPU aber keine [http://de.wikipedia.org/wiki/Gleitkommaeinheit FPU] besitzt und somit auch keine Maschinensprachen-Befehle dafür, wird eine ''Exception'' ausgelöst ("Fehler"), welche vom Kernel abgefangen wird. 
Nun steht der Kernel vor der Aufgabe, die Gleitkomma-Operation zu lösen und dem Programm das Ergebnis mitzuteilen. Danach muss er den Code für die Exception noch zu Ende führen und zurückkehren. 
Alles in allem eine sehr aufwendige Methode.

Da bei ''softfloat'' die Gleitkomma-Operationen vom Compiler soweit zerstückelt und wieder zusammengesetzt werden, dass gar keine Kommas mehr nötig sind, ist das in dem meisten Fällen flotter.

Das schnellste, ist natürlich eine Hardware-[http://de.wikipedia.org/wiki/Gleitkommaeinheit FPU], die es aber auf dem [[mini2440]] nicht gibt.

'''Kann man beides nutzen?''' 
Jein, wenn man im Kernel eine der beiden FPE-Methoden aktiviert hat und man führt ein softfloat-Programm aus, dann wird natürlich softfloat verwendet.
Wenn man allerdings ein FPE-Programm ausführen will und hat die Unterstützung nicht im Kernel, sieht es schlecht aus.

Also am besten eine FPE auswählen und mit einer softfloat-Toolchain compilieren. Das spart Zeit und Kopfzerbrechen über Invalid Opcode/Segfaults usw. ;)

==== Toolchain aufsetzen ====
Jenachdem, welche Toolchain man einsetzt, kann es sein, dass man den Compileraufruf anpassen muss.
Wenn man eine Cross Toolchain installiert hat und nur ''gcc'' auf der Kommandozeile eintippt, wird man höchstwahrscheinlich beim ''lokalen'' gcc, keinem Cross-Compiler, landen. Überprüfen kann man das mit
<pre> $ which gcc</pre>
Die FriendlyARM Toolchain macht es uns da sehr leicht, sie verwendet aussagekräftige Namen für ihre Programme. Bei ihr wäre der gcc Aufruf der:
<pre> $ arm-linux-gcc
oder
$ arm-none-linux-gnueabi-gcc
</pre>
Ich gehe im kompletten Artikel davon aus, dass man eine funktionierende Toolchain installiert hat, welche über ''arm-linux-...'' zu erreichen ist. Entweder passt man die gcc-Aufrufe von hier an, oder man kann sich auch [http://wiki.unixboard.de/index.php/ManPage:ln symbolische Links] anlegen.
Zum Schluss sollte das dann ungefähr so aussehen, vom bin-Pfad der Toolchain aus!
<pre> $ ls -al /usr/local/arm/4.3.2/bin/
...
lrwxrwxrwx 1 root root 25 2010-02-25 07:15 arm-linux-ld -> arm-none-linux-gnueabi-ld
...
</pre>
Ich selbst arbeite mit der FriendlyARM-Toolchain, werde mich hier also meistens auf diese beziehen, ausser anders vermerkt.
===== FriendlyARM =====
[http://www.friendlyarm.net/downloads Hier] als ''ARM-Linux-GCC'' zu finden.

Entpackt verbraucht diese Toolchain ca. 295MB. Mit ihr liessen sich bei mir bereits der Kernel, uboot, sowie zahlreiche Programme kompilieren.

Zuerst wird die Toolchain an die richtige Stelle entpackt, der Pfad mit angegeben und dann ist sie auch schon bereit.
Dieses Kommando sieht auf den ersten Blick etwas nach Dateisystem-Apokalypse aus, ist allerdings lage nicht so wild. Die Option ''-C /'' sagt, dass direkt ins Wurzelverzeichnis entpackt werden soll, daher benötigt man für diesen Schritt '''root-Rechte'''. Die FriendlyARM-Toolchain ist so aufgebaut, dass sie damit nach ''/usr/local/arm/4.3.2/'' entpackt wird, '''unser Ziel''' :) Die Version mit dem gcc 4.4.3 wird nach /opt/FreindlyArm/toolschain/4.4.3 entpackt. Die Pfade sind also entsprechend anzupassen.
<pre> $ tar xvfj arm-linux-gcc-4.3.2.tar.gz -C /
</pre>
Wenn wir das nun so haben, müssen wir natürlich auch noch sagen, wo er den Compiler findet.
Dazu öffnet man am besten seine "autorun-Datei" der Shell. In der Konsole ganz einfach mit vim/nano/etc zu erreichen.
<pre> $ vim /home/user/.bashrc</pre>
Dort tragen wir dann '''ganz ans Ende''' dies ein:
<pre>export PATH=$PATH:/usr/local/arm/4.3.2/bin</pre>
Kaum gespeichert, startet man eine neue shell (Konsole) und überprüft ob die Pfade stimmen.
Wenn ''/usr/local/arm/...'' im Pfad enthalten ist, müsste alles stimmen.
<pre> $ echo $PATH</pre>
Tippt man nun '''nur''' ''arm-'' und drückt zweimal die Tabtaste, so müsste eine ellenlange Liste mit Programmen wie z. B. ''arm-linux-gcc'' oder ''arm-linux-ld'' erscheinen.
<pre> $ arm-linux-gcc -v</pre>

===== codesourcery =====
[http://www.codesourcery.com/sgpp/lite/arm/portal/package3696/public/arm-none-linux-gnueabi/arm-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 codesourcery arm-none-linux-gnueabi]

===== buildroot =====

Von http://www.buildroot.net das letzte stable Release holen, mini-2440 wird unterstützt. Der Build dauert zwar einige Zeit, aber nacher kann man sich an X11 erfreuen.

===== PTXdist =====

PTXdist ist ähnlich wie BuildRoot und unterstützt das Mini2440 seit der Version 2011.05.0. PTXdist verwendet Barebox(UBoot-V2) als Bootloader. Die Projektseite zu dem Mini ist unter http://www.oselas.org/oselas/bsp/pengutronix/mini2440_bsp_en.html zu finden.

Wichtige Links:
* [http://www.oselas.org/oselas/bsp/pengutronix/download/OSELAS.BSP-Pengutronix-Mini2440-Quickstart.pdf Quickstart Guide geschrieben für das Mini]
* [http://www.oselas.org/software/ptxdist/download/ PTXdist Downloadverzeichnis]
* [http://www.pengutronix.de/oselas/toolchain/download/ OSELAS Toolchain Downloadverzeichnis]
* [http://www.oselas.org/oselas/bsp/pengutronix/download/ Projektdateien für das Mini]
* [http://www.oselas.org/software/ptxdist/appnotes/OSELAS.BSP-Pengutronix-Generic-arm-Quickstart.pdf How to become a PTXdist Guru] - Erklärung wie z.B. eigene Packete erstellt werden können

=== Cross Compiling ===
Sobald die Toolchain richtig aufgesetzt ist kann man anfangen, seine Programme zu übersetzten.

Hier folgt nur eine kurze Beschreibung, wer sowas genauer wissen will, sollte sich auf Seiten wie diesen umsehen:
* http://www.ailis.de/~k/archives/19-ARM-cross-compiling-howto.html
* http://linux.bytesex.org/cross-compiler.html
Ausserdem findet man zu vielen embedded-nutzbaren Programmen direkt ein Cross-Compiling Howto mit ein wenig google.
Ob diese nun für ARM, AVR32, PPC, MIPS, ... sind, ist im Grunde egal, da man ja meistens nur die Architektur anpassen muss.

Es gibt mehrere Möglichkeiten. Die erste ist der direkte Aufruf vom Compiler oder mittels eines "festen" Makefiles. Die zweite, wahrscheinlich Häufigste, ist das ausführen eines configure-Scriptes bevor der make-Vorgang gestartet wird.

* Das einfache aufrufen des Compilers
Dazu ein einfaches Hello-World Programm:
<c>
#include <stdio.h>

int main() {
printf("hiho\n");
}
</c>

Compiliert wird das Programm ganz einfach so:
<pre>$ arm-linux-gcc <name.c> -o <name></pre>
Danach wird die Datei ''<name>'' an das Board [http://www.mikrocontroller.net/wikisoftware/index.php?title=Mini2440&action=submit#.C3.9Cbertragen_von_Daten.2FProgrammen_ins_Flash übertragen].
Sobald ''<name>'' auf dem Board ist, kann es ausgeführt werden:
<pre> $ ./<name></pre>
Eventuell fehlen die Rechte:
<pre> $ chmod +x <name></pre>

* ./configure-Scripte
Hier sieht es schon ein klein wenig schwieriger aus, ist es aber eigentlich nicht.
''Normalerweise'', aber '''nicht immer''', sieht das compilieren eines Programms für das mini2440 so aus:
<pre> $ HOST=arm-linux ARCH=arm ./configure --build=arm-linux --your-options
$ make
</pre>
Man muss dem configure-Script lediglich angeben, für welche Architektur das Makefile konfiguriert werden soll und welchen Compiler er dafür nehmen soll.

=== Linux-Kernel ===

Den Kernel-Quellcode besorgt man sich am besten den Kernel-Fork von buserror. Wenn man nicht auf dem ARM selber kompilieren möchte, benutzt man wie hier im Beispiel einen Cross-Compiler (Siehe oben). Weiterhin wird noch git benötigt, um den Kernel-Quellcode zu laden. Folgende Einstellungen werden im Abschnitt verwendet:
<pre> Verzeichnis: /mnt/mini2440
CHOST/CROSS-COMPILE: arm-softfloat-linux-gnueabi
</pre>
Starten wir damit, den Quellcode zu laden:
<pre> $ cd /mnt/mini2440
$ git clone git://repo.or.cz/linux-2.6/mini2440.git linux-2.6.32-rc8</pre>
Dann ab ins Kernel-Verzeichnis und den Kernel mit den Defaults konfigurieren:
<pre> $ cd linux-2.6.32-rc8
$ CROSS_COMPILE=arm-softfloat-linux-gnueabi- ARCH=arm make mini2440_defconfig</pre>
Wenn man noch etwas manuell ändern möchte:
<pre> $ CROSS_COMPILE=arm-softfloat-linux-gnueabi- ARCH=arm make menuconfig</pre>
Den Kernel anschließend kompilieren:
<pre> $ CROSS_COMPILE=arm-softfloat-linux-gnueabi- ARCH=arm make</pre>
Die Module bekommen wir wie folgt nach /mnt/mini2440/lib/modules installiert:
<pre> $ CROSS_COMPILE=arm-softfloat-linux-gnueabi- ARCH=arm INSTALL_MOD_PATH=/mnt/mini2440 make modules_install</pre>
Wenn wir mit u-boot arbeiten, dann benötigen wir das zImage in /mnt/mini2440/kernel-2.6.32-rc8/arch/arm/boot, um daraus mittels mkimage (Siehe uboot) ein uImage zu erstellen.
 
'''Kernel-Parameter''' 
dem Kernel kann man zum Start noch Parameter für das Board mitgeben:
<pre>mini2440=[0..9][t][b]</pre>
[0..9] bestimmen die Display-Timings (varieren je nach verwendetem Kernel)
* 0 3,5" Display N35 + TS (alt);
* 1 7" Display + TS;
* 2 VGA-Board;
* 3 3,5" Display T35 + TS;
* 4 5,6" Display Innolux + TS;
[t] Touchscreen ist vorhanden; 
[b] Backlight ist vorhanden;

=== root-fs ===
Um ein eigenes Root-Filesystem zu compilieren, gibt es mehrere Möglichkeiten.

Die einfachsten sind Cross-Umgebungen wie [http://buildroot.uclibc.org/ buildroot] und [http://wiki.openembedded.net/index.php/Main_Page openembedded].

==== Debian ====
Auch relativ einfach ist es, sich ein fertig compiliertes debian-arm zu installieren. Wenn man das Debian einmal auf seiner SD-Karte laufen hat, ist es kein Problem mehr, alles wie gewohnt mit apt zu installieren usw. usw. 
Allerdings sind gerade die Scripte bei Debian noch nie dafür bekannt gewesen sonderlich schnell zu laufen und es ist sehr sehr träge beim booten.

Ich habe auf meinem mini2440 seit einiger Zeit Debian am Laufen, habe aber sämtliche Init-Scripte durch eigene ersetzt, welche um einiges flotter laufen. Ebenso verzichte ich auf sysvinit und damit aber auch auf sehr nützliche Tools/Funktionen, wie die runlevels und shutdown oder reboot.
Diese Funktionen müssen auch von meinen eigenen Scripten übernommen werden. Dafür läuft es um einiges schneller.

[http://emqbit.com/deboostrap-debian Hier] eine Anleitung für ein AT91-Linux Board mit Debian. Diese kann fast 1:1 übernommen werden.

Mit X11, Lighttpd, PHP, Python, mc, vim, mpd, alsa, gcc, ... (und auch apache als leidige Abhängigkeit von PHP) braucht mein Debian etwa 550MB auf der SD-Karte.
Schon ein ordentlicher Brummer, aber egal, es bootet mit eigenen Scripten innerhalb von 15 Sekunden.

==== Gentoo ====
Ooooh wer daran denkt, hat einfach nur zuviel Zeit. Gentoo in allen Ehren, aber allein PHP zu compilieren dauert gut 4 Stunden... danach habe ich es aufgegeben.

Wer Gentoo installieren kann, wird sich auf dem Mini2440 auch nicht schwerer tun, als auf einem PC. Der Unterschied besteht nur darin, dass man die Stage auf SD Karte packen muss, am normalen Rechner natürlich, und dort dann schon die wichtigsten Einstellungen vornehmen muss.

Mit Portage und den ganzen Dev-Files ist Gentoo ein riesen Gebilde für so ein schwachbrüstiges Board. Eine 4GB SD-Karte ist das Minimum. Außer man bootet zuerst in den Flash und dann chrootet man auf ein Gentoo auf einer USB-Festplatte. uboot kann das, soweit ich weiß, nicht.

=== sys-fs ===
Sysfs ist ein virtuelles Dateisystem, welches seit dem Linux Kernel 2.6. zur Verfügung gestellt wurde. Der Kernel stellt dabei Konfigurationen, Informationen über Vorrichtungen und Treiber im sogenannten userspace zur Verfügung. Dies Bedeutet einfach, dass Informationen/Geräte an einer festgelegten Stelle im Dateisystem stehen und ausgelesen oder beschrieben werden können.

Über einige Dateien in diesem Dateisystem können GPIOs und z.B. auch LEDs angesteuert werden.

=== Framebuffer ===
Der Framebuffer ist von Haus aus im FriendlyARM Kernel aktiviert und ohne ihn lässt sich im Linux keine Ausgabe auf dem Display realisieren. Er ist unter ''/dev/fb0'' zu erreichen. 
In der Kernelkonfiguration muss die Framebuffer-Konsole und der Framebuffer-Treiber für das jeweilige Display gewählt werden.

Eine Textausgabe geht ganz einfach über das Terminal, welche auf ihn gemappt ist:
<pre>$ echo "hello world" > /dev/tty1</pre>

Man kann dem Framebuffer diverse Argumente mitgeben, die die Ausgabe auf dem Display beeinflussen. Diese werden über ''fbcon=...'' angeben. Man kann auch mehre Argumente angeben, das sähe zum Beispiel so aus:
<pre>
root=/dev/mmcblk0p1 console=ttySAC0 fbcon=rotate:1 fbcon=scrollback:0
</pre>

Alternativ können mehrere fbcon-Parameter auch durch Komma getrennt werden:
<pre>
... fbcon=rotate:1,scrollback:0
</pre>

Der Scrollback-Buffer ist auf diesem Display eigentlich nicht nötig, da man hier auf dem Mini2440 auf keiner Konsole mit Tastatur usw. arbeitet. Daher schaltet man ihn mit ''fbcon=scrollback:0'' ab, das spart gegenüber dem Standardwert 32kB RAM. 
Wer ihn doch benötigt, kann ihn natürlich trotzdem verwenden. Die Zahl nach dem Doppelpunkt steht für die Größe in Bytes. Ein ''k'' als Suffix steht für Kilobyte, ''fbcon=scrollback:1024k'' entspräche einem Scrollback-Buffer von 1MB.

Für die FB-Konsole gibt es einige weitere Möglichkeiten und viele Optionen lassen sich zur Laufzeit ändern. Hier habe ich nur das Wichtigste beschrieben. Wer darüber mehr erfahren will, sollte sich im Kernel-Quellcode die Datei ''Documentation/fb/fbcon.txt'' ansehen.

==== Font wählen ====
Die voreingestellte VGA8x16 Font ist etwas groß und es passt nicht allzuviel Text auf das Display. Die am besten lesbare, kleine Schrift ist die Mac6x11 Font.
In menuconfig folgendes einstellen:
<pre>
-> Device Drivers
-> Graphics support
-> Console display driver support
-> Select compiled-in fonts
<*> Framebuffer Console support
[*] Map the console to the primary display device
[*] Framebuffer Console Rotation
[*] Select compiled-in fonts
[ ] VGA 8x8 font
[ ] VGA 8x16 font
[*] Mac console 6x11 font (not supported by all drivers)
[ ] console 7x14 font (not supported by all drivers)
[ ] Pearl (old m68k) console 8x8 font
[ ] Acorn console 8x8 font
[ ] Mini 4x6 font
[ ] Sparc console 8x16 font
[ ] Sparc console 12x22 font (not supported by all drivers)
[ ] console 10x18 font (not supported by all drivers)
</pre>
Werden mehrere Fonts eincompiliert, können sie so ausgewählt werden:
<pre>
(Kernel-Commandline)
... fbcon=font:xxxx
</pre>
Mögliche Werte für ''xxxx'' sind:
* VGA8x8
* VGA8x16
* Mac6x11
* 7x14
* 10x18
* MINI4x6
* RomanLarge
* SUN8x16
* SUN12x22
* ProFont6x11
* Acorn8x8
* PEARL8x8

Bei machen Fonts steht in der Kernel-Menuconfig ''not supported by all drivers''. Dies erklärt sich so:
<pre>
Note, not all drivers can handle font with widths not divisible by 8,
such as vga16fb.
kernel-src/Documentation/fb/fbcon.txt
</pre>
Manche Treiber können nicht mit Fontbreiten/-höhen umgehen, welche nicht durch 8 teilbar sind. Da aber z.B. die MAC6x11 Font auch nicht durch 8 teilbar ist und das Mini2440 das anzeigen kann, gehe ich davon aus, dass alle funktionieren.

==== Rotation ====
Um das Display zu "drehen" folgendes einstellen:
<pre>
-> Device Drivers
-> Graphics support
-> Console display driver support
-> Framebuffer Console support
[*] Framebuffer Console Rotation
</pre>
Also Kernel-Parameter im Bootloader dann einstellen:
<pre>
fbcon=rotate:x
</pre>
Für ''x'' sind Werte von 0 bis 3 gültig. Jeweils wird um 90° im Uhrzeigersinn weitergedreht.

''Hinweis:'' 
Die Rotation bezieht sich '''nur''' auf den Framebuffer. Ein anschließend gestartetes Qtopia (z.B.) bleibt von der gewählten Einstellung unberührt.
In eigenen Anwendungen, welche eine grafische Oberfläche bereitstellen, lässt sich die Rotation allerdings verwenden, indem man einfach die Datei '''/proc/cmdline''' ausliest und den dort gegebenen Wert verwendet, um seine Bildschirmausrichtung anzupassen.

=== Bootloader ===
Die beiden verfügbaren Bootloader sind vivi (ein "standard-s3c24xx-Linux-Bootloader") und u-boot, '''der''' Bootloader für embedded-Systeme schlechthin ;)

Gemeinsam haben sie eigentlich nur, dass sie '''a)''' funktionieren und '''b)''' einen Linux-Kernel laden können. 
Der große Nachteil von vivi ist, dass es nur mit [http://en.wikipedia.org/wiki/YAFFS YAFFS2]-Dateisystemen umgehen kann, die auf dem onboard-Flash liegen müssen.
Sobald der Kernel geladen ist, ist das kein Problem mehr, doch der Kernel muss eben im Flash liegen. 
Um nun z. B. von USB-Festplatten/Sticks und SD-/MMC-Karten booten zu können, muss also u-boot installiert werden.

'''WARNUNG: An einem Bootloader herumzuspielen, kann sehr böse ausgehen, etwa mit dem unbootbar-mach-Vorgang, der durch zu wenig Nachdenken ausgelöst wird.
Das mini2440 lässt sich zwar jederzeit per JTAG mit LPT-Adapter zurückholen, ist doch aber eigentlich unnötig ;)'''

==== uboot ====

Der Bootloader uboot wurde von "buserror" soweit an das mini2440 angepasst, dass er mehr oder weniger läuft.
Für die verschiedenen Boards gelten also auch leicht verschiedene Anweisungen um uboot ins Wasser zu bekommen.

Das git und die Seite von "buserror" ist [http://code.google.com/p/mini2440/ hier] zu finden.

Boards:
* 64MB
* 128MB
* 256MB
** [[Datei:mini2440.h]]
** [[Datei:uboot.bin]]
* 1GB

Den u-boot-Fork von buserror laden wir am besten mit git. Weiterhin benötigen wir einen Cross-Compiler (Siehe oben). Die letzte mir bekannte Version des GCC mit dem sich das "U-Boot" kompilieren lässt ist 4.3.4. Folgende Einstellungen werden im Abschnitt verwendet:
<pre> Verzeichnis: /mnt/mini2440
CHOST/CROSS-COMPILE: arm-softfloat-linux-gnueabi
</pre>
Starten wir damit, den Quellcode zu laden:
<pre> $ cd /mnt/mini2440
$ git clone git://repo.or.cz/u-boot-openmoko/mini2440.git u-boot</pre>
Dann ab ins Source-Verzeichnis und mit den Defaults für das Mini2440 konfigurieren:
<pre> $ cd u-boot
$ CROSS_COMPILE=arm-softfloat-linux-gnueabi- make mini2440_config</pre>
Wenn man noch etwas manuell ändern möchte, dann die Datei include/configs/mini2440.h bearbeiten, z. B. für das Mini2440-256MB:
<pre> #define USE_920T_MMU 1
//#define CONFIG_USE_IRQ 1 /* Needed for USB device! */
</pre>
(CONFIG_USE_IRQ auskommentieren, damit das Mini2440 u-boot aus dem RAM ausgeführt werden kann. Leider kann man dann im "U-Boot" kein USB-Gerät mehr ansprechen, um ggfl. mal wieder aufzutauchen). 
Zusätzlich kann man noch defaults für das Environment (bootargs, ip, ...) festlegen.
 
Anschließend das "U-Boot" kompilieren:
<pre> $ CROSS_COMPILE=arm-softfloat-linux-gnueabi- make</pre>
 
Im Verzeichnis tools findet man mkimage. Damit kann man aus einem zImage (Linux-Kernel) ein uImage machen. Dieses uImage lässt sich von u-boot aus laden (Nand, NFS, TFtp, MMC) und ausführen.
<pre> mkimage -A arm -O linux -T kernel -C none -a 0x30008000 -e 0x30008000 -d path-to/zImage path-to/uImage</pre>
Jetzt haben wir ein von u-boot ausführbaren Linux-Kernel.

== Multimedia ==

=== Abspielen von Audio-Daten ===
Mit dem FriendlyARM-Image gibt es zwei Möglichkeiten Audio-Dateien abzuspielen. Die Eine ist, Qtopia zu starten und dort einfach die Datei von SD-Karte, USB, ... auszuwählen und er spielt sie ab.

Die andere ist, die Datei auf der Konsole mit ''madplay dateiname.mp3'' abzuspielen. [http://www.digipedia.pl/man/doc/view/madplay.1/ Hier] die Manpage zu madplay.

==== MPD - der Music Player Daemon ====
Mit einem eigenen Image oder wenn man sich alles von Hand compilieren will ist der [http://www.musicpd.org/ Music Player Daemon] ein genialer Musik-Player. Er lässt sich durch sehr sehr viele verschiedene Clients steuern und braucht dabei nahezu kaum Rechenleistung. 
Der eigentliche Player läuft vollkommen "versteckt" im Hintergrund. Um ihn zu steuern wird vom Client eine Verbindung aufgebaut und die entsprechenden Befehle gesendet. 
Die Clients müssen noch nicht einmal auf dem Board laufen, können auch auf jedem anderen Rechner im Netzwerk oder Internet sein. Man muss einfach nur die IP und den Port angeben.

Mit gerade mal etwa 100 Zeilen Code lässt sich eine einfach zu nutzende Client-Lib in C programmieren um dann seine eigenen Clients zu schreiben. Damit lässt sich der MPD durch so ziemlich jedes Ereignis an einem Rechner steuern.
[[MPD Client Programming|hier]] habe ich einen Artikel erstellt, der das wichtige dafür beschreibt.

=== Aufnehmen von Audio-Daten ===
=== Abspielen von Video-Daten ===

Ich selbst habe noch keinen Player, bis auf den vom originalen Image mit Qtopia gesehen/compiliert, welcher Filme einigermaßen flüssig abspielt.

Mein Ansatz momentan ist, den MPlayer mit fbdev, directfb und sdl mit Framebuffer Ausgabe direkt auf den Framebuffer schreiben zu lassen.
Allerdings habe ich damit bisher nur sehr sehr magere Ergebnisse gehabt.

=== Kamera-Interface ===

== Hardware ==
Nahezu alles ist über die verschiedenen Header auf dem Board zu erreichen
=== Pinouts ===
[[Bild:mini2440_pinout.jpg|450px]]
{| class="wikitable"
|+ '''Audio / UART'''
|-
! Pin || Audio IN || CON1, CON2, CON3 || CON8 || J1 (ext. NAND/NOR-sw)
|-
| 1 || IN || TX || VIN || NORBOOT
|-
| 2 || GND || RX || GND || OM0
|-
| 3 || IN || 5V || GND || NANDBOOT
|-
| 4 || || GND || VDD5V||
|}

{| class="wikitable"
|+ '''CON4 GPIO, CON5'''
|-
! Pin || CON5 || CON4 GPIO || CAMERA || CON12 || JTAG
|-
| 1 || 5V || 5V || SDA || EINT8/GPG0 || 3.3V
|-
| 2 || GND || 3.3V || SCL|| EINT11/GPG3 || 3.3V
|-
| 3 || EINT17|| GND || EINT20|| EINT13/GPG5 || /TRST
|-
| 4 || EINT18|| /RESET || CAMRST|| EINT14/GPG6 || /RESET
|-
| 5 || EINT3|| AIN0 || CAM_CLOCK|| EINT15/GPG7 || TDI
|-
| 6 || EINT9|| AIN1 || CAM_HREF|| EINT19/GPG11 || TDO
|-
| 7 || /GCS1|| AIN2 || CAM_VSYNC|| 3.3V || TMS
|-
| 8 || /GCS2 || AIN3 || CAM_PCLK|| GND || GND
|-
| 9 || /GCS3 || EINT0 || CAMDATA7|| ||TCK
|-
| 10 || /GCS5|| EINT1 || CAMDATA6|| ||GND
|-
| 11 || L/OE|| EINT2 || CAMDATA5
|-
| 12 || L/WE|| EINT3 || CAMDATA4
|-
| 13 || /WAIT|| EINT4 || CAMDATA3
|-
| 14|| /RESET|| EINT5 || CAMDATA2
|-
| 15 || /XDACK0|| EINT6 || CAMDATA1
|-
| 16 || /XDREQ0|| EINT8 || CAMDATA0
|-
| 17 || LADDR0|| EINT9 || 3.3V
|-
| 18 ||LADDR1|| EINT11 || VDDCAM
|-
| 19 ||LADDR2|| EINT13 || 1.8V
|-
| 20 ||LADDR3|| EINT14 || GND
|-
| 21||LADDR4|| EINT15 ||
|-
| 22||LADDR5|| EINT17 || ||
|-
| 23||LADDR6|| EINT18
|-
| 24||LADDR24|| EINT19
|-
| 25||LDATA0||MISO
|-
| 26||LDATA1||MOSI
|-
| 27||LDATA2||CLOCK
|-
| 28||LDATA3||SS
|-
| 29||LDATA4|| SCL
|-
| 30||LDATA5|| SDA
|-
| 31||LDATA6||GPB0
|-
| 32||LDATA7||GPB1
|-
|33 ||LDATA8||CLKOUT0
|-
| 34 ||LDATA9||CLKOUT1
|-
| 35||LDATA10
|-
|36 ||LDATA11
|-
| 37 ||LDATA12
|-
| 38 ||LDATA13
|-
| 39 ||LDATA14
|-
| 40 ||LDATA15

|}

=== Steckverbinder ===
Digi-Key:
{| class="wikitable"
! Connector || Hersteller || Artikelnummer || Teilenummer
|-
| CON1,2,3,8 || JST Sales America Inc || PHR-4 || [http://search.digikey.com/scripts/DkSearch/dksus.dll?keywords=455-1164-ND 455-1164-ND]
|-
| Audio IN, J1 || JST Sales America Inc || PHR-3 || [http://search.digikey.com/scripts/DkSearch/dksus.dll?keywords=455-1126-ND 455-1126-ND]
|-
| || JST Sales America Inc || SPH-002T-P0.5L || [http://search.digikey.com/scripts/DkSearch/dksus.dll?Detail&name=455-2148-1-ND 455-2148-1-ND]
|-
| CON4 || Sullins Connector Solutions || SFH213-PPPN-D17-ID-BK-M181 || [http://search.digikey.com/scripts/DkSearch/dksus.dll?keywords=S9061-ND S9061-ND]
|-
| || Sullins Connector Solutions || SBH21-NBPN-D17-ST-BK || [http://search.digikey.com/scripts/DkSearch/dksus.dll?keywords=S9023-ND S9023-ND]

|}

==== onboard Hardware ====
Sobald man mal anfangen möchte, sich mit der Hardware auseinanderzusetzen, sollte man natürlich auch wissen wie, was und wo dran.

''... an welchem EINT war ... Low oder High aktiv? ...''

[[Bild:mini2440_eeprom.jpg||300px]][[Bild:mini2440_buttons.jpg||300px]][[Bild:mini2440_leds.jpg||300px]][[Bild:mini2440_poti.jpg||300px]]
[[Bild:mini2440_buzzer.jpg||300px]]

=== [[UART]] ===
Die S3C2440 besitzt insgesamt drei unabhängige UARTs.

'''Die Spannungspegel der Rx und Tx Pins sind etwas verwirrend. Auf dem Stecker liegen 5V an, doch das Datenblatt sagt nicht, ob die Rx und Tx Pins auch 5V-Tolerant sind. Daher sollte man das ausschliessen. Ein Spannungsteiler aus 3k3 und 2k2 an der Rx-Leitung vom Prozessor sollte das Problem beheben, solange der Empfänger an der Tx-Leitung 3.3V noch als H-Signal versteht.'''

{| class="wikitable"
|+ '''UARTs'''
|-
! UART || 64 byte FIFO || IrDA 1.0 || RTS/CTS Leitungen|| Spannungspegel (L - H)
|-
| uart0 || * || * || * || 0V - 3,3V / RS232
|-
| uart1 || * || * || * || 0V - 3,3V
|-
| uart2 || * || * || x || 0V - 3,3V
|}

Über die Ansteuerung auf Hardwareebene braucht man sich, solange man ein Betriebssystem verwendet, '''keine''' Gedanken zu machen.
Unter Linux sind die drei UARTs über ttySAC0, ttySAC1 und ttySAC2 zu erreichen.

=== [[LED|LEDs]] ===
Wenn der Kerneltreiber für die LEDs mit eincompiliert wurde, ist es ein leichtes, die LEDs mit einer kleinen Hand voll C-Zeilen anzusprechen.

Man öffnet die Gerätedatei und mittels ''ioctl()'' schreibt man die Werte in die Gerätedatei.

Der Aufruf von ioctl sieht so aus:
<c>
ioctl(descriptor, AN/AUS, LED_NUMMER);
</c>
Also muss man um zum Beispiel LED0 anzuschalten für AN/AUS '''1''' angeben und für LED_NUMMER die '''0'''.
Dafür habe ich im Abschnitt C-Code zwei Beispiel-Funktionen geschrieben. Die erste erwartet AN/AUS und LED_NUMMER als Argument, die Zweite erwartet eine Bitmaske, was mir persönlich doch besser gefällt ;)

==== C-Code ====
<c>int setleds(int on, int led_no) {
int led_fd = open("/dev/leds0", 0);
if (led_fd < 0) { led_fd = open("/dev/leds", 0); }
if (led_fd < 0) { perror("open device leds"); return(-1); }

ioctl(led_fd, on, led_no);

close(led_fd);
return 0;
}

int setledmask(int mask) {
int led_fd = open("/dev/leds0", 0);
if (led_fd < 0) { led_fd = open("/dev/leds", 0); }
if (led_fd < 0) { perror("open device leds"); return(-1); }

if(mask & 0x01) ioctl(led_fd, 1, 0); else ioctl(led_fd, 0, 0);
if(mask & 0x02) ioctl(led_fd, 1, 1); else ioctl(led_fd, 0, 1);
if(mask & 0x04) ioctl(led_fd, 1, 2); else ioctl(led_fd, 0, 2);
if(mask & 0x08) ioctl(led_fd, 1, 3); else ioctl(led_fd, 0, 3);

close(led_fd);
return 0;
}
</c>

==== LED-sysfs ====
Bei aktiviertem sys-fs Kerneltreiber für LEDs, kann man diese im Verzeichnis '/sys/class/leds/' finden und ansteuern.
<pre>
cd /sys/class/leds/ # wechselt in den Ordner
ls -lsa # listet alle Vorhandenen LEDs auf
echo 1 > led4/brightness # LED AN
echo 0 > led4/brightness # LED AUS
# oder
echo 1 > /sys/class/leds/led4/brightness # LED AN
echo 0 > /sys/class/leds/led4/brightness # LED AUS
</pre>

=== [[I2C]] ===
==== i2ctools ====
Die [http://www.lm-sensors.org/wiki/I2CTools i2ctools] sind Linux-Userspace Programme, welche dafür gedacht sind, auf einfache Weise auf der Konsole mit I2C Geräten zu kommunizieren.
==== 24xx [[EEPROM]]s ====
==== [[Port-Expander]] ====
===== PCF8574 / PCF8574a =====
Einen [[PCF8574]] anzusteuern ist sehr einfach. Mit den i2ctools kann man damit erste Tests machen um zu sehen, ob er funktioniert.

Der Port-Expander wird mit den 3.3V versorgt, welche das Board liefert, SDA und SCL natürlich ebenfalls anschliessen.
Ich habe alle drei Adress-Pins auf '''L''' gelegt und erhalte von ''i2cdetect'' so die Adresse '''0x38'''.

=== [[SPI]] ===
=== [[PWM]] ===
==== onboard buzzer ====
=== [[ADC]] ===
==== Touchscreen ====
Wenn der Kernel-Treiber installiert ist, kann der Touchscreen wie z. B. jede Maus über das event-Interface angesprochen werden.
Normalerweise liegt der Touchscreen auf ''/dev/input/event0''.
Diese Gerätedatei muss man auch der tslib angeben.

==== LCD Backlight ====
Wenn der Kernel-Treiber installiert ist, kann die Hintergrundbeleuchtung des Displays einfach über die entsprechende Geräte-Datei ein- bzw. ausgeschaltet werden. 
einschalten: <pre># echo 1 > /dev/backlight</pre>
ausschalten: <pre># echo 0 > /dev/backlight</pre>

==== onboard Poti ====
Hierzu muss wieder der Kerneltreiber mit eincompiliert sein, damit man das Gerät ''/dev/adc'' hat. Im FriendlyARM-Kernel ist der Treiber fest mit drin.

Die Funktion getpoti() liest in einer Schleife mehrmals den Potiwert ein und bildet einen Mittelwert, der zurückgegeben wird.
Die Anzahl der Werte, aus denen der Mittelwert gebildet wird, wird mit dem #define ''LOOPs'' angegeben.
===== C-Code =====
<c>
#define LOOPS 12 // 12 Werte fuer Mittelwert

unsigned int getpoti() {
int value, i, fd = open("/dev/adc", 0);
unsigned int add = 0, ret;
if (fd < 0) { printf("cant open adc device!\n"); return -1; }

for(i = 0; i < LOOPS; i++) {
char buffer[30];
int len = read(fd, buffer, sizeof buffer -1);
if (len > 0) {
buffer[len] = '\0';
value = -1;
sscanf(buffer, "%d", &value);
add += value;
} else {
printf("cant read from adc device!\n");
close(fd);
return -1;
}
}
close(fd);
ret = add / LOOPS;
return ret;
}
</c>

=== GPIO ===
Da der S3C2440 über sage und schreibe '''130''' GPIOs verfügt, mit diversen Funktionen, wie I2C, PWM, ..., das setzen der "Drive Strength" (maximaler Strom an machen Pins), ... ist das Ganze nicht mehr so einfach wie bei einem AVR.
Der Bastler sollte hier schon genau wissen was er will vorallem das [[Media:S3C2440_datasheet_samsung.pdf|Datenblatt]] zu Rate ziehen.
Die Funktionen und Register des Chips sind ab Seite '''274''' (Kapitel ''IO-Ports'') zu finden.
Die elektrischen Daten sind ab Seite '''554''' zu finden.

==== C-Code für die onboard-Buttons ====
Hierfür wird wird der Kerneltreiber benötigt. Im FriendlyARM-Kernel ist dieser fest mit drin.

Wenn die Buttons eingelesen werden, erhält man für jeden nicht gerdrücken Buttons ''0x30'' und für jeden gedrückten Button ''0x31''.
Die Funktion liest die Buttons ein und vergleicht den Wert, sobald 0x31 kommt, ist sie beendet. Die Buttons sind von 0 bis 5 nummeriert.

<c>
int wait4button(int button) {
char btn[6] = {'0', '0', '0', '0', '0', '0'};
int fd = open("/dev/buttons", 0);
if (fd < 0) { printf("cant open buttons device"); return(-1); }

while(btn[button] == 0x30) { // if a button is released, we read 0x30, if pressed 0x31
if (read(fd, btn, sizeof btn) != sizeof btn) {
printf("cant read buttons!");
close(fd);
return(-1);
}
}
close(fd);
return 0;
}</c>

==== GPIO-sysfs ====
Bei aktiviertem sys-fs Kerneltreiber für GPIOs, kann man diese im Verzeichnis '/sys/class/gpio/' finden und ansteuern. Eine gute Erklärung ist dazu [http://www.avrfreaks.net/wiki/index.php/Documentation:Linux/GPIO#gpio-sysfs hier] zu finden.

=== Real Time Clock ===
Für die Real Time Clock, welche fest im Prozessor integriert ist, gibt es einen Kerneltreiber.

Lesen/Setzen lässt sich sich sehr einfach mit dem Tool [http://linux.die.net/man/8/hwclock hwclock].
=== Beispielprogramme ===

Hier habe ich ein paar kleine Beispielprogramme im Quellcode hochgeladen.

* [[Media:led_adc.c]] Herzschlag auf den LEDs, Geschwindigkeit mit Poti einstellen. Compilieren mit ''arm-linux-gcc led_adc.c -o led_adc''.

== Andere Betriebssysteme ==

=== uCos2 ===
=== Windows CE ===
=== FreeRTOS ===
=== emdedian ===

== Software mit Betriebssystem ==
* Grafische Oberfläche mit der SDL-Bibliothek erstellen: [[Mini2440 SDL GUI Programmierung]]

== Software ohne Betriebssystem ==

=== Entwicklungsumgebung ===
=== Beispiele ===

== Wo kaufen? ==

Zu beziehen ist das Board entweder über Ebay, meist aus China, oder bei [http://www.watterott.com/de/FriendlyARM Watterott].

== Eigene Displays an das Mini anschließen ==

* Displays mit LVDS Anschluss können z.B. mit diesem selbst gebauten Adapter an das Mini angeschlossen werden. http://www.mikrocontroller.net/topic/217774#new

== Links und Quellen ==
* [http://www.friendlyarm.net/products/mini2440 Übersicht auf der Friendlyarm Seite]
=== Howtos ===
* [http://wiki.linuxmce.org/index.php/Mini2440 Kernel, u-boot und qemu-mini2440 compilieren]
* [[Mini2440 SDL GUI Programmierung]]

=== Repositories ===

* [http://code.google.com/p/mini2440/downloads/list Emdebian+Angstrom Images, s3c_boot_usb]

* [http://programmers-projects.de/node/10 Programmer's-Projects Mini2440 Projekt (überarbeitetes USB-Upload-Tool für Linux und mehr)]

=== Youtube und ähnliche ===

[[Category:ARM-Boards]]
[[Category:Linux-Boards]]

STM32F4-Discovery

2012-02-03T19:49:58Z

Avr-frickler:

Dieser Wiki-Artikel soll den Einstieg in die Prozessorfamilie STM32 von [http://www.st.com STMicroelectronics] erleichtern. Der Artikel begleitet dich von der Installation der benötigten Software bis hin zum flashen des Beispiels in den Prozessor. 
Da es für Windows schon einiges im Internet zu finden gibt, wird die Installation der Toolchain für Linux beschrieben. Die verwendeten Tools sind allerdings als Quelltext oder als Windows-Installation verfügbar, somit lassen sich die meisten Schritte auch auf Windows-Betriebssystemen nachvollziehen.
== Hardware ==
Das in diesem Artikel verwendete Board [http://www.st.com/internet/evalboard/product/252419.jsp STM32F4-Discovery] lässt sich z.B. bei [http://www.watterott.com/de/STM32F4Discovery Watterott] bestellen.
Es lassen sich auch andere Boards verwenden, allerdings müssen die Beispiele dem Schaltplan entsprechend angepasst werden.
== Software ==
Um das Dateisystem möglicht sauber zu halten installiere ich hier sämtliche Software in das Unterverzeichnis /opt welches für solche Installationen vorgesehen ist. Damit auf dieses Verzeichnis schreibend zugegriffen werden darf sind root-Rechte erforderlich. Ich werde vor den Befehlen immer den Prompt schreiben damit zu erkennen ist welche Rechte notwendig sind.

Es ist natürlich auch möglich alles in sein Heimat-Verzeichnis zu schreiben, hier kommt man dann grössten Teils ohne root-Rechte aus. Das muss aber jeder für sich selbst entscheiden wie er es mag.

Nicht alle Linux-Distributionen sind gleich, ich arbeite hier mit einem (fast) frischem Lubuntu 11.10. Der grösste Teil sollte also mit Ubuntu und Debian-Systemen funktionieren. Für andere Distributionen kann man den entsprechenden Abschnitt editieren oder auf der [[Diskussion:STM32F4-Discovery]] zu diesem Artikel vermerken.
==== Sourcery CodeBench Lite Edition for ARM EABI ====
[[Datei:Sup_processors.jpg|thumb|left]]
Als erstes benötigen wir die Toolchain mit Compiler & Linker. Hier verwenden wir die [http://www.mentor.com/embedded-software/sourcery-tools/sourcery-codebench/editions/lite-edition/ Sourcery Codebench von Mentor]. In der Auswahlbox "Supported Prozessors" wählt man in der Rubrik "ARM processors" den Punkt "Download the EABI Release >" aus.

Leider muss man sich registrieren. Nach der Registrierung erhält man einen Link per E-Mail zur Downloadseite. Man wählt das "Recommended Release" aus und lädt dort die Datei "IA32 GNU/Linux TAR" herunter.

[https://sourcery.mentor.com/sgpp/lite/arm/portal/package9740/public/arm-none-eabi/arm-2011.09-69-arm-none-eabi-i686-pc-linux-gnu.tar.bz2 Direktlink Linux] [https://sourcery.mentor.com/sgpp/lite/arm/portal/package9741/public/arm-none-eabi/arm-2011.09-69-arm-none-eabi-i686-mingw32.tar.bz2 Direktlink Windows]

Die Datei muss einfach nur an einem beliebigem Ort entpackt werden und die Umgebungsvariable PATH erweitert werden.

<pre>
root@linux:/home/user/Downloads# mkdir /opt/CodeSourcery
root@linux:/home/user/Downloads# cd /opt/CodeSourcery
root@linux:/opt/CodeSourcery# tar xvf /home/user/Downloads/arm-2011.09-69-arm-none-eabi-i686-pc-linux-gnu.tar.bz2
root@linux:/opt/CodeSourcery# ls
arm-2011.09
</pre>

Anpassen der Umgebungsvariable PATH, die Anpassung ermöglicht es Eclipse den Compiler im Dateisystem zu finden ohne den absoluten Pfad anzugeben. 
Es gibt verschiedene Orte wo sich die Variable anpassen lässt. Auf meinem System habe ich die Datei /etc/environment angepasst.

<pre>
root@linux:/opt/CodeSourcery# echo PATH=\"$PATH:/opt/CodeSourcery/arm-2011.09/bin\" >> /etc/environment
root@linux:/opt/CodeSourcery# source /etc/environment
root@linux:/opt/CodeSourcery# arm-none-eabi-gcc --version
arm-none-eabi-gcc (Sourcery CodeBench Lite 2011.09-69) 4.6.1
Copyright (C) 2011 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
</pre>

Wer gerne mit der Konsole & vi/emacs arbeitet kann sofort zum Abschnitt stlink springen, für die Klickibunti-Fraktion folgt jetzt die Installation der IDE.
==== Eclipse IDE ====
Nach der Installation der Toolchain folgt jetzt die IDE hier habe ich mich für Eclipse entschieden. Zunächst sucht man sich auf [http://www.eclipse.org/downloads/ eclipse.org] aus einen der vielen Pakete das für sich passende raus. Das sinnvollste an dieser Stelle ist "Eclipse IDE for C/C++ Developers". Wer aber vor hat die IDE nicht nur für C/C++ zu verwenden ist mit "Eclipse Classic" vielleicht besser bedient.

Ich werde hier Eclipse Classic 3.7.1 verwenden und zeigen wie das CDT (C/C++ Development Tooling) installiert wird.
Um Eclipse zu "installieren" muss das Archiv nur an einem Ort seiner Wahl entpackt werden.
<pre>
root@linux:/home/user/Downloads# cd /opt
root@linux:/opt# tar xvf /home/user/Downloads/eclipse-SDK-3.7.1-linux-gtk.tar.gz
</pre>
Die IDE lässt sich nun wie folgt starten:
<pre>
user@linux:~$ /opt/eclipse/eclipse
</pre>
Wie ein Starter angelegt wird liest du am besten im Handbuch/Wiki zu deiner Distribution nach.

Als nächstes folgt die Installation der benötigten Plugins. Der Abschnitt "CDT (C/C++ Development Tooling)" kann übersprungen werden, wenn man das Eclipse-Paket "Eclipse IDE for C/C++ Developers" installiert hat.
===== CDT (C/C++ Development Tooling) =====
Zum installieren des CDT wird zuerst die IDE gestartet. Im Hauptfenster wählt man dann den Menüpunkt '''Help > Install New Software...''' es erscheint ein neuer Dialog. Das Eingabefeld '''Work with:''' wird mit '''http://download.eclipse.org/tools/cdt/releases/indigo''' ausgefüllt und mit der '''Return-Taste''' abgeschickt.

Im unteren Teil des Dialogs werden nun die verfügbaren Plugins aufgelistet, benötigt wird das Plugins '''C/C++ Development Tools''' aus der Rubrik '''CDT Main Features''' und '''C/C++ GDB Hardware Debugging''' aus der Rubrik '''CDT Optional Features'''. Einfach ein Haken vor den Plugins machen und auf '''Next''' klicken. Es erscheint eine Zusammenfassung und eine Seite weiter die Lizenz, die man sich durchlesen sollte und dann bestenfalls bestätigt. Mit einem klick auf '''Finish''' wird das Plugin heruntergeladen und installiert.

Nach der Installation des Plugins sollte Eclipse neu gestartet werden. Auf der Willkommen-Seite ist nun ein Punkt C/C++ Development zusehen bzw. lässt sich im Menü per '''File > New > Project...''' ein C oder C++ Projekt anlegen.

===== GNU ARM Eclipse Plug-in =====
Mit der jetzigen Installation ist es bereits möglich einfache C/C++ Projekte zu erstellen und Makefiles zu importieren. Jetzt fehlt noch das Bindeglied zwischen der Toolchain und Eclipse. Dazu gibt es das [http://sourceforge.net/projects/gnuarmeclipse/ GNU ARM Eclipse Plug-in]. Mit dem Plugin kann man nun die Konfiguration des Compilers und Linkers in Eclipse erledigen was sonst in einem Makefile geschieht.

Die Installation des Plugins funktioniert genauso wie die Installation des CDT, nur mit anderer Quelle. Hier die Kurzfassung:
# '''Help > Install New Software...'''
# '''Work with:''' mit http://gnuarmeclipse.sourceforge.net/updates ausfüllen und mit '''Return-Taste''' bestätigen.
# Einen Haken vor CDT GNU Cross Development Tools machen und '''Next''' drücken.
# Es erscheint eine Zusammenfassung mit '''Next''' zu nächsten Seite.
# Lizenzvereinbarung lesen und akzeptieren Installation mit klick auf '''Finish''' starten.
# Es erscheint noch eine Warnung, dass die Dateien nicht signiert sind. Diesen bitte mit '''OK''' bestätigen.
# Eclipse neu starten.

Beim erstellen eines neuen C oder C++ Projekts kann nun die Toolchain ARM Linux GCC (Sourcery G++ Lite) gewählt werden.
Bevor mit den Beispielen begonnen werden kann muss noch die Frage geklärt werden wie die Daten auf den Chip kommen.
==== stlink ====
Das Entwicklungsboard STM32F4-Discovery von ST kann über USB per STLinkV2 Programmiert werden. Für Linux gibt es da den [https://github.com/texane/stlink "stm32 discovery line linux programmer"]

Die Tools liegen als Quelltext vor und müssen zuerst kompiliert werden. Dann mal los! Solltest du mit deinem Linux noch nie ein Programm kompiliert haben siehe am besten erst in dem Handbuch/Wiki zu deiner Distribution nach was du benötigst (Ubuntu benötigt z.B. die Pakete build-essential und git).

Als erstes die Quelltexte laden
<pre>user@linux:~/src$ git clone git://github.com/texane/stlink.git</pre>
Um die Tools nun kompilieren zu können werden noch die Quelltexte der libusb 1.0 benötigt. Bei einem Ubuntu-System ist dies das Paket libusb-1.0.0-dev (Lubuntu 11.10). 
Jetzt kann der Quelltext kompiliert werden.
<pre>
user@linux:~/src$ cd stlink
user@linux:~/src/stlink$ make
</pre>
Wenn das ganze Fehlerfrei durch gelaufen ist kann man den ganzen Ordner oder alternativ auch nur ./flash/flash und ./gdbserver/st-util kopieren und per Umgebungsvariable PATH verfügbar machen. 
'''Achtung''': Im folgendem Block benenne ich flash in st-flash um, weil ich flash nicht besonders passend finde wenn man es per Umgebungsvariable verfügbar macht.
<pre>
root@linux:~# mkdir /opt/stlink
root@linux:~# cd /opt/stlink
root@linux:/opt/stlink# cp /home/user/src/stlink/flash/flash ./st-flash
root@linux:/opt/stlink# cp /home/user/src/stlink/gdbserver/st-util .
root@linux:/opt/stlink# echo PATH=\"$PATH:/opt/stlink\" >> /etc/environment
root@linux:/opt/stlink# source /etc/environment
</pre>
Nun brauchen die beiden Tools noch Schreibrechte für das USB-Gerät.
<pre>
root@linux:~# cp /home/user/src/stlink/49-stlinkv*.rules /etc/udev/rules.d
root@linux:~# udevadm control --reload-rules
</pre>
Wird nun das STM32F4-Discovery an den PC gesteckt wird ein neues Device erzeugt, bei mir war das '''/dev/stlinkv2_2'''. 
Für Boards mit STLink v1 solltest du dir einmal die README zu stlink durchlesen.

Sollte das soweit alles geklappt haben, ist das jetzt der perfekte Zeitpunkt um ein Backup der Firmware zu machen.
<pre>
user@linux:~$ st-flash read ~/STM32F4-Discovery.bin 0x8000000 0x100000
</pre>
Mit folgendem Befehl kann die Datei wieder zurück geschrieben werden.
<pre>
user@linux:~$ st-flash write ~/STM32F4-Discovery.bin 0x8000000
</pre>
==== stlink in Eclipse einbinden ====
Als nächstes wird der GDB-Server in Eclipse integriert. Man wählt aus dem Hauptmenu '''Run > External Tools > External Tools Configurations...'''.

Ein Klick mit der rechten Maustaste auf '''Program''' und '''New''' auswählen.
Als Name '''ST-Link''' eintragen. Bei Working Directory: wird '''${workspace_loc}${project_path}''' eingetragen.
Auf der Registerkarte '''Build''' wird der Haken vor '''Build before Launch''' raus genommen. Danach auf der Registerkarte '''Common''' einen Haken vor '''External Tools''' im Feld '''Display in Favorites menu''' machen.
Ein Klick auf '''Apply''' und den Dialog mit einem Klick auf '''Close''' schließen.

== Beispiel-Projekte ==
=== Vorbereitungen ===
==== Standard Peripherals Library ====
Bevor jetzt der erste Quelltext in den Editor gehackt wird, kann man sich das Leben etwas leichter machen. STMicroelectronics stellt für seine Microprozessoren Bibliotheken bereit, die einem eine ganze Menge Arbeit abnimmt.

Die Rede ist von der "Standard Peripherals Library", diese lässt sich auf der Seite von [http://www.st.com STMicroelectronics] herunter laden. Der Weg dorthin ist dank einer wunderschön gestalteten Homepage etwas steinig. 
Auf der Hauptseite wählt man zuerst in der Rubrik '''Products''' die Kategorie '''Micros & Memories''' und danach '''Mikrocontrollers'''. Als nächstes wird auf die Registerkarte '''Resources''' gewechselt. Im Bereich '''Software Resources''' wird der Punkt '''Firmware''' ausgewählt. Es öffnet sich ein neues Browserfenster/-tab mit einer Liste von Dateien. Im oberen Bereich gibt es ein Suchfeld. Hier kann nach den "standard peripherals library" gesucht werde
Für das STM32F4-Discovery benötigen wir die Datei [http://www.st.com/internet/com/SOFTWARE_RESOURCES/SW_COMPONENT/FIRMWARE/stm32f4_dsp_stdperiph_lib.zip STM32F4 DSP and standard peripherals library]

Die Datei kann an einen beliebigen Ort entpackt werden.
==== Neues Projekt anlegen ====
Jetzt kann mit der Programmierarbeit begonnen werden. Falls noch nicht geschehen kann nun die IDE gestartet werden, im Terminal geht das bei meiner Installation mit:
<pre>user@linux:~$ /opt/eclipse/eclipse</pre>
Nun wird ein neues Projekt geöffnet folgende Schritte sind nötig:
# File > New > Project...
# C/C++ > C Project; Next
# ARM Cross Target Application > Empty Project
# Toolchains = ARM Linux GCC (Sourcery G++ Lite)
# Project name = (Hier den Projektnamen eingeben); Finish
# Eventuell wird nach der C/C++ Perspective gefragt, diesen Dialog mit '''Yes''' beantworten.
Auf der linken Seite im '''Project Explorer''' siehst du nun das neue Projekt, sobald du die Baumstruktur öffnest sollte bereits ein Ordner '''Includes''' vorhanden sein, dort gibt es bereits 3 Einträge:
* '''/opt/CodeSourcery/arm-2011.09/arm-none-eabi/include'''
* '''/opt/CodeSourcery/arm-2011.09/lib/gcc/arm-none-eabi/4.6.1/include'''
* '''/opt/CodeSourcery/arm-2011.09/lib/gcc/arm-none-eabi/4.6.1/include-fixed'''
Wenn diese Einträge nicht vorhanden sind, ist bis hierhin etwas schief gegangen. Vermutlich wurde die Umgebungsvariable PATH nicht korrekt gesetzt.

Wenn bis hierhin alles geklappt hat können nun die weiteren Einstellungen vorgenommen werden. Zuerst werden die Header-Datei der Standard Peripherals Library hinzu gefügt.
# Project > Properties
# C/C++ General > Paths and Symbols
# Configuration = [All configurations]
# Reiter Includes, Languages = GNU C
Hier werden nun die Pfade zu den Header-Dateien der Standard Peripherals Library eingetragen. Ich habe das von ST heruntergeladene Archiv nach /home/user/eclipse/STM32/ entpackt. daraus ergeben sich für mich folgende Pfade die eingetragen werden müssen:
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Include
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Include
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/STM32F4xx_StdPeriph_Driver/inc
* /${ProjDirPath}
Als nächstes werden die Quellcode-Dateien der Standard Peripherals Library hinzugefügt.
# Reiter Source Location
# Link Folder..., Folder Name = StdPeriph
# Link to folder in the filesystem aktivieren
# Browse..., Verzeichniss = /user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/STM32F4xx_StdPeriph_Driver/src
Jetzt noch 2 Symbole anlegen:
# Reiter Symbols, Languages = GNU C
# Add..., Name: = USE_STDPERIPH_DRIVER > OK
# Add..., Name: = USE_STM32_DISCOVERY > OK
Nun noch ein Linker-Script aktivieren.
# C/C++ Build > Settings
# Configuration = [All configurations]
# ARM Sourcery Linux GCC Linker > General
# Script File (-T) = /${ProjDirPath}/stm32_flash.ld
Als letztes noch das Ausgabeformat auf Binary einstellen.
# ARM Sourcery Linux GNU Create Flash Image > Output
# Output file format (-O) = binary
Der Dialog kann nun mit '''OK''' geschlossen werden.

Jetzt müssen noch 3 Dateien ins Projekt kopiert werden.
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Project/STM32F4xx_StdPeriph_Templates/TrueSTUDIO/STM324xG_EVAL/stm32_flash.ld
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/system_stm32f4xx.c
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/TrueSTUDIO/startup_stm32f4xx.s

'''Die Dateiendung der Datei startup_stm32f4xx.s muss noch in ein geoßes S geändert werden. Ausserdem muss in der Datei folgende Anweisung auskommentiert werden.'''
<pre>
/* Call static constructors */
// bl __libc_init_array
</pre>

'''Hinweis zur Ausgabedatei''' 
Die kompilierte Datei befindet sich im Ordner Debug oder Release im Projektverzeichniss. Die Datei besitzt den Namen des Prejekts und endet auf .hex. Die Endung ist zwar hex beinhaltet aber trotzdem ein Binary.

Jetzt kann mit der Programmierung begonnen werden.
==== Debugging mit GDB ====
Dieser Abschnitt zeigt wie der GDB-Server von stlink in Eclipse verwendet wird.

Bei geöffnetem Projekt klickt man im Hauptmenü auf '''Run > Debug Configurations...'''. In der Liste links klickt man mit der Rechten Maustaste auf '''GDB Hardware Debugging''' und wählt '''New'''.

Bei Name trägt man den Namen der Konfiguration ein z.B. STM32F4-Discovery ST-Link. Die Datei für '''C/C++ Application:''' wählt man am besten aus, indem man auf '''Search Project...''' klickt. Das Eingabefeld '''Project:''' sollte bereits ausgefüllt sein.
Auf der Registerkarte '''Debugger''' wird in das Eingabefeld '''GDB-Command:''' '''arm-none-eabi-gdb''' eingetragen. In das Feld '''Port Number:''' wird 4242 eingetragen. Abschließend wird auf die Registerkarte Common gewechselt. Hier wird ein Haken vor '''Debug''' im Feld '''Display in Favorites menu''' gemacht.
Ein Klick auf '''Apply''' und '''Close''' schließt die Konfiguration ab.

Um ein Projekt zu debuggen wählt man zuerst aus dem Hauptmenu '''Run > External Tools > ST-Link''' dadurch wird der GDB-Server gestartet.

Sollte man die Meldung erhalten Variable References empty selection: ${project_path} hilft es einmal in eine Projektdatei oder den Projekt-Explorer zu klicken.

Danach wählt man aus dem Hauptmenü '''Run > Debug Configurations...''', in der Liste links wählt man die angelegte Configuration unter '''GDB Hardware Debugging''' aus und klickt auf Debug. Eclipse möchte nun in die Debug-Perspektive wchseln, das sollte mit '''Yes''' beantworten werden.

Das Programm wird in den Mikrocontroller geladen und nach dem Flashvorgang direkt gestoppt. Mit F8 kann die Ausführung wieder gestartet werden.
=== Beispiel: Blinky ===
Hier ein Beispiel welches die 4 LEDs um den MEMS-Sensor herum leuchten lässt.

main.c
<c>
#include "stm32f4xx.h"

GPIO_InitTypeDef GPIO_InitStructure;

void Delay(__IO uint32_t nCount) {
while(nCount--) {
}
}

int main(void) {
/* GPIOD Periph clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

/* Configure PD12, 13, 14 and PD15 in output pushpull mode */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);

while (1) {
/* Set PD12 Green */
GPIOD->BSRRL = GPIO_Pin_12;
/* Reset PD13 Orange, PD14 Red, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD13 Orange */
GPIOD->BSRRL = GPIO_Pin_13;
/* Reset PD12 Green, PD14 Red, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_14 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD14 Red */
GPIOD->BSRRL = GPIO_Pin_14;
/* Reset PD12 Green, PD13 Orange, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD15 Blue */
GPIOD->BSRRL = GPIO_Pin_15;
/* Reset PD12 Green, PD13 Orange, PD14 Red */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14;
Delay(10000000L);
}
}
</c>
stm32f4xx_conf.h
<c>
#ifndef __STM32F4xx_CONF_H
#define __STM32F4xx_CONF_H

/* Includes ------------------------------------------------------------------*/
/* Uncomment the line below to enable peripheral header file inclusion */
// #include "stm32f4xx_adc.h"
// #include "stm32f4xx_can.h"
// #include "stm32f4xx_crc.h"
// #include "stm32f4xx_cryp.h"
// #include "stm32f4xx_dac.h"
// #include "stm32f4xx_dbgmcu.h"
// #include "stm32f4xx_dcmi.h"
// #include "stm32f4xx_dma.h"
// #include "stm32f4xx_exti.h"
// #include "stm32f4xx_flash.h"
// #include "stm32f4xx_fsmc.h"
// #include "stm32f4xx_hash.h"
#include "stm32f4xx_gpio.h"
// #include "stm32f4xx_i2c.h"
// #include "stm32f4xx_iwdg.h"
// #include "stm32f4xx_pwr.h"
#include "stm32f4xx_rcc.h"
// #include "stm32f4xx_rng.h"
// #include "stm32f4xx_rtc.h"
// #include "stm32f4xx_sdio.h"
// #include "stm32f4xx_spi.h"
// #include "stm32f4xx_syscfg.h"
// #include "stm32f4xx_tim.h"
// #include "stm32f4xx_usart.h"
// #include "stm32f4xx_wwdg.h"
// #include "misc.h"

#ifdef USE_FULL_ASSERT
#define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
void assert_failed(uint8_t* file, uint32_t line);
#else
#define assert_param(expr) ((void)0)
#endif

#endif
</c>
[[Kategorie:STM32]]

STM32F4-Discovery

2012-02-03T18:28:09Z

Avr-frickler:

Dieser Wiki-Artikel soll den Einstieg in die Prozessorfamilie STM32 von [http://www.st.com STMicroelectronics] erleichtern. Der Artikel begleitet dich von der Installation der benötigten Software bis hin zum flashen des Beispiels in den Prozessor. 
Da es für Windows schon einiges im Internet zu finden gibt, wird die Installation der Toolchain für Linux beschrieben. Die verwendeten Tools sind allerdings als Quelltext oder als Windows-Installation verfügbar, somit lassen sich die meisten Schritte auch auf Windows-Betriebssystemen nachvollziehen.
== Hardware ==
Das in diesem Artikel verwendete Board [http://www.st.com/internet/evalboard/product/252419.jsp STM32F4-Discovery] lässt sich z.B. bei [http://www.watterott.com/de/STM32F4Discovery Watterott] bestellen.
Es lassen sich auch andere Boards verwenden, allerdings müssen die Beispiele dem Schaltplan entsprechend angepasst werden.
== Software ==
Um das Dateisystem möglicht sauber zu halten installiere ich hier sämtliche Software in das Unterverzeichnis /opt welches für solche Installationen vorgesehen ist. Damit auf dieses Verzeichnis schreibend zugegriffen werden darf sind root-Rechte erforderlich. Ich werde vor den Befehlen immer den Prompt schreiben damit zu erkennen ist welche Rechte notwendig sind.

Es ist natürlich auch möglich alles in sein Heimat-Verzeichnis zu schreiben, hier kommt man dann grössten Teils ohne root-Rechte aus. Das muss aber jeder für sich selbst entscheiden wie er es mag.

Nicht alle Linux-Distributionen sind gleich, ich arbeite hier mit einem (fast) frischem Lubuntu 11.10. Der grösste Teil sollte also mit Ubuntu und Debian-Systemen funktionieren. Für andere Distributionen kann man den entsprechenden Abschnitt editieren oder auf der [[Diskussion:STM32F4-Discovery]] zu diesem Artikel vermerken.
==== Sourcery CodeBench Lite Edition for ARM EABI ====
[[Datei:Sup_processors.jpg|thumb|left]]
Als erstes benötigen wir die Toolchain mit Compiler & Linker. Hier verwenden wir die [http://www.mentor.com/embedded-software/sourcery-tools/sourcery-codebench/editions/lite-edition/ Sourcery Codebench von Mentor]. In der Auswahlbox "Supported Prozessors" wählt man in der Rubrik "ARM processors" den Punkt "Download the EABI Release >" aus.

Leider muss man sich registrieren. Nach der Registrierung erhält man einen Link per E-Mail zur Downloadseite. Man wählt das "Recommended Release" aus und lädt dort die Datei "IA32 GNU/Linux TAR" herunter.

[https://sourcery.mentor.com/sgpp/lite/arm/portal/package9740/public/arm-none-eabi/arm-2011.09-69-arm-none-eabi-i686-pc-linux-gnu.tar.bz2 Direktlink Linux] [https://sourcery.mentor.com/sgpp/lite/arm/portal/package9741/public/arm-none-eabi/arm-2011.09-69-arm-none-eabi-i686-mingw32.tar.bz2 Direktlink Windows]

Die Datei muss einfach nur an einem beliebigem Ort entpackt werden und die Umgebungsvariable PATH erweitert werden.

<pre>
root@linux:/home/user/Downloads# mkdir /opt/CodeSourcery
root@linux:/home/user/Downloads# cd /opt/CodeSourcery
root@linux:/opt/CodeSourcery# tar xvf /home/user/Downloads/arm-2011.09-69-arm-none-eabi-i686-pc-linux-gnu.tar.bz2
root@linux:/opt/CodeSourcery# ls
arm-2011.09
</pre>

Anpassen der Umgebungsvariable PATH, die Anpassung ermöglicht es Eclipse den Compiler im Dateisystem zu finden ohne den absoluten Pfad anzugeben. 
Es gibt verschiedene Orte wo sich die Variable anpassen lässt. Auf meinem System habe ich die Datei /etc/environment angepasst.

<pre>
root@linux:/opt/CodeSourcery# echo PATH=\"$PATH:/opt/CodeSourcery/arm-2011.09/bin\" >> /etc/environment
root@linux:/opt/CodeSourcery# source /etc/environment
root@linux:/opt/CodeSourcery# arm-none-eabi-gcc --version
arm-none-eabi-gcc (Sourcery CodeBench Lite 2011.09-69) 4.6.1
Copyright (C) 2011 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
</pre>

Wer gerne mit der Konsole & vi/emacs arbeitet kann sofort zum Abschnitt stlink springen, für die Klickibunti-Fraktion folgt jetzt die Installation der IDE.
==== Eclipse IDE ====
Nach der Installation der Toolchain folgt jetzt die IDE hier habe ich mich für Eclipse entschieden. Zunächst sucht man sich auf [http://www.eclipse.org/downloads/ eclipse.org] aus einen der vielen Pakete das für sich passende raus. Das sinnvollste an dieser Stelle ist "Eclipse IDE for C/C++ Developers". Wer aber vor hat die IDE nicht nur für C/C++ zu verwenden ist mit "Eclipse Classic" vielleicht besser bedient.

Ich werde hier Eclipse Classic 3.7.1 verwenden und zeigen wie das CDT (C/C++ Development Tooling) installiert wird.
Um Eclipse zu "installieren" muss das Archiv nur an einem Ort seiner Wahl entpackt werden.
<pre>
root@linux:/home/user/Downloads# cd /opt
root@linux:/opt# tar xvf /home/user/Downloads/eclipse-SDK-3.7.1-linux-gtk.tar.gz
</pre>
Die IDE lässt sich nun wie folgt starten:
<pre>
user@linux:~$ /opt/eclipse/eclipse
</pre>
Wie ein Starter angelegt wird liest du am besten im Handbuch/Wiki zu deiner Distribution nach.

Als nächstes folgt die Installation der benötigten Plugins. Der Abschnitt "CDT (C/C++ Development Tooling)" kann übersprungen werden, wenn man das Eclipse-Paket "Eclipse IDE for C/C++ Developers" installiert hat.
===== CDT (C/C++ Development Tooling) =====
Zum installieren des CDT wird zuerst die IDE gestartet. Im Hauptfenster wählt man dann den Menüpunkt '''Help > Install New Software...''' es erscheint ein neuer Dialog. Das Eingabefeld '''Work with:''' wird mit '''http://download.eclipse.org/tools/cdt/releases/indigo''' ausgefüllt und mit der '''Return-Taste''' abgeschickt.

Im unteren Teil des Dialogs werden nun die verfügbaren Plugins aufgelistet, benötigt wird das Plugins '''C/C++ Development Tools''' aus der Rubrik '''CDT Main Features''' und '''C/C++ GDB Hardware Debugging''' aus der Rubrik '''CDT Optional Features'''. Einfach ein Haken vor den Plugins machen und auf '''Next''' klicken. Es erscheint eine Zusammenfassung und eine Seite weiter die Lizenz, die man sich durchlesen sollte und dann bestenfalls bestätigt. Mit einem klick auf '''Finish''' wird das Plugin heruntergeladen und installiert.

Nach der Installation des Plugins sollte Eclipse neu gestartet werden. Auf der Willkommen-Seite ist nun ein Punkt C/C++ Development zusehen bzw. lässt sich im Menü per '''File > New > Project...''' ein C oder C++ Projekt anlegen.

===== GNU ARM Eclipse Plug-in =====
Mit der jetzigen Installation ist es bereits möglich einfache C/C++ Projekte zu erstellen und Makefiles zu importieren. Jetzt fehlt noch das Bindeglied zwischen der Toolchain und Eclipse. Dazu gibt es das [http://sourceforge.net/projects/gnuarmeclipse/ GNU ARM Eclipse Plug-in]. Mit dem Plugin kann man nun die Konfiguration des Compilers und Linkers in Eclipse erledigen was sonst in einem Makefile geschieht.

Die Installation des Plugins funktioniert genauso wie die Installation des CDT, nur mit anderer Quelle. Hier die Kurzfassung:
# '''Help > Install New Software...'''
# '''Work with:''' mit http://gnuarmeclipse.sourceforge.net/updates ausfüllen und mit '''Return-Taste''' bestätigen.
# Einen Haken vor CDT GNU Cross Development Tools machen und '''Next''' drücken.
# Es erscheint eine Zusammenfassung mit '''Next''' zu nächsten Seite.
# Lizenzvereinbarung lesen und akzeptieren Installation mit klick auf '''Finish''' starten.
# Es erscheint noch eine Warnung, dass die Dateien nicht signiert sind. Diesen bitte mit '''OK''' bestätigen.
# Eclipse neu starten.

Beim erstellen eines neuen C oder C++ Projekts kann nun die Toolchain ARM Linux GCC (Sourcery G++ Lite) gewählt werden.
Bevor mit den Beispielen begonnen werden kann muss noch die Frage geklärt werden wie die Daten auf den Chip kommen.
==== stlink ====
Das Entwicklungsboard STM32F4-Discovery von ST kann über USB per STLinkV2 Programmiert werden. Für Linux gibt es da den [https://github.com/texane/stlink "stm32 discovery line linux programmer"]

Die Tools liegen als Quelltext vor und müssen zuerst kompiliert werden. Dann mal los! Solltest du mit deinem Linux noch nie ein Programm kompiliert haben siehe am besten erst in dem Handbuch/Wiki zu deiner Distribution nach was du benötigst (Ubuntu benötigt z.B. die Pakete build-essential und git).

Als erstes die Quelltexte laden
<pre>user@linux:~/src$ git clone git://github.com/texane/stlink.git</pre>
Um die Tools nun kompilieren zu können werden noch die Quelltexte der libusb 1.0 benötigt. Bei einem Ubuntu-System ist dies das Paket libusb-1.0.0-dev (Lubuntu 11.10). 
Jetzt kann der Quelltext kompiliert werden.
<pre>
user@linux:~/src$ cd stlink
user@linux:~/src/stlink$ make
</pre>
Wenn das ganze Fehlerfrei durch gelaufen ist kann man den ganzen Ordner oder alternativ auch nur ./flash/flash und ./gdbserver/st-util kopieren und per Umgebungsvariable PATH verfügbar machen. 
'''Achtung''': Im folgendem Block benenne ich flash in st-flash um, weil ich flash nicht besonders passend finde wenn man es per Umgebungsvariable verfügbar macht.
<pre>
root@linux:~# mkdir /opt/stlink
root@linux:~# cd /opt/stlink
root@linux:/opt/stlink# cp /home/user/src/stlink/flash/flash ./st-flash
root@linux:/opt/stlink# cp /home/user/src/stlink/gdbserver/st-util .
root@linux:/opt/stlink# echo PATH=\"$PATH:/opt/stlink\" >> /etc/environment
root@linux:/opt/stlink# source /etc/environment
</pre>
Nun brauchen die beiden Tools noch Schreibrechte für das USB-Gerät.
<pre>
root@linux:~# cp /home/user/src/stlink/49-stlinkv*.rules /etc/udev/rules.d
root@linux:~# udevadm control --reload-rules
</pre>
Wird nun das STM32F4-Discovery an den PC gesteckt wird ein neues Device erzeugt, bei mir war das '''/dev/stlinkv2_2'''. 
Für Boards mit STLink v1 solltest du dir einmal die README zu stlink durchlesen.

Sollte das soweit alles geklappt haben, ist das jetzt der perfekte Zeitpunkt um ein Backup der Firmware zu machen.
<pre>
user@linux:~$ st-flash read ~/STM32F4-Discovery.bin 0x8000000 0x100000
</pre>
Mit folgendem Befehl kann die Datei wieder zurück geschrieben werden.
<pre>
user@linux:~$ st-flash write ~/STM32F4-Discovery.bin 0x8000000
</pre>
==== stlink in Eclipse einbinden ====
Als nächstes wird der GDB-Server in Eclipse integriert. Man wählt aus dem Hauptmenu '''Run > External Tools > External Tools Configurations...'''.

Ein Klick mit der rechten Maustaste auf '''Program''' und '''New''' auswählen.
Als Name '''ST-Link''' eintragen. Bei Working Directory: wird '''${workspace_loc}${project_path}''' eingetragen.
Auf der Registerkarte '''Build''' wird der Haken vor '''Build before Launch''' raus genommen. Danach auf der Registerkarte '''Common''' einen Haken vor '''External Tools''' im Feld '''Display in Favorites menu''' machen.
Ein Klick auf '''Apply''' und den Dialog mit einem Klick auf '''Close''' schließen.

== Beispiel-Projekte ==
=== Vorbereitungen ===
==== Standard Peripherals Library ====
Bevor jetzt der erste Quelltext in den Editor gehackt wird, kann man sich das Leben etwas leichter machen. STMicroelectronics stellt für seine Microprozessoren Bibliotheken bereit, die einem eine ganze Menge Arbeit abnimmt.

Die Rede ist von der "Standard Peripherals Library", diese lässt sich auf der Seite von [http://www.st.com STMicroelectronics] herunter laden. Der Weg dorthin ist dank einer wunderschön gestalteten Homepage etwas steinig. 
Auf der Hauptseite wählt man zuerst in der Rubrik '''Products''' die Kategorie '''Micros & Memories''' und danach '''Mikrocontrollers'''. Als nächstes wird auf die Registerkarte '''Resources''' gewechselt. Im Bereich '''Software Resources''' wird der Punkt '''Firmware''' ausgewählt. Es öffnet sich ein neues Browserfenster/-tab mit einer Liste von Dateien. Im oberen Bereich gibt es ein Suchfeld. Hier kann nach den "standard peripherals library" gesucht werde
Für das STM32F4-Discovery benötigen wir die Datei [http://www.st.com/internet/com/SOFTWARE_RESOURCES/SW_COMPONENT/FIRMWARE/stm32f4_dsp_stdperiph_lib.zip STM32F4 DSP and standard peripherals library]

Die Datei kann an einen beliebigen Ort entpackt werden.
==== Neues Projekt anlegen ====
Jetzt kann mit der Programmierarbeit begonnen werden. Falls noch nicht geschehen kann nun die IDE gestartet werden, im Terminal geht das bei meiner Installation mit:
<pre>user@linux:~$ /opt/eclipse/eclipse</pre>
Nun wird ein neues Projekt geöffnet folgende Schritte sind nötig:
# File > New > Project...
# C/C++ > C Project; Next
# ARM Cross Target Application > Empty Project
# Toolchains = ARM Linux GCC (Sourcery G++ Lite)
# Project name = (Hier den Projektnamen eingeben); Finish
# Eventuell wird nach der C/C++ Perspective gefragt, diesen Dialog mit '''Yes''' beantworten.
Auf der linken Seite im '''Project Explorer''' siehst du nun das neue Projekt, sobald du die Baumstruktur öffnest sollte bereits ein Ordner '''Includes''' vorhanden sein, dort gibt es bereits 3 Einträge:
* '''/opt/CodeSourcery/arm-2011.09/arm-none-eabi/include'''
* '''/opt/CodeSourcery/arm-2011.09/lib/gcc/arm-none-eabi/4.6.1/include'''
* '''/opt/CodeSourcery/arm-2011.09/lib/gcc/arm-none-eabi/4.6.1/include-fixed'''
Wenn diese Einträge nicht vorhanden sind, ist bis hierhin etwas schief gegangen. Vermutlich wurde die Umgebungsvariable PATH nicht korrekt gesetzt.

Wenn bis hierhin alles geklappt hat können nun die weiteren Einstellungen vorgenommen werden. Zuerst werden die Header-Datei der Standard Peripherals Library hinzu gefügt.
# Project > Properties
# C/C++ General > Paths and Symbols
# Configuration = [All configurations]
# Reiter Includes, Languages = GNU C
Hier werden nun die Pfade zu den Header-Dateien der Standard Peripherals Library eingetragen. Ich habe das von ST heruntergeladene Archiv nach /home/user/eclipse/STM32/ entpackt. daraus ergeben sich für mich folgende Pfade die eingetragen werden müssen:
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Include
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Include
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/STM32F4xx_StdPeriph_Driver/inc
* /${ProjDirPath}
Als nächstes werden die Quellcode-Dateien der Standard Peripherals Library hinzugefügt.
# Reiter Source Location
# Link Folder..., Folder Name = StdPeriph
# Link to folder in the filesystem aktivieren
# Browse..., Verzeichniss = /user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/STM32F4xx_StdPeriph_Driver/src
Jetzt noch 2 Symbole anlegen:
# Reiter Symbols, Languages = GNU C
# Add..., Name: = USE_STDPERIPH_DRIVER > OK
# Add..., Name: = USE_STM32_DISCOVERY > OK
Nun noch ein Linker-Script aktivieren.
# C/C++ Build > Settings
# Configuration = [All configurations]
# ARM Sourcery Linux GCC Linker > General
# Script File (-T) = /${ProjDirPath}/stm32_flash.ld
Als letztes noch das Ausgabeformat auf Binary einstellen.
# ARM Sourcery Linux GNU Create Flash Image > Output
# Output file format (-O) = binary
Der Dialog kann nun mit '''OK''' geschlossen werden.

Jetzt müssen noch 3 Dateien ins Projekt kopiert werden.
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Project/STM32F4xx_StdPeriph_Templates/TrueSTUDIO/STM324xG_EVAL/stm32_flash.ld
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/system_stm32f4xx.c
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/TrueSTUDIO/startup_stm32f4xx.s

'''Die Dateiendung der Datei startup_stm32f4xx.s muss noch in ein geoßes S geändert werden. Ausserdem muss in der Datei folgende Anweisung auskommentiert werden.'''
<pre>
/* Call static constructors */
// bl __libc_init_array
</pre>

'''Hinweis zur Ausgabedatei''' 
Die kompilierte Datei befindet sich im Ordner Debug oder Release im Projektverzeichniss. Die Datei besitzt den Namen des Prejekts und endet auf .hex. Die Endung ist zwar hex beinhaltet aber trotzdem ein Binary.

Jetzt kann mit der Programmierung begonnen werden.
=== Beispiel: Blinky ===
Hier ein Beispiel welches die 4 LEDs um den MEMS-Sensor herum leuchten lässt.

main.c
<c>
#include "stm32f4xx.h"

GPIO_InitTypeDef GPIO_InitStructure;

void Delay(__IO uint32_t nCount) {
while(nCount--) {
}
}

int main(void) {
/* GPIOD Periph clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

/* Configure PD12, 13, 14 and PD15 in output pushpull mode */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);

while (1) {
/* Set PD12 Green */
GPIOD->BSRRL = GPIO_Pin_12;
/* Reset PD13 Orange, PD14 Red, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD13 Orange */
GPIOD->BSRRL = GPIO_Pin_13;
/* Reset PD12 Green, PD14 Red, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_14 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD14 Red */
GPIOD->BSRRL = GPIO_Pin_14;
/* Reset PD12 Green, PD13 Orange, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD15 Blue */
GPIOD->BSRRL = GPIO_Pin_15;
/* Reset PD12 Green, PD13 Orange, PD14 Red */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14;
Delay(10000000L);
}
}
</c>
stm32f4xx_conf.h
<c>
#ifndef __STM32F4xx_CONF_H
#define __STM32F4xx_CONF_H

/* Includes ------------------------------------------------------------------*/
/* Uncomment the line below to enable peripheral header file inclusion */
// #include "stm32f4xx_adc.h"
// #include "stm32f4xx_can.h"
// #include "stm32f4xx_crc.h"
// #include "stm32f4xx_cryp.h"
// #include "stm32f4xx_dac.h"
// #include "stm32f4xx_dbgmcu.h"
// #include "stm32f4xx_dcmi.h"
// #include "stm32f4xx_dma.h"
// #include "stm32f4xx_exti.h"
// #include "stm32f4xx_flash.h"
// #include "stm32f4xx_fsmc.h"
// #include "stm32f4xx_hash.h"
#include "stm32f4xx_gpio.h"
// #include "stm32f4xx_i2c.h"
// #include "stm32f4xx_iwdg.h"
// #include "stm32f4xx_pwr.h"
#include "stm32f4xx_rcc.h"
// #include "stm32f4xx_rng.h"
// #include "stm32f4xx_rtc.h"
// #include "stm32f4xx_sdio.h"
// #include "stm32f4xx_spi.h"
// #include "stm32f4xx_syscfg.h"
// #include "stm32f4xx_tim.h"
// #include "stm32f4xx_usart.h"
// #include "stm32f4xx_wwdg.h"
// #include "misc.h"

#ifdef USE_FULL_ASSERT
#define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
void assert_failed(uint8_t* file, uint32_t line);
#else
#define assert_param(expr) ((void)0)
#endif

#endif
</c>
[[Kategorie:STM32]]

STM32F4-Discovery

2012-02-03T18:22:33Z

Avr-frickler: Abschnitt 'stlink in Eclipse einbinden' hinzugefügt.

Dieser Wiki-Artikel soll den Einstieg in die Prozessorfamilie STM32 von [http://www.st.com STMicroelectronics] erleichtern. Der Artikel begleitet dich von der Installation der benötigten Software bis hin zum flashen des Beispiels in den Prozessor. 
Da es für Windows schon einiges im Internet zu finden gibt, wird die Installation der Toolchain für Linux beschrieben. Die verwendeten Tools sind allerdings als Quelltext oder als Windows-Installation verfügbar, somit lassen sich die meisten Schritte auch auf Windows-Betriebssystemen nachvollziehen.
== Hardware ==
Das in diesem Artikel verwendete Board [http://www.st.com/internet/evalboard/product/252419.jsp STM32F4-Discovery] lässt sich z.B. bei [http://www.watterott.com/de/STM32F4Discovery Watterott] bestellen.
Es lassen sich auch andere Boards verwenden, allerdings müssen die Beispiele dem Schaltplan entsprechend angepasst werden.
== Software ==
Um das Dateisystem möglicht sauber zu halten installiere ich hier sämtliche Software in das Unterverzeichnis /opt welches für solche Installationen vorgesehen ist. Damit auf dieses Verzeichnis schreibend zugegriffen werden darf sind root-Rechte erforderlich. Ich werde vor den Befehlen immer den Prompt schreiben damit zu erkennen ist welche Rechte notwendig sind.

Es ist natürlich auch möglich alles in sein Heimat-Verzeichnis zu schreiben, hier kommt man dann grössten Teils ohne root-Rechte aus. Das muss aber jeder für sich selbst entscheiden wie er es mag.

Nicht alle Linux-Distributionen sind gleich, ich arbeite hier mit einem (fast) frischem Lubuntu 11.10. Der grösste Teil sollte also mit Ubuntu und Debian-Systemen funktionieren. Für andere Distributionen kann man den entsprechenden Abschnitt editieren oder auf der [[Diskussion:STM32F4-Discovery]] zu diesem Artikel vermerken.
==== Sourcery CodeBench Lite Edition for ARM EABI ====
[[Datei:Sup_processors.jpg|thumb|left]]
Als erstes benötigen wir die Toolchain mit Compiler & Linker. Hier verwenden wir die [http://www.mentor.com/embedded-software/sourcery-tools/sourcery-codebench/editions/lite-edition/ Sourcery Codebench von Mentor]. In der Auswahlbox "Supported Prozessors" wählt man in der Rubrik "ARM processors" den Punkt "Download the EABI Release >" aus.

Leider muss man sich registrieren. Nach der Registrierung erhält man einen Link per E-Mail zur Downloadseite. Man wählt das "Recommended Release" aus und lädt dort die Datei "IA32 GNU/Linux TAR" herunter.

[https://sourcery.mentor.com/sgpp/lite/arm/portal/package9740/public/arm-none-eabi/arm-2011.09-69-arm-none-eabi-i686-pc-linux-gnu.tar.bz2 Direktlink Linux] [https://sourcery.mentor.com/sgpp/lite/arm/portal/package9741/public/arm-none-eabi/arm-2011.09-69-arm-none-eabi-i686-mingw32.tar.bz2 Direktlink Windows]

Die Datei muss einfach nur an einem beliebigem Ort entpackt werden und die Umgebungsvariable PATH erweitert werden.

<pre>
root@linux:/home/user/Downloads# mkdir /opt/CodeSourcery
root@linux:/home/user/Downloads# cd /opt/CodeSourcery
root@linux:/opt/CodeSourcery# tar xvf /home/user/Downloads/arm-2011.09-69-arm-none-eabi-i686-pc-linux-gnu.tar.bz2
root@linux:/opt/CodeSourcery# ls
arm-2011.09
</pre>

Anpassen der Umgebungsvariable PATH, die Anpassung ermöglicht es Eclipse den Compiler im Dateisystem zu finden ohne den absoluten Pfad anzugeben. 
Es gibt verschiedene Orte wo sich die Variable anpassen lässt. Auf meinem System habe ich die Datei /etc/environment angepasst.

<pre>
root@linux:/opt/CodeSourcery# echo PATH=\"$PATH:/opt/CodeSourcery/arm-2011.09/bin\" >> /etc/environment
root@linux:/opt/CodeSourcery# source /etc/environment
root@linux:/opt/CodeSourcery# arm-none-eabi-gcc --version
arm-none-eabi-gcc (Sourcery CodeBench Lite 2011.09-69) 4.6.1
Copyright (C) 2011 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
</pre>

Wer gerne mit der Konsole & vi/emacs arbeitet kann sofort zum Abschnitt stlink springen, für die Klickibunti-Fraktion folgt jetzt die Installation der IDE.
==== Eclipse IDE ====
Nach der Installation der Toolchain folgt jetzt die IDE hier habe ich mich für Eclipse entschieden. Zunächst sucht man sich auf [http://www.eclipse.org/downloads/ eclipse.org] aus einen der vielen Pakete das für sich passende raus. Das sinnvollste an dieser Stelle ist "Eclipse IDE for C/C++ Developers". Wer aber vor hat die IDE nicht nur für C/C++ zu verwenden ist mit "Eclipse Classic" vielleicht besser bedient.

Ich werde hier Eclipse Classic 3.7.1 verwenden und zeigen wie das CDT (C/C++ Development Tooling) installiert wird.
Um Eclipse zu "installieren" muss das Archiv nur an einem Ort seiner Wahl entpackt werden.
<pre>
root@linux:/home/user/Downloads# cd /opt
root@linux:/opt# tar xvf /home/user/Downloads/eclipse-SDK-3.7.1-linux-gtk.tar.gz
</pre>
Die IDE lässt sich nun wie folgt starten:
<pre>
user@linux:~$ /opt/eclipse/eclipse
</pre>
Wie ein Starter angelegt wird liest du am besten im Handbuch/Wiki zu deiner Distribution nach.

Als nächstes folgt die Installation der benötigten Plugins. Der Abschnitt "CDT (C/C++ Development Tooling)" kann übersprungen werden, wenn man das Eclipse-Paket "Eclipse IDE for C/C++ Developers" installiert hat.
===== CDT (C/C++ Development Tooling) =====
Zum installieren des CDT wird zuerst die IDE gestartet. Im Hauptfenster wählt man dann den Menüpunkt '''Help > Install New Software...''' es erscheint ein neuer Dialog. Das Eingabefeld '''Work with:''' wird mit '''http://download.eclipse.org/tools/cdt/releases/indigo''' ausgefüllt und mit der '''Return-Taste''' abgeschickt.

Im unteren Teil des Dialogs werden nun die verfügbaren Plugins aufgelistet, benötigt wird das Plugins '''C/C++ Development Tools''' aus der Rubrik '''CDT Main Features''' und '''C/C++ GDB Hardware Debugging''' aus der Rubrik '''CDT Optional Features'''. Einfach ein Haken vor den Plugins machen und auf '''Next''' klicken. Es erscheint eine Zusammenfassung und eine Seite weiter die Lizenz, die man sich durchlesen sollte und dann bestenfalls bestätigt. Mit einem klick auf '''Finish''' wird das Plugin heruntergeladen und installiert.

Nach der Installation des Plugins sollte Eclipse neu gestartet werden. Auf der Willkommen-Seite ist nun ein Punkt C/C++ Development zusehen bzw. lässt sich im Menü per '''File > New > Project...''' ein C oder C++ Projekt anlegen.

===== GNU ARM Eclipse Plug-in =====
Mit der jetzigen Installation ist es bereits möglich einfache C/C++ Projekte zu erstellen und Makefiles zu importieren. Jetzt fehlt noch das Bindeglied zwischen der Toolchain und Eclipse. Dazu gibt es das [http://sourceforge.net/projects/gnuarmeclipse/ GNU ARM Eclipse Plug-in]. Mit dem Plugin kann man nun die Konfiguration des Compilers und Linkers in Eclipse erledigen was sonst in einem Makefile geschieht.

Die Installation des Plugins funktioniert genauso wie die Installation des CDT, nur mit anderer Quelle. Hier die Kurzfassung:
# '''Help > Install New Software...'''
# '''Work with:''' mit http://gnuarmeclipse.sourceforge.net/updates ausfüllen und mit '''Return-Taste''' bestätigen.
# Einen Haken vor CDT GNU Cross Development Tools machen und '''Next''' drücken.
# Es erscheint eine Zusammenfassung mit '''Next''' zu nächsten Seite.
# Lizenzvereinbarung lesen und akzeptieren Installation mit klick auf '''Finish''' starten.
# Es erscheint noch eine Warnung, dass die Dateien nicht signiert sind. Diesen bitte mit '''OK''' bestätigen.
# Eclipse neu starten.

Beim erstellen eines neuen C oder C++ Projekts kann nun die Toolchain ARM Linux GCC (Sourcery G++ Lite) gewählt werden.
Bevor mit den Beispielen begonnen werden kann muss noch die Frage geklärt werden wie die Daten auf den Chip kommen.
==== stlink ====
Das Entwicklungsboard STM32F4-Discovery von ST kann über USB per STLinkV2 Programmiert werden. Für Linux gibt es da den [https://github.com/texane/stlink "stm32 discovery line linux programmer"]

Die Tools liegen als Quelltext vor und müssen zuerst kompiliert werden. Dann mal los! Solltest du mit deinem Linux noch nie ein Programm kompiliert haben siehe am besten erst in dem Handbuch/Wiki zu deiner Distribution nach was du benötigst (Ubuntu benötigt z.B. die Pakete build-essential und git).

Als erstes die Quelltexte laden
<pre>user@linux:~/src$ git clone git://github.com/texane/stlink.git</pre>
Um die Tools nun kompilieren zu können werden noch die Quelltexte der libusb 1.0 benötigt. Bei einem Ubuntu-System ist dies das Paket libusb-1.0.0-dev (Lubuntu 11.10). 
Jetzt kann der Quelltext kompiliert werden.
<pre>
user@linux:~/src$ cd stlink
user@linux:~/src/stlink$ make
</pre>
Wenn das ganze Fehlerfrei durch gelaufen ist kann man den ganzen Ordner oder alternativ auch nur ./flash/flash und ./gdbserver/st-util kopieren und per Umgebungsvariable PATH verfügbar machen. 
'''Achtung''': Im folgendem Block benenne ich flash in st-flash um, weil ich flash nicht besonders passend finde wenn man es per Umgebungsvariable verfügbar macht.
<pre>
root@linux:~# mkdir /opt/stlink
root@linux:~# cd /opt/stlink
root@linux:/opt/stlink# cp /home/user/src/stlink/flash/flash ./st-flash
root@linux:/opt/stlink# cp /home/user/src/stlink/gdbserver/st-util .
root@linux:/opt/stlink# echo PATH=\"$PATH:/opt/stlink\" >> /etc/environment
root@linux:/opt/stlink# source /etc/environment
</pre>
Nun brauchen die beiden Tools noch Schreibrechte für das USB-Gerät.
<pre>
root@linux:~# cp /home/user/src/stlink/49-stlinkv*.rules /etc/udev/rules.d
root@linux:~# udevadm control --reload-rules
</pre>
Wird nun das STM32F4-Discovery an den PC gesteckt wird ein neues Device erzeugt, bei mir war das '''/dev/stlinkv2_2'''. 
Für Boards mit STLink v1 solltest du dir einmal die README zu stlink durchlesen.

Sollte das soweit alles geklappt haben, ist das jetzt der perfekte Zeitpunkt um ein Backup der Firmware zu machen.
<pre>
user@linux:~$ st-flash read ~/STM32F4-Discovery.bin 0x8000000 0x100000
</pre>
Mit folgendem Befehl kann die Datei wieder zurück geschrieben werden.
<pre>
user@linux:~$ st-flash write ~/STM32F4-Discovery.bin 0x8000000
</pre>
==== stlink in Eclipse einbinden ====
Als nächstes wird der GDB-Server in Eclipse integriert. Man wählt aus dem Hauptmenu '''Run > External Tools > External Tools Configurations...'''.

Ein Klick mit der rechten Maustaste auf '''Program''' und '''New''' auswählen.
Als Name '''ST-Link''' eintragen. Bei Working Directory: wird '''${workspace_loc}${project_path}''' eingetragen.
Auf der Registerkarte '''Build''' wird der Haken vor '''Build before Launch''' raus genommen. Danach auf der Registerkarte '''Common''' einen Haken vor '''External Tools''' im Feld '''Display in Favorites menu''' machen.
Ein Klick auf '''Apply''' und den Dialog mit einem Klick auf '''Close''' schließen.

== Beispiel-Projekte ==
=== Vorbereitungen ===
==== Standard Peripherals Library ====
Bevor jetzt der erste Quelltext in den Editor gehackt wird, kann man sich das Leben etwas leichter machen. STMicroelectronics stellt für seine Microprozessoren Bibliotheken bereit, die einem eine ganze Menge Arbeit abnimmt.

Die Rede ist von der "Standard Peripherals Library", diese lässt sich auf der Seite von [http://www.st.com STMicroelectronics] herunter laden. Der Weg dorthin ist dank einer wunderschön gestalteten Homepage etwas steinig. 
Auf der Hauptseite wählt man zuerst in der Rubrik '''Products''' die Kategorie '''Micros & Memories''' und danach '''Mikrocontrollers'''. Als nächstes wird auf die Registerkarte '''Resources''' gewechselt. Im Bereich '''Software Resources''' wird der Punkt '''Firmware''' ausgewählt. Es öffnet sich ein neues Browserfenster/-tab mit einer Liste von Dateien. Im oberen Bereich gibt es ein Suchfeld. Hier kann nach den "standard peripherals library" gesucht werde
Für das STM32F4-Discovery benötigen wir die Datei [http://www.st.com/internet/com/SOFTWARE_RESOURCES/SW_COMPONENT/FIRMWARE/stm32f4_dsp_stdperiph_lib.zip STM32F4 DSP and standard peripherals library]

Die Datei kann an einen beliebigen Ort entpackt werden.
==== Neues Projekt anlegen ====
Jetzt kann mit der Programmierarbeit begonnen werden. Falls noch nicht geschehen kann nun die IDE gestartet werden, im Terminal geht das bei meiner Installation mit:
<pre>user@linux:~$ /opt/eclipse/eclipse</pre>
Nun wird ein neues Projekt geöffnet folgende Schritte sind nötig:
# File > New > Project...
# C/C++ > C Project; Next
# ARM Cross Target Application > Empty Project
# Toolchains = ARM Linux GCC (Sourcery G++ Lite)
# Project name = (Hier den Projektnamen eingeben); Finish
# Eventuell wird nach der C/C++ Perspective gefragt, diesen Dialog mit '''Yes''' beantworten.
Auf der linken Seite im '''Project Explorer''' siehst du nun das neue Projekt, sobald du die Baumstruktur öffnest sollte bereits ein Ordner '''Includes''' vorhanden sein, dort gibt es bereits 3 Einträge:
* '''/opt/CodeSourcery/arm-2011.09/arm-none-eabi/include'''
* '''/opt/CodeSourcery/arm-2011.09/lib/gcc/arm-none-eabi/4.6.1/include'''
* '''/opt/CodeSourcery/arm-2011.09/lib/gcc/arm-none-eabi/4.6.1/include-fixed'''
Wenn diese Einträge nicht vorhanden sind, ist bis hierhin etwas schief gegangen. Vermutlich wurde die Umgebungsvariable PATH nicht korrekt gesetzt.

Wenn bis hierhin alles geklappt hat können nun die weiteren Einstellungen vorgenommen werden. Zuerst werden die Header-Datei der Standard Peripherals Library hinzu gefügt.
# Project > Properties
# C/C++ General > Paths and Symbols
# Configuration = [All configurations]
# Reiter Includes, Languages = GNU C
Hier werden nun die Pfade zu den Header-Dateien der Standard Peripherals Library eingetragen. Ich habe das von ST heruntergeladene Archiv nach /home/user/eclipse/STM32/ entpackt. daraus ergeben sich für mich folgende Pfade die eingetragen werden müssen:
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Include
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Include
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/STM32F4xx_StdPeriph_Driver/inc
* /${ProjDirPath}
Als nächstes werden die Quellcode-Dateien der Standard Peripherals Library hinzugefügt.
# Reiter Source Location
# Link Folder..., Folder Name = StdPeriph
# Link to folder in the filesystem aktivieren
# Browse..., Verzeichniss = /user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/STM32F4xx_StdPeriph_Driver/src
Jetzt noch 2 Symbole anlegen:
# Reiter Symbols, Languages = GNU C
# Add..., Name: = USE_STDPERIPH_DRIVER > OK
# Add..., Name: = USE_STM32_DISCOVERY > OK
Nun noch ein Linker-Script aktivieren.
# C/C++ Build > Settings
# Configuration = [All configurations]
# ARM Sourcery Linux GCC Linker > General
# Script File (-T) = /${ProjDirPath}/stm32_flash.ld
Als letztes noch das Ausgabeformat auf Binary einstellen.
# ARM Sourcery Linux GNU Create Flash Image > Output
# Output file format (-O) = binary
Der Dialog kann nun mit '''OK''' geschlossen werden.

Jetzt müssen noch 3 Dateien ins Projekt kopiert werden.
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Project/STM32F4xx_StdPeriph_Templates/TrueSTUDIO/STM324xG_EVAL/stm32_flash.ld
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/system_stm32f4xx.c
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/TrueSTUDIO/startup_stm32f4xx.s

'''Die Dateiendung der Datei startup_stm32f4xx.s muss noch in ein geoßes S geändert werden. Ausserdem muss in der Datei folgende Anweisung auskommentiert werden.'''
<pre>
/* Call static constructors */
// bl __libc_init_array
</pre>

'''Hinweis zur Ausgabedatei''' 
Die kompilierte Datei befindet sich im Ordner Debug oder Release im Projektverzeichniss. Die Datei besitzt den Namen des Prejekts und endet auf .hex. Die Endung ist zwar hex beinhaltet aber trotzdem ein Binary.

Jetzt kann mit der Programmierung begonnen werden.
=== Beispiel: Blinky ===
Hier ein Beispiel welches die 4 LEDs um den MEMS-Sensor herum leuchten.

main.c
<c>
#include "stm32f4xx.h"

GPIO_InitTypeDef GPIO_InitStructure;

void Delay(__IO uint32_t nCount) {
while(nCount--) {
}
}

int main(void) {
/* GPIOD Periph clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

/* Configure PD12, 13, 14 and PD15 in output pushpull mode */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);

while (1) {
/* Set PD12 Green */
GPIOD->BSRRL = GPIO_Pin_12;
/* Reset PD13 Orange, PD14 Red, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD13 Orange */
GPIOD->BSRRL = GPIO_Pin_13;
/* Reset PD12 Green, PD14 Red, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_14 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD14 Red */
GPIOD->BSRRL = GPIO_Pin_14;
/* Reset PD12 Green, PD13 Orange, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD15 Blue */
GPIOD->BSRRL = GPIO_Pin_15;
/* Reset PD12 Green, PD13 Orange, PD14 Red */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14;
Delay(10000000L);
}
}
</c>
stm32f4xx_conf.h
<c>
#ifndef __STM32F4xx_CONF_H
#define __STM32F4xx_CONF_H

/* Includes ------------------------------------------------------------------*/
/* Uncomment the line below to enable peripheral header file inclusion */
// #include "stm32f4xx_adc.h"
// #include "stm32f4xx_can.h"
// #include "stm32f4xx_crc.h"
// #include "stm32f4xx_cryp.h"
// #include "stm32f4xx_dac.h"
// #include "stm32f4xx_dbgmcu.h"
// #include "stm32f4xx_dcmi.h"
// #include "stm32f4xx_dma.h"
// #include "stm32f4xx_exti.h"
// #include "stm32f4xx_flash.h"
// #include "stm32f4xx_fsmc.h"
// #include "stm32f4xx_hash.h"
#include "stm32f4xx_gpio.h"
// #include "stm32f4xx_i2c.h"
// #include "stm32f4xx_iwdg.h"
// #include "stm32f4xx_pwr.h"
#include "stm32f4xx_rcc.h"
// #include "stm32f4xx_rng.h"
// #include "stm32f4xx_rtc.h"
// #include "stm32f4xx_sdio.h"
// #include "stm32f4xx_spi.h"
// #include "stm32f4xx_syscfg.h"
// #include "stm32f4xx_tim.h"
// #include "stm32f4xx_usart.h"
// #include "stm32f4xx_wwdg.h"
// #include "misc.h"

#ifdef USE_FULL_ASSERT
#define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
void assert_failed(uint8_t* file, uint32_t line);
#else
#define assert_param(expr) ((void)0)
#endif

#endif
</c>
[[Kategorie:STM32]]

STM32F4-Discovery

2012-02-03T17:44:31Z

Avr-frickler: /* CDT (C/C++ Development Tooling) */ Erweiterung um das Plugin C/C++ GDB Hardware Debugging

Dieser Wiki-Artikel soll den Einstieg in die Prozessorfamilie STM32 von [http://www.st.com STMicroelectronics] erleichtern. Der Artikel begleitet dich von der Installation der benötigten Software bis hin zum flashen des Beispiels in den Prozessor. 
Da es für Windows schon einiges im Internet zu finden gibt, wird die Installation der Toolchain für Linux beschrieben. Die verwendeten Tools sind allerdings als Quelltext oder als Windows-Installation verfügbar, somit lassen sich die meisten Schritte auch auf Windows-Betriebssystemen nachvollziehen.
== Hardware ==
Das in diesem Artikel verwendete Board [http://www.st.com/internet/evalboard/product/252419.jsp STM32F4-Discovery] lässt sich z.B. bei [http://www.watterott.com/de/STM32F4Discovery Watterott] bestellen.
Es lassen sich auch andere Boards verwenden, allerdings müssen die Beispiele dem Schaltplan entsprechend angepasst werden.
== Software ==
Um das Dateisystem möglicht sauber zu halten installiere ich hier sämtliche Software in das Unterverzeichnis /opt welches für solche Installationen vorgesehen ist. Damit auf dieses Verzeichnis schreibend zugegriffen werden darf sind root-Rechte erforderlich. Ich werde vor den Befehlen immer den Prompt schreiben damit zu erkennen ist welche Rechte notwendig sind.

Es ist natürlich auch möglich alles in sein Heimat-Verzeichnis zu schreiben, hier kommt man dann grössten Teils ohne root-Rechte aus. Das muss aber jeder für sich selbst entscheiden wie er es mag.

Nicht alle Linux-Distributionen sind gleich, ich arbeite hier mit einem (fast) frischem Lubuntu 11.10. Der grösste Teil sollte also mit Ubuntu und Debian-Systemen funktionieren. Für andere Distributionen kann man den entsprechenden Abschnitt editieren oder auf der [[Diskussion:STM32F4-Discovery]] zu diesem Artikel vermerken.
==== Sourcery CodeBench Lite Edition for ARM EABI ====
[[Datei:Sup_processors.jpg|thumb|left]]
Als erstes benötigen wir die Toolchain mit Compiler & Linker. Hier verwenden wir die [http://www.mentor.com/embedded-software/sourcery-tools/sourcery-codebench/editions/lite-edition/ Sourcery Codebench von Mentor]. In der Auswahlbox "Supported Prozessors" wählt man in der Rubrik "ARM processors" den Punkt "Download the EABI Release >" aus.

Leider muss man sich registrieren. Nach der Registrierung erhält man einen Link per E-Mail zur Downloadseite. Man wählt das "Recommended Release" aus und lädt dort die Datei "IA32 GNU/Linux TAR" herunter.

[https://sourcery.mentor.com/sgpp/lite/arm/portal/package9740/public/arm-none-eabi/arm-2011.09-69-arm-none-eabi-i686-pc-linux-gnu.tar.bz2 Direktlink Linux] [https://sourcery.mentor.com/sgpp/lite/arm/portal/package9741/public/arm-none-eabi/arm-2011.09-69-arm-none-eabi-i686-mingw32.tar.bz2 Direktlink Windows]

Die Datei muss einfach nur an einem beliebigem Ort entpackt werden und die Umgebungsvariable PATH erweitert werden.

<pre>
root@linux:/home/user/Downloads# mkdir /opt/CodeSourcery
root@linux:/home/user/Downloads# cd /opt/CodeSourcery
root@linux:/opt/CodeSourcery# tar xvf /home/user/Downloads/arm-2011.09-69-arm-none-eabi-i686-pc-linux-gnu.tar.bz2
root@linux:/opt/CodeSourcery# ls
arm-2011.09
</pre>

Anpassen der Umgebungsvariable PATH, die Anpassung ermöglicht es Eclipse den Compiler im Dateisystem zu finden ohne den absoluten Pfad anzugeben. 
Es gibt verschiedene Orte wo sich die Variable anpassen lässt. Auf meinem System habe ich die Datei /etc/environment angepasst.

<pre>
root@linux:/opt/CodeSourcery# echo PATH=\"$PATH:/opt/CodeSourcery/arm-2011.09/bin\" >> /etc/environment
root@linux:/opt/CodeSourcery# source /etc/environment
root@linux:/opt/CodeSourcery# arm-none-eabi-gcc --version
arm-none-eabi-gcc (Sourcery CodeBench Lite 2011.09-69) 4.6.1
Copyright (C) 2011 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
</pre>

Wer gerne mit der Konsole & vi/emacs arbeitet kann sofort zum Abschnitt stlink springen, für die Klickibunti-Fraktion folgt jetzt die Installation der IDE.
==== Eclipse IDE ====
Nach der Installation der Toolchain folgt jetzt die IDE hier habe ich mich für Eclipse entschieden. Zunächst sucht man sich auf [http://www.eclipse.org/downloads/ eclipse.org] aus einen der vielen Pakete das für sich passende raus. Das sinnvollste an dieser Stelle ist "Eclipse IDE for C/C++ Developers". Wer aber vor hat die IDE nicht nur für C/C++ zu verwenden ist mit "Eclipse Classic" vielleicht besser bedient.

Ich werde hier Eclipse Classic 3.7.1 verwenden und zeigen wie das CDT (C/C++ Development Tooling) installiert wird.
Um Eclipse zu "installieren" muss das Archiv nur an einem Ort seiner Wahl entpackt werden.
<pre>
root@linux:/home/user/Downloads# cd /opt
root@linux:/opt# tar xvf /home/user/Downloads/eclipse-SDK-3.7.1-linux-gtk.tar.gz
</pre>
Die IDE lässt sich nun wie folgt starten:
<pre>
user@linux:~$ /opt/eclipse/eclipse
</pre>
Wie ein Starter angelegt wird liest du am besten im Handbuch/Wiki zu deiner Distribution nach.

Als nächstes folgt die Installation der benötigten Plugins. Der Abschnitt "CDT (C/C++ Development Tooling)" kann übersprungen werden, wenn man das Eclipse-Paket "Eclipse IDE for C/C++ Developers" installiert hat.
===== CDT (C/C++ Development Tooling) =====
Zum installieren des CDT wird zuerst die IDE gestartet. Im Hauptfenster wählt man dann den Menüpunkt '''Help > Install New Software...''' es erscheint ein neuer Dialog. Das Eingabefeld '''Work with:''' wird mit '''http://download.eclipse.org/tools/cdt/releases/indigo''' ausgefüllt und mit der '''Return-Taste''' abgeschickt.

Im unteren Teil des Dialogs werden nun die verfügbaren Plugins aufgelistet, benötigt wird das Plugins '''C/C++ Development Tools''' aus der Rubrik '''CDT Main Features''' und '''C/C++ GDB Hardware Debugging''' aus der Rubrik '''CDT Optional Features'''. Einfach ein Haken vor den Plugins machen und auf '''Next''' klicken. Es erscheint eine Zusammenfassung und eine Seite weiter die Lizenz, die man sich durchlesen sollte und dann bestenfalls bestätigt. Mit einem klick auf '''Finish''' wird das Plugin heruntergeladen und installiert.

Nach der Installation des Plugins sollte Eclipse neu gestartet werden. Auf der Willkommen-Seite ist nun ein Punkt C/C++ Development zusehen bzw. lässt sich im Menü per '''File > New > Project...''' ein C oder C++ Projekt anlegen.

===== GNU ARM Eclipse Plug-in =====
Mit der jetzigen Installation ist es bereits möglich einfache C/C++ Projekte zu erstellen und Makefiles zu importieren. Jetzt fehlt noch das Bindeglied zwischen der Toolchain und Eclipse. Dazu gibt es das [http://sourceforge.net/projects/gnuarmeclipse/ GNU ARM Eclipse Plug-in]. Mit dem Plugin kann man nun die Konfiguration des Compilers und Linkers in Eclipse erledigen was sonst in einem Makefile geschieht.

Die Installation des Plugins funktioniert genauso wie die Installation des CDT, nur mit anderer Quelle. Hier die Kurzfassung:
# '''Help > Install New Software...'''
# '''Work with:''' mit http://gnuarmeclipse.sourceforge.net/updates ausfüllen und mit '''Return-Taste''' bestätigen.
# Einen Haken vor CDT GNU Cross Development Tools machen und '''Next''' drücken.
# Es erscheint eine Zusammenfassung mit '''Next''' zu nächsten Seite.
# Lizenzvereinbarung lesen und akzeptieren Installation mit klick auf '''Finish''' starten.
# Es erscheint noch eine Warnung, dass die Dateien nicht signiert sind. Diesen bitte mit '''OK''' bestätigen.
# Eclipse neu starten.

Beim erstellen eines neuen C oder C++ Projekts kann nun die Toolchain ARM Linux GCC (Sourcery G++ Lite) gewählt werden.
Bevor mit den Beispielen begonnen werden kann muss noch die Frage geklärt werden wie die Daten auf den Chip kommen.
==== stlink ====
Das Entwicklungsboard STM32F4-Discovery von ST kann über USB per STLinkV2 Programmiert werden. Für Linux gibt es da den [https://github.com/texane/stlink "stm32 discovery line linux programmer"]

Die Tools liegen als Quelltext vor und müssen zuerst kompiliert werden. Dann mal los! Solltest du mit deinem Linux noch nie ein Programm kompiliert haben siehe am besten erst in dem Handbuch/Wiki zu deiner Distribution nach was du benötigst (Ubuntu benötigt z.B. die Pakete build-essential und git).

Als erstes die Quelltexte laden
<pre>user@linux:~/src$ git clone git://github.com/texane/stlink.git</pre>
Um die Tools nun kompilieren zu können werden noch die Quelltexte der libusb 1.0 benötigt. Bei einem Ubuntu-System ist dies das Paket libusb-1.0.0-dev (Lubuntu 11.10). 
Jetzt kann der Quelltext kompiliert werden.
<pre>
user@linux:~/src$ cd stlink
user@linux:~/src/stlink$ make
</pre>
Wenn das ganze Fehlerfrei durch gelaufen ist kann man den ganzen Ordner oder alternativ auch nur ./flash/flash und ./gdbserver/st-util kopieren und per Umgebungsvariable PATH verfügbar machen. 
'''Achtung''': Im folgendem Block benenne ich flash in st-flash um, weil ich flash nicht besonders passend finde wenn man es per Umgebungsvariable verfügbar macht.
<pre>
root@linux:~# mkdir /opt/stlink
root@linux:~# cd /opt/stlink
root@linux:/opt/stlink# cp /home/user/src/stlink/flash/flash ./st-flash
root@linux:/opt/stlink# cp /home/user/src/stlink/gdbserver/st-util .
root@linux:/opt/stlink# echo PATH=\"$PATH:/opt/stlink\" >> /etc/environment
root@linux:/opt/stlink# source /etc/environment
</pre>
Nun brauchen die beiden Tools noch Schreibrechte für das USB-Gerät.
<pre>
root@linux:~# cp /home/user/src/stlink/49-stlinkv*.rules /etc/udev/rules.d
root@linux:~# udevadm control --reload-rules
</pre>
Wird nun das STM32F4-Discovery an den PC gesteckt wird ein neues Device erzeugt, bei mir war das '''/dev/stlinkv2_2'''. 
Für Boards mit STLink v1 solltest du dir einmal die README zu stlink durchlesen.

Sollte das soweit alles geklappt haben, ist das jetzt der perfekte Zeitpunkt um ein Backup der Firmware zu machen.
<pre>
user@linux:~$ st-flash read ~/STM32F4-Discovery.bin 0x8000000 0x100000
</pre>
Mit folgendem Befehl kann die Datei wieder zurück geschrieben werden.
<pre>
user@linux:~$ st-flash write ~/STM32F4-Discovery.bin 0x8000000
</pre>
==== TODO ====
Einbindung des gdb-Servers und flash-Tools in Eclipse.
== Beispiel-Projekte ==
=== Vorbereitungen ===
==== Standard Peripherals Library ====
Bevor jetzt der erste Quelltext in den Editor gehackt wird, kann man sich das Leben etwas leichter machen. STMicroelectronics stellt für seine Microprozessoren Bibliotheken bereit, die einem eine ganze Menge Arbeit abnimmt.

Die Rede ist von der "Standard Peripherals Library", diese lässt sich auf der Seite von [http://www.st.com STMicroelectronics] herunter laden. Der Weg dorthin ist dank einer wunderschön gestalteten Homepage etwas steinig. 
Auf der Hauptseite wählt man zuerst in der Rubrik '''Products''' die Kategorie '''Micros & Memories''' und danach '''Mikrocontrollers'''. Als nächstes wird auf die Registerkarte '''Resources''' gewechselt. Im Bereich '''Software Resources''' wird der Punkt '''Firmware''' ausgewählt. Es öffnet sich ein neues Browserfenster/-tab mit einer Liste von Dateien. Im oberen Bereich gibt es ein Suchfeld. Hier kann nach den "standard peripherals library" gesucht werde
Für das STM32F4-Discovery benötigen wir die Datei [http://www.st.com/internet/com/SOFTWARE_RESOURCES/SW_COMPONENT/FIRMWARE/stm32f4_dsp_stdperiph_lib.zip STM32F4 DSP and standard peripherals library]

Die Datei kann an einen beliebigen Ort entpackt werden.
==== Neues Projekt anlegen ====
Jetzt kann mit der Programmierarbeit begonnen werden. Falls noch nicht geschehen kann nun die IDE gestartet werden, im Terminal geht das bei meiner Installation mit:
<pre>user@linux:~$ /opt/eclipse/eclipse</pre>
Nun wird ein neues Projekt geöffnet folgende Schritte sind nötig:
# File > New > Project...
# C/C++ > C Project; Next
# ARM Cross Target Application > Empty Project
# Toolchains = ARM Linux GCC (Sourcery G++ Lite)
# Project name = (Hier den Projektnamen eingeben); Finish
# Eventuell wird nach der C/C++ Perspective gefragt, diesen Dialog mit '''Yes''' beantworten.
Auf der linken Seite im '''Project Explorer''' siehst du nun das neue Projekt, sobald du die Baumstruktur öffnest sollte bereits ein Ordner '''Includes''' vorhanden sein, dort gibt es bereits 3 Einträge:
* '''/opt/CodeSourcery/arm-2011.09/arm-none-eabi/include'''
* '''/opt/CodeSourcery/arm-2011.09/lib/gcc/arm-none-eabi/4.6.1/include'''
* '''/opt/CodeSourcery/arm-2011.09/lib/gcc/arm-none-eabi/4.6.1/include-fixed'''
Wenn diese Einträge nicht vorhanden sind, ist bis hierhin etwas schief gegangen. Vermutlich wurde die Umgebungsvariable PATH nicht korrekt gesetzt.

Wenn bis hierhin alles geklappt hat können nun die weiteren Einstellungen vorgenommen werden. Zuerst werden die Header-Datei der Standard Peripherals Library hinzu gefügt.
# Project > Properties
# C/C++ General > Paths and Symbols
# Configuration = [All configurations]
# Reiter Includes, Languages = GNU C
Hier werden nun die Pfade zu den Header-Dateien der Standard Peripherals Library eingetragen. Ich habe das von ST heruntergeladene Archiv nach /home/user/eclipse/STM32/ entpackt. daraus ergeben sich für mich folgende Pfade die eingetragen werden müssen:
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Include
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Include
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/STM32F4xx_StdPeriph_Driver/inc
* /${ProjDirPath}
Als nächstes werden die Quellcode-Dateien der Standard Peripherals Library hinzugefügt.
# Reiter Source Location
# Link Folder..., Folder Name = StdPeriph
# Link to folder in the filesystem aktivieren
# Browse..., Verzeichniss = /user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/STM32F4xx_StdPeriph_Driver/src
Jetzt noch 2 Symbole anlegen:
# Reiter Symbols, Languages = GNU C
# Add..., Name: = USE_STDPERIPH_DRIVER > OK
# Add..., Name: = USE_STM32_DISCOVERY > OK
Nun noch ein Linker-Script aktivieren.
# C/C++ Build > Settings
# Configuration = [All configurations]
# ARM Sourcery Linux GCC Linker > General
# Script File (-T) = /${ProjDirPath}/stm32_flash.ld
Als letztes noch das Ausgabeformat auf Binary einstellen.
# ARM Sourcery Linux GNU Create Flash Image > Output
# Output file format (-O) = binary
Der Dialog kann nun mit '''OK''' geschlossen werden.

Jetzt müssen noch 3 Dateien ins Projekt kopiert werden.
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Project/STM32F4xx_StdPeriph_Templates/TrueSTUDIO/STM324xG_EVAL/stm32_flash.ld
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/system_stm32f4xx.c
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/TrueSTUDIO/startup_stm32f4xx.s

'''Die Dateiendung der Datei startup_stm32f4xx.s muss noch in ein geoßes S geändert werden. Ausserdem muss in der Datei folgende Anweisung auskommentiert werden.'''
<pre>
/* Call static constructors */
// bl __libc_init_array
</pre>

'''Hinweis zur Ausgabedatei''' 
Die kompilierte Datei befindet sich im Ordner Debug oder Release im Projektverzeichniss. Die Datei besitzt den Namen des Prejekts und endet auf .hex. Die Endung ist zwar hex beinhaltet aber trotzdem ein Binary.

Jetzt kann mit der Programmierung begonnen werden.
=== Beispiel: Blinky ===
Hier ein Beispiel welches die 4 LEDs um den MEMS-Sensor herum leuchten.

main.c
<c>
#include "stm32f4xx.h"

GPIO_InitTypeDef GPIO_InitStructure;

void Delay(__IO uint32_t nCount) {
while(nCount--) {
}
}

int main(void) {
/* GPIOD Periph clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

/* Configure PD12, 13, 14 and PD15 in output pushpull mode */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);

while (1) {
/* Set PD12 Green */
GPIOD->BSRRL = GPIO_Pin_12;
/* Reset PD13 Orange, PD14 Red, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD13 Orange */
GPIOD->BSRRL = GPIO_Pin_13;
/* Reset PD12 Green, PD14 Red, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_14 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD14 Red */
GPIOD->BSRRL = GPIO_Pin_14;
/* Reset PD12 Green, PD13 Orange, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD15 Blue */
GPIOD->BSRRL = GPIO_Pin_15;
/* Reset PD12 Green, PD13 Orange, PD14 Red */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14;
Delay(10000000L);
}
}
</c>
stm32f4xx_conf.h
<c>
#ifndef __STM32F4xx_CONF_H
#define __STM32F4xx_CONF_H

/* Includes ------------------------------------------------------------------*/
/* Uncomment the line below to enable peripheral header file inclusion */
// #include "stm32f4xx_adc.h"
// #include "stm32f4xx_can.h"
// #include "stm32f4xx_crc.h"
// #include "stm32f4xx_cryp.h"
// #include "stm32f4xx_dac.h"
// #include "stm32f4xx_dbgmcu.h"
// #include "stm32f4xx_dcmi.h"
// #include "stm32f4xx_dma.h"
// #include "stm32f4xx_exti.h"
// #include "stm32f4xx_flash.h"
// #include "stm32f4xx_fsmc.h"
// #include "stm32f4xx_hash.h"
#include "stm32f4xx_gpio.h"
// #include "stm32f4xx_i2c.h"
// #include "stm32f4xx_iwdg.h"
// #include "stm32f4xx_pwr.h"
#include "stm32f4xx_rcc.h"
// #include "stm32f4xx_rng.h"
// #include "stm32f4xx_rtc.h"
// #include "stm32f4xx_sdio.h"
// #include "stm32f4xx_spi.h"
// #include "stm32f4xx_syscfg.h"
// #include "stm32f4xx_tim.h"
// #include "stm32f4xx_usart.h"
// #include "stm32f4xx_wwdg.h"
// #include "misc.h"

#ifdef USE_FULL_ASSERT
#define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
void assert_failed(uint8_t* file, uint32_t line);
#else
#define assert_param(expr) ((void)0)
#endif

#endif
</c>
[[Kategorie:STM32]]

STM32F4-Discovery

2012-01-27T20:23:56Z

Avr-frickler: Abschnitt Vorbereitungen ertweitert, Beispiel hinzugefügt

Dieser Wiki-Artikel soll den Einstieg in die Prozessorfamilie STM32 von [http://www.st.com STMicroelectronics] erleichtern. Der Artikel begleitet dich von der Installation der benötigten Software bis hin zum flashen des Beispiels in den Prozessor. 
Da es für Windows schon einiges im Internet zu finden gibt, wird die Installation der Toolchain für Linux beschrieben. Die verwendeten Tools sind allerdings als Quelltext oder als Windows-Installation verfügbar, somit lassen sich die meisten Schritte auch auf Windows-Betriebssystemen nachvollziehen.
== Hardware ==
Das in diesem Artikel verwendete Board [http://www.st.com/internet/evalboard/product/252419.jsp STM32F4-Discovery] lässt sich z.B. bei [http://www.watterott.com/de/STM32F4Discovery Watterott] bestellen.
Es lassen sich auch andere Boards verwenden, allerdings müssen die Beispiele dem Schaltplan entsprechend angepasst werden.
== Software ==
Um das Dateisystem möglicht sauber zu halten installiere ich hier sämtliche Software in das Unterverzeichnis /opt welches für solche Installationen vorgesehen ist. Damit auf dieses Verzeichnis schreibend zugegriffen werden darf sind root-Rechte erforderlich. Ich werde vor den Befehlen immer den Prompt schreiben damit zu erkennen ist welche Rechte notwendig sind.

Es ist natürlich auch möglich alles in sein Heimat-Verzeichnis zu schreiben, hier kommt man dann grössten Teils ohne root-Rechte aus. Das muss aber jeder für sich selbst entscheiden wie er es mag.

Nicht alle Linux-Distributionen sind gleich, ich arbeite hier mit einem (fast) frischem Lubuntu 11.10. Der grösste Teil sollte also mit Ubuntu und Debian-Systemen funktionieren. Für andere Distributionen kann man den entsprechenden Abschnitt editieren oder auf der [[Diskussion:STM32F4-Discovery]] zu diesem Artikel vermerken.
==== Sourcery CodeBench Lite Edition for ARM EABI ====
[[Datei:Sup_processors.jpg|thumb|left]]
Als erstes benötigen wir die Toolchain mit Compiler & Linker. Hier verwenden wir die [http://www.mentor.com/embedded-software/sourcery-tools/sourcery-codebench/editions/lite-edition/ Sourcery Codebench von Mentor]. In der Auswahlbox "Supported Prozessors" wählt man in der Rubrik "ARM processors" den Punkt "Download the EABI Release >" aus.

Leider muss man sich registrieren. Nach der Registrierung erhält man einen Link per E-Mail zur Downloadseite. Man wählt das "Recommended Release" aus und lädt dort die Datei "IA32 GNU/Linux TAR" herunter.

[https://sourcery.mentor.com/sgpp/lite/arm/portal/package9740/public/arm-none-eabi/arm-2011.09-69-arm-none-eabi-i686-pc-linux-gnu.tar.bz2 Direktlink Linux] [https://sourcery.mentor.com/sgpp/lite/arm/portal/package9741/public/arm-none-eabi/arm-2011.09-69-arm-none-eabi-i686-mingw32.tar.bz2 Direktlink Windows]

Die Datei muss einfach nur an einem beliebigem Ort entpackt werden und die Umgebungsvariable PATH erweitert werden.

<pre>
root@linux:/home/user/Downloads# mkdir /opt/CodeSourcery
root@linux:/home/user/Downloads# cd /opt/CodeSourcery
root@linux:/opt/CodeSourcery# tar xvf /home/user/Downloads/arm-2011.09-69-arm-none-eabi-i686-pc-linux-gnu.tar.bz2
root@linux:/opt/CodeSourcery# ls
arm-2011.09
</pre>

Anpassen der Umgebungsvariable PATH, die Anpassung ermöglicht es Eclipse den Compiler im Dateisystem zu finden ohne den absoluten Pfad anzugeben. 
Es gibt verschiedene Orte wo sich die Variable anpassen lässt. Auf meinem System habe ich die Datei /etc/environment angepasst.

<pre>
root@linux:/opt/CodeSourcery# echo PATH=\"$PATH:/opt/CodeSourcery/arm-2011.09/bin\" >> /etc/environment
root@linux:/opt/CodeSourcery# source /etc/environment
root@linux:/opt/CodeSourcery# arm-none-eabi-gcc --version
arm-none-eabi-gcc (Sourcery CodeBench Lite 2011.09-69) 4.6.1
Copyright (C) 2011 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
</pre>

Wer gerne mit der Konsole & vi/emacs arbeitet kann sofort zum Abschnitt stlink springen, für die Klickibunti-Fraktion folgt jetzt die Installation der IDE.
==== Eclipse IDE ====
Nach der Installation der Toolchain folgt jetzt die IDE hier habe ich mich für Eclipse entschieden. Zunächst sucht man sich auf [http://www.eclipse.org/downloads/ eclipse.org] aus einen der vielen Pakete das für sich passende raus. Das sinnvollste an dieser Stelle ist "Eclipse IDE for C/C++ Developers". Wer aber vor hat die IDE nicht nur für C/C++ zu verwenden ist mit "Eclipse Classic" vielleicht besser bedient.

Ich werde hier Eclipse Classic 3.7.1 verwenden und zeigen wie das CDT (C/C++ Development Tooling) installiert wird.
Um Eclipse zu "installieren" muss das Archiv nur an einem Ort seiner Wahl entpackt werden.
<pre>
root@linux:/home/user/Downloads# cd /opt
root@linux:/opt# tar xvf /home/user/Downloads/eclipse-SDK-3.7.1-linux-gtk.tar.gz
</pre>
Die IDE lässt sich nun wie folgt starten:
<pre>
user@linux:~$ /opt/eclipse/eclipse
</pre>
Wie ein Starter angelegt wird liest du am besten im Handbuch/Wiki zu deiner Distribution nach.

Als nächstes folgt die Installation der benötigten Plugins. Der Abschnitt "CDT (C/C++ Development Tooling)" kann übersprungen werden, wenn man das Eclipse-Paket "Eclipse IDE for C/C++ Developers" installiert hat.
===== CDT (C/C++ Development Tooling) =====
Zum installieren des CDT wird zuerst die IDE gestartet. Im Hauptfenster wählt man dann den Menüpunkt '''Help > Install New Software...''' es erscheint ein neuer Dialog. Das Eingabefeld '''Work with:''' wird mit '''http://download.eclipse.org/tools/cdt/releases/indigo''' ausgefüllt und mit der '''Return-Taste''' abgeschickt.

Im unteren Teil des Dialogs werden nun die verfügbaren Plugins aufgelistet, benötigt wird das Plugin '''C/C++ Development Tools''' aus der Rubrik '''CDT Main Features'''. Einfach ein Haken davor machen und auf '''Next''' klicken. Es erscheint eine Zusammenfassung und eine Seite weiter die Lizenz, die man sich durchlesen sollte und dann bestenfalls bestätigt. Mit einem klick auf '''Finish''' wird das Plugin heruntergeladen und installiert.

Nach der Installation des Plugins sollte Eclipse neu gestartet werden. Auf der Willkommen-Seite ist nun ein Punkt C/C++ Development zusehen bzw. lässt sich im Menü per '''File > New > Project...''' ein C oder C++ Projekt anlegen.
===== GNU ARM Eclipse Plug-in =====
Mit der jetzigen Installation ist es bereits möglich einfache C/C++ Projekte zu erstellen und Makefiles zu importieren. Jetzt fehlt noch das Bindeglied zwischen der Toolchain und Eclipse. Dazu gibt es das [http://sourceforge.net/projects/gnuarmeclipse/ GNU ARM Eclipse Plug-in]. Mit dem Plugin kann man nun die Konfiguration des Compilers und Linkers in Eclipse erledigen was sonst in einem Makefile geschieht.

Die Installation des Plugins funktioniert genauso wie die Installation des CDT, nur mit anderer Quelle. Hier die Kurzfassung:
# '''Help > Install New Software...'''
# '''Work with:''' mit http://gnuarmeclipse.sourceforge.net/updates ausfüllen und mit '''Return-Taste''' bestätigen.
# Einen Haken vor CDT GNU Cross Development Tools machen und '''Next''' drücken.
# Es erscheint eine Zusammenfassung mit '''Next''' zu nächsten Seite.
# Lizenzvereinbarung lesen und akzeptieren Installation mit klick auf '''Finish''' starten.
# Es erscheint noch eine Warnung, dass die Dateien nicht signiert sind. Diesen bitte mit '''OK''' bestätigen.
# Eclipse neu starten.

Beim erstellen eines neuen C oder C++ Projekts kann nun die Toolchain ARM Linux GCC (Sourcery G++ Lite) gewählt werden.
Bevor mit den Beispielen begonnen werden kann muss noch die Frage geklärt werden wie die Daten auf den Chip kommen.
==== stlink ====
Das Entwicklungsboard STM32F4-Discovery von ST kann über USB per STLinkV2 Programmiert werden. Für Linux gibt es da den [https://github.com/texane/stlink "stm32 discovery line linux programmer"]

Die Tools liegen als Quelltext vor und müssen zuerst kompiliert werden. Dann mal los! Solltest du mit deinem Linux noch nie ein Programm kompiliert haben siehe am besten erst in dem Handbuch/Wiki zu deiner Distribution nach was du benötigst (Ubuntu benötigt z.B. die Pakete build-essential und git).

Als erstes die Quelltexte laden
<pre>user@linux:~/src$ git clone git://github.com/texane/stlink.git</pre>
Um die Tools nun kompilieren zu können werden noch die Quelltexte der libusb 1.0 benötigt. Bei einem Ubuntu-System ist dies das Paket libusb-1.0.0-dev (Lubuntu 11.10). 
Jetzt kann der Quelltext kompiliert werden.
<pre>
user@linux:~/src$ cd stlink
user@linux:~/src/stlink$ make
</pre>
Wenn das ganze Fehlerfrei durch gelaufen ist kann man den ganzen Ordner oder alternativ auch nur ./flash/flash und ./gdbserver/st-util kopieren und per Umgebungsvariable PATH verfügbar machen. 
'''Achtung''': Im folgendem Block benenne ich flash in st-flash um, weil ich flash nicht besonders passend finde wenn man es per Umgebungsvariable verfügbar macht.
<pre>
root@linux:~# mkdir /opt/stlink
root@linux:~# cd /opt/stlink
root@linux:/opt/stlink# cp /home/user/src/stlink/flash/flash ./st-flash
root@linux:/opt/stlink# cp /home/user/src/stlink/gdbserver/st-util .
root@linux:/opt/stlink# echo PATH=\"$PATH:/opt/stlink\" >> /etc/environment
root@linux:/opt/stlink# source /etc/environment
</pre>
Nun brauchen die beiden Tools noch Schreibrechte für das USB-Gerät.
<pre>
root@linux:~# cp /home/user/src/stlink/49-stlinkv*.rules /etc/udev/rules.d
root@linux:~# udevadm control --reload-rules
</pre>
Wird nun das STM32F4-Discovery an den PC gesteckt wird ein neues Device erzeugt, bei mir war das '''/dev/stlinkv2_2'''. 
Für Boards mit STLink v1 solltest du dir einmal die README zu stlink durchlesen.

Sollte das soweit alles geklappt haben, ist das jetzt der perfekte Zeitpunkt um ein Backup der Firmware zu machen.
<pre>
user@linux:~$ st-flash read ~/STM32F4-Discovery.bin 0x8000000 0x100000
</pre>
Mit folgendem Befehl kann die Datei wieder zurück geschrieben werden.
<pre>
user@linux:~$ st-flash write ~/STM32F4-Discovery.bin 0x8000000
</pre>
==== TODO ====
Einbindung des gdb-Servers und flash-Tools in Eclipse.
== Beispiel-Projekte ==
=== Vorbereitungen ===
==== Standard Peripherals Library ====
Bevor jetzt der erste Quelltext in den Editor gehackt wird, kann man sich das Leben etwas leichter machen. STMicroelectronics stellt für seine Microprozessoren Bibliotheken bereit, die einem eine ganze Menge Arbeit abnimmt.

Die Rede ist von der "Standard Peripherals Library", diese lässt sich auf der Seite von [http://www.st.com STMicroelectronics] herunter laden. Der Weg dorthin ist dank einer wunderschön gestalteten Homepage etwas steinig. 
Auf der Hauptseite wählt man zuerst in der Rubrik '''Products''' die Kategorie '''Micros & Memories''' und danach '''Mikrocontrollers'''. Als nächstes wird auf die Registerkarte '''Resources''' gewechselt. Im Bereich '''Software Resources''' wird der Punkt '''Firmware''' ausgewählt. Es öffnet sich ein neues Browserfenster/-tab mit einer Liste von Dateien. Im oberen Bereich gibt es ein Suchfeld. Hier kann nach den "standard peripherals library" gesucht werde
Für das STM32F4-Discovery benötigen wir die Datei [http://www.st.com/internet/com/SOFTWARE_RESOURCES/SW_COMPONENT/FIRMWARE/stm32f4_dsp_stdperiph_lib.zip STM32F4 DSP and standard peripherals library]

Die Datei kann an einen beliebigen Ort entpackt werden.
==== Neues Projekt anlegen ====
Jetzt kann mit der Programmierarbeit begonnen werden. Falls noch nicht geschehen kann nun die IDE gestartet werden, im Terminal geht das bei meiner Installation mit:
<pre>user@linux:~$ /opt/eclipse/eclipse</pre>
Nun wird ein neues Projekt geöffnet folgende Schritte sind nötig:
# File > New > Project...
# C/C++ > C Project; Next
# ARM Cross Target Application > Empty Project
# Toolchains = ARM Linux GCC (Sourcery G++ Lite)
# Project name = (Hier den Projektnamen eingeben); Finish
# Eventuell wird nach der C/C++ Perspective gefragt, diesen Dialog mit '''Yes''' beantworten.
Auf der linken Seite im '''Project Explorer''' siehst du nun das neue Projekt, sobald du die Baumstruktur öffnest sollte bereits ein Ordner '''Includes''' vorhanden sein, dort gibt es bereits 3 Einträge:
* '''/opt/CodeSourcery/arm-2011.09/arm-none-eabi/include'''
* '''/opt/CodeSourcery/arm-2011.09/lib/gcc/arm-none-eabi/4.6.1/include'''
* '''/opt/CodeSourcery/arm-2011.09/lib/gcc/arm-none-eabi/4.6.1/include-fixed'''
Wenn diese Einträge nicht vorhanden sind, ist bis hierhin etwas schief gegangen. Vermutlich wurde die Umgebungsvariable PATH nicht korrekt gesetzt.

Wenn bis hierhin alles geklappt hat können nun die weiteren Einstellungen vorgenommen werden. Zuerst werden die Header-Datei der Standard Peripherals Library hinzu gefügt.
# Project > Properties
# C/C++ General > Paths and Symbols
# Configuration = [All configurations]
# Reiter Includes, Languages = GNU C
Hier werden nun die Pfade zu den Header-Dateien der Standard Peripherals Library eingetragen. Ich habe das von ST heruntergeladene Archiv nach /home/user/eclipse/STM32/ entpackt. daraus ergeben sich für mich folgende Pfade die eingetragen werden müssen:
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Include
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Include
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/STM32F4xx_StdPeriph_Driver/inc
* /${ProjDirPath}
Als nächstes werden die Quellcode-Dateien der Standard Peripherals Library hinzugefügt.
# Reiter Source Location
# Link Folder..., Folder Name = StdPeriph
# Link to folder in the filesystem aktivieren
# Browse..., Verzeichniss = /user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/STM32F4xx_StdPeriph_Driver/src
Jetzt noch 2 Symbole anlegen:
# Reiter Symbols, Languages = GNU C
# Add..., Name: = USE_STDPERIPH_DRIVER > OK
# Add..., Name: = USE_STM32_DISCOVERY > OK
Nun noch ein Linker-Script aktivieren.
# C/C++ Build > Settings
# Configuration = [All configurations]
# ARM Sourcery Linux GCC Linker > General
# Script File (-T) = /${ProjDirPath}/stm32_flash.ld
Als letztes noch das Ausgabeformat auf Binary einstellen.
# ARM Sourcery Linux GNU Create Flash Image > Output
# Output file format (-O) = binary
Der Dialog kann nun mit '''OK''' geschlossen werden.

Jetzt müssen noch 3 Dateien ins Projekt kopiert werden.
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Project/STM32F4xx_StdPeriph_Templates/TrueSTUDIO/STM324xG_EVAL/stm32_flash.ld
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/system_stm32f4xx.c
* /home/user/eclipse/STM32/STM32F4xx StdPeriphLib V1.0.0/Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/TrueSTUDIO/startup_stm32f4xx.s

'''Die Dateiendung der Datei startup_stm32f4xx.s muss noch in ein geoßes S geändert werden. Ausserdem muss in der Datei folgende Anweisung auskommentiert werden.'''
<pre>
/* Call static constructors */
// bl __libc_init_array
</pre>

'''Hinweis zur Ausgabedatei''' 
Die kompilierte Datei befindet sich im Ordner Debug oder Release im Projektverzeichniss. Die Datei besitzt den Namen des Prejekts und endet auf .hex. Die Endung ist zwar hex beinhaltet aber trotzdem ein Binary.

Jetzt kann mit der Programmierung begonnen werden.
=== Beispiel: Blinky ===
Hier ein Beispiel welches die 4 LEDs um den MEMS-Sensor herum leuchten.

main.c
<c>
#include "stm32f4xx.h"

GPIO_InitTypeDef GPIO_InitStructure;

void Delay(__IO uint32_t nCount) {
while(nCount--) {
}
}

int main(void) {
/* GPIOD Periph clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

/* Configure PD12, 13, 14 and PD15 in output pushpull mode */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);

while (1) {
/* Set PD12 Green */
GPIOD->BSRRL = GPIO_Pin_12;
/* Reset PD13 Orange, PD14 Red, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD13 Orange */
GPIOD->BSRRL = GPIO_Pin_13;
/* Reset PD12 Green, PD14 Red, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_14 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD14 Red */
GPIOD->BSRRL = GPIO_Pin_14;
/* Reset PD12 Green, PD13 Orange, PD15 Blue */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_15;
Delay(10000000L);

/* Set PD15 Blue */
GPIOD->BSRRL = GPIO_Pin_15;
/* Reset PD12 Green, PD13 Orange, PD14 Red */
GPIOD->BSRRH = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14;
Delay(10000000L);
}
}
</c>
stm32f4xx_conf.h
<c>
#ifndef __STM32F4xx_CONF_H
#define __STM32F4xx_CONF_H

/* Includes ------------------------------------------------------------------*/
/* Uncomment the line below to enable peripheral header file inclusion */
// #include "stm32f4xx_adc.h"
// #include "stm32f4xx_can.h"
// #include "stm32f4xx_crc.h"
// #include "stm32f4xx_cryp.h"
// #include "stm32f4xx_dac.h"
// #include "stm32f4xx_dbgmcu.h"
// #include "stm32f4xx_dcmi.h"
// #include "stm32f4xx_dma.h"
// #include "stm32f4xx_exti.h"
// #include "stm32f4xx_flash.h"
// #include "stm32f4xx_fsmc.h"
// #include "stm32f4xx_hash.h"
#include "stm32f4xx_gpio.h"
// #include "stm32f4xx_i2c.h"
// #include "stm32f4xx_iwdg.h"
// #include "stm32f4xx_pwr.h"
#include "stm32f4xx_rcc.h"
// #include "stm32f4xx_rng.h"
// #include "stm32f4xx_rtc.h"
// #include "stm32f4xx_sdio.h"
// #include "stm32f4xx_spi.h"
// #include "stm32f4xx_syscfg.h"
// #include "stm32f4xx_tim.h"
// #include "stm32f4xx_usart.h"
// #include "stm32f4xx_wwdg.h"
// #include "misc.h"

#ifdef USE_FULL_ASSERT
#define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
void assert_failed(uint8_t* file, uint32_t line);
#else
#define assert_param(expr) ((void)0)
#endif

#endif
</c>
[[Kategorie:STM32]]

STM32F4-Discovery

2012-01-10T21:06:10Z

Avr-frickler: Abschnitt Projekt-Konfiguration hinzugefügt

STM32F4-Discovery

2012-01-10T19:22:54Z

Avr-frickler: Änderung an der Erweiterung der Umgebungsvariablen PATH

STM32F4-Discovery

2012-01-09T20:11:01Z

Avr-frickler: Kleine Änderungen im bisherigen Text und Erweiterung um den Abschnitt zur Standard Library

Diskussion:STM32F4-Discovery

2012-01-09T17:30:48Z

Avr-frickler:

Da es bereits eine allgemeine STM32 Seite gibt (http://www.mikrocontroller.net/articles/STM32), würde ich hier spezielle Informationen zum STM32F4, nach dem Titel sogar spezielle Informationen zu dem Board erwarten.
So aber lese ich vieles, sicher nützliches, was eigentlich auf die allgemeine Seite gehört.
Ich schlage vor, die Informationen die allgemein für die STM32 Reihe gelten von dieser Seite auf die allgemeine Seite zu verlagern.

Wie ich gerade sehe, gibt es sogar schon eine spezielle Seite zur Eclipse-Installation unter http://www.mikrocontroller.net/articles/STM32_Eclipse_Installation.

Ich meine, das es für die Übersichtlichkeit und die Benutzbarkeit nützlich wäre, keine redundanten Seiten zu erstellen.
----
Ja ich geb zu der Name ist irre führend.

Der [[STM32_Eclipse_Installation]] bezieht sich hauptsächlich auf Windows, gerade die verwendete Toolchain YAGARTO gibt es so nicht für Linux, zumindest habe ich auf der Seite nichts dazu gefunden. Die Sachen die dort zu Linux (stlink) sind überhaupt nicht zu gebrauchen da z.B. das git-repos nicht mehr existiert.

Es macht aber sicher Sinn das ganz zu bündeln, wenn ich hier soweit bin das ich alles zusammen habe werde ich mal schauen wie man dies am besten zusammen bekommt.

Die Idee zum Artikel entstammt einem [http://www.mikrocontroller.net/topic/241982 Thread] auf diesem Board.
----
'''BITTE''' mach weiter! Der erwähnte Artikel ([[STM32_Eclipse_Installation]]) ist sowas von unübersichtlich und viel zu lang, dass das einzig sinnvolle eigentlich nur das Löschen wäre. Dieser Artikel ist dagegen sauber aufgebaut. Ich HOFFE es geht weiter, denn an genau am aktuellen Punkt, der Einbindung von stlink und gdb in Eclipse, komme ich nicht weiter.

Wenn dieser Artikel fertig ist, kann man ja noch überlegen den anderen Artikel aufzuräumen/zu ersetzen.
----
Klar mache ich weiter, allerdings brauche ich erst einmal ein funktionierendes Beispiel zum kompilieren ;-) um auch GDB ordentlich testen zu können, habe bisher noch nichts mit GDB gemacht. Aber das wird schon werden.
----
Dann überarbeite doch die Seite ([[STM32_Eclipse_Installation]]).
In Bezug auf die Seiten ([[STM32F4-Discovery]]) und ([[STM32]]) hast Du mich auch nicht überzeugt. Warum zwei Seiten nebeneinander die dann am Ende evtl. ineinander überführt werden sollen?
Na gut. War eine Anregung. Deine Entscheidung wie Du es machst.
Und sicher bin ich auch dafür das Du weitermachst. Es ging nur um das "wie" und nicht um das "ob". Viel Erfolg.
----
Kannst Du die Links die die Installation einer Entwicklungsumgebung unter Windows hilfreich sind bitte auch aufnehmen. Du dürftest da ja einiges gefunden haben. Danke!

== Beispiel für das Discovery ==

http://www.chibios.org/dokuwiki/doku.php?id=chibios:articles:stm32f4_discovery
Den Code gibts über deren SVN. Das Os müsst ihr jan nicht benutzen. Ich kann aber bestätigen das der Code läuft und einwand frei unter Eclipse compiliert.
----
Hi Danke für den Link sehr hilfreich. Wenn ich die Demo aber richtig verstehe ist das eine Demo für das OS was der Autor da bereitstellt. Bei den Bibliotheken von ST sind Besipiele bei, hier werde ich erst einmal versuchen das hinzu bekommen. Ich werde im Artikel mal beschreiben wie ich so ein Projekt anlege und ich hoffe bei Problemen hier oder im Forum Hilfe zu bekommen ;)

Für Windows sollte die Installation gleich sein, das einzigste was du wohl nicht bekommen wirst ist stlink. Im Link unter "Beispiel für Discovery" hier auf dieser Seite gibt es aber wohl eine Möglichkeit.

Diskussion:STM32F4-Discovery

2012-01-08T16:56:13Z

Avr-frickler:

Diskussion:STM32F4-Discovery

2012-01-08T16:46:32Z

Avr-frickler:

STM32F4-Discovery

2012-01-08T13:54:19Z

Avr-frickler: Abschnitt stlink hinzugefügt und Gliederung erweitert.

STM32F4-Discovery

2012-01-08T11:05:34Z

Avr-frickler: Abschnitt über Eclipse IDE hinzugefügt.

STM32F4-Discovery

2012-01-03T18:40:03Z

Avr-frickler:

STM32F4-Discovery

2012-01-03T13:56:21Z

Avr-frickler:

Datei:Sup processors.jpg

2012-01-03T13:37:54Z

Avr-frickler:

Auswahlhilfe für die richtige Sourcery Codebench Installation.
Quelle: Screenshot der Seite http://www.mentor.com/embedded-software/sourcery-tools/sourcery-codebench/editions/lite-edition/ am 3.1.2012

Datei:Sup processors.jpg

2012-01-03T13:36:00Z

Avr-frickler: Auswahlhilfe für die richtige Sourcery Codebench Installation. Quelle: Screesnshot der Seite http://www.mentor.com/embedded-software/sourcery-tools/sourcery-codebench/editions/lite-edition/ am 3.1.2012

Auswahlhilfe für die richtige Sourcery Codebench Installation.
Quelle: Screesnshot der Seite http://www.mentor.com/embedded-software/sourcery-tools/sourcery-codebench/editions/lite-edition/ am 3.1.2012

STM32F4-Discovery

2012-01-02T16:55:12Z

Avr-frickler: Anfang des Artikels

Benutzer:Avr-frickler

2011-12-27T18:57:30Z

Avr-frickler: /* STM32 / ARM */ Wiki-Artikel GNU-ATM-Toolchain aus ubuntuusers.de hinzugefügt.

Ich sammle hier ein paar Links zu diversen Themen der Elektronik.

== STM32 / ARM ==

'''Compiler - Linux''' 
[http://michaldemin.wordpress.com/2010/02/09/arm-toolchain-newlib-part1/ ARM-GCC mit newlib + floting point support] - HowTo zum compilieren eines GCC für ARM mit newlib und Fließkommazahlen-Berechnungen in Software. 
[http://www.alios.org/blog/2009/12/gnu-arm-cortex-m3-toolchain-selber-bauen/ ARM-GCC mit newlib] - Anleitung wie man sich einen GCC für ARM baut. 
[http://wiki.ubuntuusers.de/GNU_ARM-Toolchain ARM-GCC für Ubuntu] - ARM-GCC Toolchain unter Ubuntu bauen. 

'''Utilities - Linux''' 
[http://code.google.com/p/arm-utilities arm-utilities] -
Debug/Flash-Tools für STM32-Boards mit STLink z.B. STM32F4-Discovery. 
[http://code.google.com/p/stm32flash/ stm32flash] -
Flash-Tool für STM32-Boards mit Bootloader (serielle Schnittstelle z.B. ET-STM32F103. 
[http://sourceforge.net/apps/mediawiki/gnuarmeclipse/index.php?title=Main_Page Eclipse Plugin] - Eclipse Plugin für diverse Toolchains. 

'''Artikel auf µC.net''' 
[[STM32_Eclipse_Installation]] - STM32 Toolchain in Eclipse integrieren. (Windows) 
[[STM32F10x_Standard_Peripherals_Library]] - Einstieg in die Programmierung.

Benutzer:Avr-frickler

2011-12-27T13:15:16Z

Avr-frickler: /* STM32 / ARM */ Artikel STM32F10x_Standard_Peripherals_Library hinzu gefügt.

Ich sammle hier ein paar Links zu diversen Themen der Elektronik.

== STM32 / ARM ==

'''Compiler - Linux''' 
[http://michaldemin.wordpress.com/2010/02/09/arm-toolchain-newlib-part1/ ARM-GCC mit newlib + floting point support] - HowTo zum compilieren eines GCC für ARM mit newlib und Fließkommazahlen-Berechnungen in Software. 
[http://www.alios.org/blog/2009/12/gnu-arm-cortex-m3-toolchain-selber-bauen/ ARM-GCC mit newlib] - Anleitung wie man sich einen GCC für ARM baut. 

'''Utilities - Linux''' 
[http://code.google.com/p/arm-utilities arm-utilities] -
Debug/Flash-Tools für STM32-Boards mit STLink z.B. STM32F4-Discovery. 
[http://code.google.com/p/stm32flash/ stm32flash] -
Flash-Tool für STM32-Boards mit Bootloader (serielle Schnittstelle z.B. ET-STM32F103. 
[http://sourceforge.net/apps/mediawiki/gnuarmeclipse/index.php?title=Main_Page Eclipse Plugin] - Eclipse Plugin für diverse Toolchains. 

'''Artikel auf µC.net''' 
[[STM32_Eclipse_Installation]] - STM32 Toolchain in Eclipse integrieren. (Windows) 
[[STM32F10x_Standard_Peripherals_Library]] - Einstieg in die Programmierung.

Benutzer:Avr-frickler

2011-12-27T10:21:49Z

Avr-frickler: Erste Version der Seite

Ich sammle hier ein paar Links zu diversen Themen der Elektronik.

== STM32 / ARM ==

'''Compiler - Linux''' 
[http://michaldemin.wordpress.com/2010/02/09/arm-toolchain-newlib-part1/ ARM-GCC mit newlib + floting point support] - HowTo zum compilieren eines GCC für ARM mit newlib und Fließkommazahlen-Berechnungen in Software. 
[http://www.alios.org/blog/2009/12/gnu-arm-cortex-m3-toolchain-selber-bauen/ ARM-GCC mit newlib] - Anleitung wie man sich einen GCC für ARM baut. 

'''Utilities - Linux''' 
[http://code.google.com/p/arm-utilities arm-utilities] -
Debug/Flash-Tools für STM32-Boards mit STLink z.B. STM32F4-Discovery. 
[http://code.google.com/p/stm32flash/ stm32flash] -
Flash-Tool für STM32-Boards mit Bootloader (serielle Schnittstelle z.B. ET-STM32F103. 
[http://sourceforge.net/apps/mediawiki/gnuarmeclipse/index.php?title=Main_Page Eclipse Plugin] - Eclipse Plugin für diverse Toolchains. 

'''Artikel auf µC.net''' 
[[STM32_Eclipse_Installation]] - STM32 Toolchain in Eclipse integrieren. (Windows)