Mikrocontroller.net - Benutzerbeiträge [de]

STM32 - Einstieg mit Em::Blocks

2014-03-18T20:32:21Z

Avrprogger: lö

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

====Register View====
Damit man beim Debuggen sich bequem die Werte der Register (der Peripherie-Register) ansehen kann, bracht man eine, zum Controller passende '''''System View Description'''''-Datei (*.svd), die die verschiedenen Register beschreibt (Name, Adresse, usw..). In Em::Blocks gibt es dazu ein Tool, womit man solche Dateien herunterladen und verwenden kann.

Um sich die nur die Core-Register anzusehen / zu bearbeiten braucht man keine SVD-Datei.

*'''''Debug''''' -> '''''Plugins''''' -> '''''SVD repository'''''
*Controller-Hersteller und Cntroller-Reihe auswählen
*Speicherort auswählen (Standard ist das aktuelle Projekt-Verzeichniss)
*Wenn das Häkchen bei '''''Set and launch target debug configuration''''' gesetzt ist, öffnen sich die Debug-Einstellungen automatisch, und das neue SVD-File wird verwenden.
*Debug-Einstellungen mit '''''OK''''' schließen

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
Um Libraries, wie hier im Tutorial, einzubinden, wird ein existierendes Projekt, wie ein im Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Das_erste_Projekt_erstellen Das Erste Projekt erstellen] beschrieben wird, vorausgesetzt.

===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Ich kopiere die Standard-Peripheral-Library immer per Hand in das Projekt. Darduch hat man auch gleich die aktuellste Version (in den älteren Version gibt es einige Bugs).

*1. Den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis kopieren
*2. Die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren.
*3. In der IDE den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen
*4. Und das/den Define '''''USE_STDPERIPH_DRIVER''''' hinzufügen
*4. Source- und Include-Dateien zum Projekt hinzufügen
**Achtung: Es dürfen nur die Dateien hinzugefügt werden, für die der Controller auch die entsprechende Peripherie bereit stellt. Diese Dateien dürfen nicht beim STM32F4-Discovery/STM32F407VG hinzugefügt werden.
***stm32f4xx_dma2d.c/.h
***stm32f4xx_fmc.c/.h
***stm32f4xx_ltdc.c/.h
***stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

Hier ist noch ein "BasicFramework", dass die komplette CMSIS- und Standard-Peripheral-Library enthält und kann Quasi als Basis für alle Projekte verwendet werden. Allerdings ist das Framework primär auf die STM32F405/7 und STM32F415/7 ausgelegt. Die neueren STM32F401, STM32F42X und STM32F43X haben noch etwas andere Peripherie, dass Framework müsste dann entsprechend angepasst werden. Download: [[Datei:StdPeriphDriver_BasicFramework.zip]]

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').

*1. Source-Dateien des benötigten Moduls zum Projekt hinzufügen. ('''''<ProjektName> -> Rechts Klick -> Add files...''''')
*2. '''''arm_math.h''''' in der '''''main.c''''' einbinden
*3. Damit die Warnung "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" verschwindet, muss der Define '''''__FPU_PRESENT''''' hinzugefügt werden. (Keine Ahnung, wieso es die Warnung gibt)

Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerufen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Core-Coupled-RAM verwenden===
Auf den normale SRAM kann durch den Core und die verschiedenen DMA-Controller zugegriffen werden. Jedoch können Core und DMA nicht gleichzeitig auf den SRAM zugreifen. Deswegen gibt es einen zweiten kleinen RAM, den Core-Coupled-RAM (CCRAM), auf den nur vom Core zugegriffen werden kann und nicht von einem DMA-Controller. Der CCRAM ist über einen anderen Bus an dem Cortex angeschlossen. Daduch wird ermöglicht, dass der Core sinnvoll weiterarbeiten kann, wenn ein DMA-Controller Daten aus den "Haupt"-RAM ließt/schreibt, indem der Core Daten aus dem CCRAM verarbeitet. Um Daten in den CCRAM zu legen, geht man wie folgt vor:

1. Eine neue Section im Linkerscript anlegen:
<syntaxhighlight lang="c">
Sections:
{
...

.ccram :
{
*(.ccram)
} > CCRAM

...
}
</syntaxhighlight>

2. Um die neue Section zu verwenden benutzt man diesen Define:
<syntaxhighlight lang="c">
#define CCRAM __attribute__((section(".ccram")))

...

int CCRAM dataInCCRAM;
</syntaxhighlight>

Beim Debuggen stellt man fest das die Variable an der Adresse 0x10000000 liegt, der ersten Adresse das CCRAM's.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

[[Datei:bootsram_1.png Booten aus dem SRAM]] [[Datei:bootsram_2.png Booten aus dem SRAM]]

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-03-18T20:30:53Z

Avrprogger: usb

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

====Register View====
Damit man beim Debuggen sich bequem die Werte der Register (der Peripherie-Register) ansehen kann, bracht man eine, zum Controller passende '''''System View Description'''''-Datei (*.svd), die die verschiedenen Register beschreibt (Name, Adresse, usw..). In Em::Blocks gibt es dazu ein Tool, womit man solche Dateien herunterladen und verwenden kann.

Um sich die nur die Core-Register anzusehen / zu bearbeiten braucht man keine SVD-Datei.

*'''''Debug''''' -> '''''Plugins''''' -> '''''SVD repository'''''
*Controller-Hersteller und Cntroller-Reihe auswählen
*Speicherort auswählen (Standard ist das aktuelle Projekt-Verzeichniss)
*Wenn das Häkchen bei '''''Set and launch target debug configuration''''' gesetzt ist, öffnen sich die Debug-Einstellungen automatisch, und das neue SVD-File wird verwenden.
*Debug-Einstellungen mit '''''OK''''' schließen

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
Um Libraries, wie hier im Tutorial, einzubinden, wird ein existierendes Projekt, wie ein im Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Das_erste_Projekt_erstellen Das Erste Projekt erstellen] beschrieben wird, vorausgesetzt.

===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Ich kopiere die Standard-Peripheral-Library immer per Hand in das Projekt. Darduch hat man auch gleich die aktuellste Version (in den älteren Version gibt es einige Bugs).

*1. Den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis kopieren
*2. Die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren.
*3. In der IDE den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen
*4. Und das/den Define '''''USE_STDPERIPH_DRIVER''''' hinzufügen
*4. Source- und Include-Dateien zum Projekt hinzufügen
**Achtung: Es dürfen nur die Dateien hinzugefügt werden, für die der Controller auch die entsprechende Peripherie bereit stellt. Diese Dateien dürfen nicht beim STM32F4-Discovery/STM32F407VG hinzugefügt werden.
***stm32f4xx_dma2d.c/.h
***stm32f4xx_fmc.c/.h
***stm32f4xx_ltdc.c/.h
***stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

Hier ist noch ein "BasicFramework", dass die komplette CMSIS- und Standard-Peripheral-Library enthält und kann Quasi als Basis für alle Projekte verwendet werden. Allerdings ist das Framework primär auf die STM32F405/7 und STM32F415/7 ausgelegt. Die neueren STM32F401, STM32F42X und STM32F43X haben noch etwas andere Peripherie, dass Framework müsste dann entsprechend angepasst werden. Download: [[Datei:StdPeriphDriver_BasicFramework.zip]]

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').

*1. Source-Dateien des benötigten Moduls zum Projekt hinzufügen. ('''''<ProjektName> -> Rechts Klick -> Add files...''''')
*2. '''''arm_math.h''''' in der '''''main.c''''' einbinden
*3. Damit die Warnung "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" verschwindet, muss der Define '''''__FPU_PRESENT''''' hinzugefügt werden. (Keine Ahnung, wieso es die Warnung gibt)

Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerufen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Core-Coupled-RAM verwenden===
Auf den normale SRAM kann durch den Core und die verschiedenen DMA-Controller zugegriffen werden. Jedoch können Core und DMA nicht gleichzeitig auf den SRAM zugreifen. Deswegen gibt es einen zweiten kleinen RAM, den Core-Coupled-RAM (CCRAM), auf den nur vom Core zugegriffen werden kann und nicht von einem DMA-Controller. Der CCRAM ist über einen anderen Bus an dem Cortex angeschlossen. Daduch wird ermöglicht, dass der Core sinnvoll weiterarbeiten kann, wenn ein DMA-Controller Daten aus den "Haupt"-RAM ließt/schreibt, indem der Core Daten aus dem CCRAM verarbeitet. Um Daten in den CCRAM zu legen, geht man wie folgt vor:

1. Eine neue Section im Linkerscript anlegen:
<syntaxhighlight lang="c">
Sections:
{
...

.ccram :
{
*(.ccram)
} > CCRAM

...
}
</syntaxhighlight>

2. Um die neue Section zu verwenden benutzt man diesen Define:
<syntaxhighlight lang="c">
#define CCRAM __attribute__((section(".ccram")))

...

int CCRAM dataInCCRAM;
</syntaxhighlight>

Beim Debuggen stellt man fest das die Variable an der Adresse 0x10000000 liegt, der ersten Adresse das CCRAM's.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

[[Datei:bootsram_1.png Booten aus dem SRAM]] [[Datei:bootsram_2.png Booten aus dem SRAM]]

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

==USB-Libraries verwenden==

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-03-18T20:29:58Z

Avrprogger: dsf

STM32 - Einstieg mit Em::Blocks

2014-03-18T20:28:20Z

Avrprogger: svd

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

====Register View====
Damit man beim Debuggen sich bequem die Werte der Register (der Peripherie-Register) ansehen kann, bracht man eine, zum Controller passende '''''System View Description'''''-Datei (*.svd), die die verschiedenen Register beschreibt (Name, Adresse, usw..). In Em::Blocks gibt es dazu ein Tool, womit man solche Dateien herunterladen und verwenden kann.

*'''''Debug''''' -> '''''Plugins''''' -> '''''SVD repository'''''
*Controller-Hersteller und Cntroller-Reihe auswählen
*Speicherort auswählen (Standard ist das aktuelle Projekt-Verzeichniss)
*Wenn das Häkchen bei '''''Set and launch target debug configuration''''' gesetzt ist, öffnen sich die Debug-Einstellungen automatisch, und das neue *.svd-File wird verwenden.
*Debug-Einstellungen mit '''''OK''''' schließen

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
Um Libraries, wie hier im Tutorial, einzubinden, wird ein existierendes Projekt, wie ein im Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Das_erste_Projekt_erstellen Das Erste Projekt erstellen] beschrieben wird, vorausgesetzt.

===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Ich kopiere die Standard-Peripheral-Library immer per Hand in das Projekt. Darduch hat man auch gleich die aktuellste Version (in den älteren Version gibt es einige Bugs).

*1. Den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis kopieren
*2. Die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren.
*3. In der IDE den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen
*4. Und das/den Define '''''USE_STDPERIPH_DRIVER''''' hinzufügen
*4. Source- und Include-Dateien zum Projekt hinzufügen
**Achtung: Es dürfen nur die Dateien hinzugefügt werden, für die der Controller auch die entsprechende Peripherie bereit stellt. Diese Dateien dürfen nicht beim STM32F4-Discovery/STM32F407VG hinzugefügt werden.
***stm32f4xx_dma2d.c/.h
***stm32f4xx_fmc.c/.h
***stm32f4xx_ltdc.c/.h
***stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

Hier ist noch ein "BasicFramework", dass die komplette CMSIS- und Standard-Peripheral-Library enthält und kann Quasi als Basis für alle Projekte verwendet werden. Allerdings ist das Framework primär auf die STM32F405/7 und STM32F415/7 ausgelegt. Die neueren STM32F401, STM32F42X und STM32F43X haben noch etwas andere Peripherie, dass Framework müsste dann entsprechend angepasst werden. Download: [[Datei:StdPeriphDriver_BasicFramework.zip]]

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').

*1. Source-Dateien des benötigten Moduls zum Projekt hinzufügen. ('''''<ProjektName> -> Rechts Klick -> Add files...''''')
*2. '''''arm_math.h''''' in der '''''main.c''''' einbinden
*3. Damit die Warnung "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" verschwindet, muss der Define '''''__FPU_PRESENT''''' hinzugefügt werden. (Keine Ahnung, wieso es die Warnung gibt)

Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerufen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Core-Coupled-RAM verwenden===
Auf den normale SRAM kann durch den Core und die verschiedenen DMA-Controller zugegriffen werden. Jedoch können Core und DMA nicht gleichzeitig auf den SRAM zugreifen. Deswegen gibt es einen zweiten kleinen RAM, den Core-Coupled-RAM (CCRAM), auf den nur vom Core zugegriffen werden kann und nicht von einem DMA-Controller. Der CCRAM ist über einen anderen Bus an dem Cortex angeschlossen. Daduch wird ermöglicht, dass der Core sinnvoll weiterarbeiten kann, wenn ein DMA-Controller Daten aus den "Haupt"-RAM ließt/schreibt, indem der Core Daten aus dem CCRAM verarbeitet. Um Daten in den CCRAM zu legen, geht man wie folgt vor:

1. Eine neue Section im Linkerscript anlegen:
<syntaxhighlight lang="c">
Sections:
{
...

.ccram :
{
*(.ccram)
} > CCRAM

...
}
</syntaxhighlight>

2. Um die neue Section zu verwenden benutzt man diesen Define:
<syntaxhighlight lang="c">
#define CCRAM __attribute__((section(".ccram")))

...

int CCRAM dataInCCRAM;
</syntaxhighlight>

Beim Debuggen stellt man fest das die Variable an der Adresse 0x10000000 liegt, der ersten Adresse das CCRAM's.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

[[Datei:bootsram_1.png Booten aus dem SRAM]] [[Datei:bootsram_2.png Booten aus dem SRAM]]

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32

2014-03-01T18:00:25Z

Avrprogger: dfg

STM32 ist eine Mikrocontroller-Familie von [http://www.st.com/mcu/inchtml-pages-stm32.html ST] mit einer 32-Bit [http://www.arm.com/products/processors/cortex-m/index.php ARM Cortex-M0/M3/M4] CPU. Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt und löst damit die bisherigen ARM7-basierten Controller weitestgehend ab. Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrößen und -formen. Durch die geringe Chipfläche des Cores ist es ST möglich, eine 32 Bit-CPU für weniger als 1 € anzubieten.

[[Bild:stm32F103xc.png|thumb|right|340px|Blockdiagramm STM32F103xC/D/E]]

== STM32-Familien ==

Bisher gibt es sieben STM32-Familien:
* [http://www.st.com/internet/mcu/subclass/1588.jsp STM32F0]
** Cortex M0
** Mikrocontroller zum Einstieg
** Bis 48MHz
* [http://www.st.com/internet/mcu/subclass/1169.jsp STM32F1]
** Cortex M3
** Bis 72MHz
**Verschiedene Unterfamilien:
*** Connectivity line
*** Performance line
*** USB Access line
*** Access Line
*** Value line
* [http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1575 STM32F2]
** Cortex M3
** Bis 120MHz
** Wie die STM32F1 Serie, Camera-Interface, 32-Bit Timer, Crypto-Engine...
* [http://www.st.com/internet/mcu/subclass/1605.jsp STM32F3]
** Cortex M4F
** DSP und FPU
** Bis 72MHz
** Fast 12-bit 5 MSPS and precise 16-bit sigma-delta ADCs
** Touch sensing controller (TSC)
* [http://www.st.com/internet/mcu/subclass/1521.jsp STM32F4]
** Cortex M4F
** DSP und FPU
** Bis 180MHz
** Bis zu 2MB Flash
* [http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1295 STM32L1]
** Cortex M3
** Low Power
** mit LCD Treiber
** Bis 32MHz
* [http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1581 STM32W]
** Cortex M3
** BIS 24MHz
** RF-MCU
[http://www.st.com/internet/mcu/class/1734.jsp Hier eine Übersicht zum Auswählen eines STM32Fxxx]

===Features===
* Cortex-M0 / Cortex-M3 / Cortex-M4F Kern (mit FPU)
* 16KB ... 2MB [[Flash-ROM]]
* 4KB ... 256KB [[Speicher#SRAM|SRAM]]
* 4KB [[Speicher#EEPROM|EEPROM]] (STM32L)
* SDRAM-Controller bei den [http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1577/LN1806 STM32F42xxx und STM32F43xxx], bis 512 MByte externer SDRAM addressierbar
* 512 one-time programmable Bytes(STM32F2/4)
* [[IC-Gehäuseformen | Gehäuse]] 20 ... 216 Pins als TSSOP, QFN, LQFP und BGA
* Derzeit sind über '''250''' [http://www.st.com/web/en/catalog/mmc/FM141/SC1169 STM32 Derivate/Varianten verfügbar]
* Bis 72MHz CPU-Takt, bis 120MHz beim STM32F2xx, bis 168/180 MHz beim STM32F4xx, wobei eine spezielle prefetch-hardware bis 120/168 MHz eine Geschwindigkeit erzielen soll, die 0 Wait-States entspricht. Der CPU-Takt wird über einen Multiplikator aus dem internen RC-Takt oder einem externen Quarz-Takt abgeleitet.
* Externes Businterface (nur bei Gehäusen ab 100 Pin und nur bei STM32F4, STM32F2 und STM32F1 Performance line)
* LCD Treiber für 8x40 Punkte (nicht beim STM32F2xx)
* TFT Treiber bei STM32F429 / STM32F439
* Spannungsbereich 1,65 ... 3,6V, nur eine Betriebsspannung nötig
* Temperaturbereich bis 125 °C
* Bis zu 140 IOs, viele davon [[Pegelwandler|5V-tolerant]]
* Interner, kalibrierter RC-Oszillator mit 8MHz (16MHz bei STM32F2/F4xx)
* Externer Quarz
* Real Time Clock mit eigenem Quarz und separater Stromversorgung
* Bis zu 16 [[Timer]], je Timer bis zu 4 IC/OC/PWM Ausgänge. Davon 2x Motion Control Timer (bei STM32F103xF/G), (bis zu 32 PWM Ausgänge)
* Systick Counter
* Bis zu 3 12-Bit [[AD-Wandler]] mit insgesamt 24 AD-Eingängen, integrierter [[Temperatursensor]], Referenzspannung Vrefint und VBatt Spannungsmessung (STM32F4xx)
* Bis zu 2 12-Bit [[DA-Wandler]] (bis zu 3 beim STM32F3xx)
* Bis zu 2 [[DMA]] Controller mit bis zu 12 Kanälen (16 beim STM32F2/4xx)
* Bis zu 2x [[I2C|I²C]]
* Bis zu 5x [[UART|USART]] mit LIN, IrDA und Modem Control (bis zu 8 beim STM32F2/F4xx)
* Bis zu 3x [[SPI]] (bis zu 6 beim STM32F4xx)
* Bis zu 2x [[I2S|I²S]]
* Bis zu 2x [[CAN#STMicroelectronics STM32 (Cortex M3/M4)|CAN]]
* Hardware [[CRC]] Unit, bei der STM32F3xx Serie mit einem einstellbaren Polynom
* Unique device ID register (96 Bits)
* RNG - Random Number Generator (STM32F2/4xx)
* Cryptographic Processor (CRYP) (STM32F2/4xx)
* Hash Processor (HASH) (STM32F2/4xx)
* Kamera-Interface (DCMI) (STM32F2/4xx)
* [[USB]] 2.0 Full Speed / OTG
* [[USB]] 2.0 Hi Speed OTG mit extra PHY-Chip (STM32F2/4xx)
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* Watchdog mit Window-Mode
* Jedes Peripheriemodul ist separat einschaltbar, wodurch sich erheblich [[Ultra low power|Strom sparen]] lässt
* [[JTAG]] und SWD (Serial Wire Debug) Interface
* Bis zu 6 Hardware-Breakpoints für Debuggen
* und vieles mehr . . .

== Struktur der Dokumentation: ==
Die Dokumentation der STM32 ist zwar umfangreicher und komplexer z.B. die der [[AVR]], enthält aber dennoch alle nötigen Informationen. Sie teilt sich auf in mehrere Dokumente.
Als Beispiel der Dokumentation soll stellvertretend der [http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1031/LN1565/PF164486 STM32F103RC] genannt werden. Die Seite von ST beinhaltet alle nötigen Informationen passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* Im [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/CD00191185.pdf STM32F103xC/D/E Datasheet] sind die speziellen Eigenschaften einer bestimmten Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt, sowie die Zuordnung Chipname - Flash/RAM-Größe. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben.
* Im [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/CD00171190.pdf Reference Manual (RM0008)] sind alle Peripheriemodule der jeweiligen STM32-Controllerfamilie im Detail beschrieben.
* Das [http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0403c/index.html ARMv7M Architecture Reference Manual] beschreibt detailliert den Prozessorkern, wie das Exception Model, die CPU Instruktionen inklusive Encoding, etc.
* Das [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/programming_manual/CD00228163.pdf STM32 Cortex-M3 Programming Manual] ist eine Zusammenfassung des ARMv7M Architecture Reference Manual bezogen auf die STM32.
* Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich das [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/programming_manual/CD00283419.pdf Flash Programming Manual] für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates.

Zusätzlich sollten auch die [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/errata_sheet/CD00197763.pdf Errata Sheets] beachtet werden. Empfohlen sei auch die Appnote "[http://www.st.com/web/en/resource/technical/document/application_note/CD00164185.pdf AN2586 Getting started with STM32F10xxx hardware development]".
Die jeweiligen Dokumentations-PDFs sind auf der Produktseite von ST eines jeden Mikrocontrollers verlinkt.

== Hardware Zugriffs-Libraries ==
=== CMSIS ===

Die CMSIS (ARM® '''C'''ortex™ '''M'''icrocontroller '''S'''oftware '''I'''nterface '''S'''tandard) ist eine Library von ARM für den Zugriff auf die herstellerübergreifenden Funktionen des ARM-Cores. Hierzu gehört bei den Cortex-M4F-Cores auch die DSP und Floating-Point Funktionalität. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, den Sys-Tick-Counter, sowie eine SystemInit-Funktion, welche sich um die PLL kümmert.

Im Rahmen des CMSIS-Standards ([http://www.onARM.com www.onARM.com]) wurden die Headerdateien standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Die CMSIS C-Dateien bzw. Header enthalten auch Anpassungen für die verschiedenen Compiler. Die Portierung eines Real-Time-Betriebsystems sollte unter Verwendung der CMSIS, für Chips der verschiedenen Hersteller, stark vereinfacht möglich sein (z.B. einheitliche Adressen für Core-Hardware/Sys-Tick-Counter).

Die CMSIS ist im Download der ‎STM32 Standard Peripheral Library enthalten. Die Compiler-Hersteller liefern eine jeweils zur ihrer Tool-Version passende bzw. geprüfte Library (incl. CMSIS) aus. Diese Libs können, gegenüber den Downloads beim Chip-Hersteller, auch ältere Version beinhalten.

=== ‎STM32 Standard Peripheral Library ===

ST bietet für jede Controller-Familie eine umfangreiche zur CMSIS passende Peripherie-Bibliothek. Alle Funktionen um die Peripherie zu benutzen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherie-Register kümmern. Diese Library und ihre Dokumentation setzen das grundlegende Verständnis der Funktion des jeweiligen Peripheriemoduls voraus, wie es die o.a. Referenz und diverse Appnotes vermitteln. Die Library beinhaltet außerdem für fast jede Peripherie mehrere Beispiele.
Für die USB Schnittstelle gibt es noch eine extra Library, genauso wie für Ethernet.

Auf der "Design Resources" Seite der Produktseite von ST eines jeden STM32 Mikrocontrollers kann die Library für den jeweiligen Controller heruntergeladen werden, z.B. [http://www.st.com/web/en/catalog/tools/PF257890 hier für den o.g. STM32F103RC].

Library für STM32F4xx: [http://www.st.com/web/en/catalog/tools/PF257901# STSW-STM32065 STM32F4 DSP and standard peripherals library]

== Programmierung ==
Zur Programmierung der STM32 gibt es verschiedene Möglichkeiten, sowohl kommerzielle proprietäre als auch mit Freier Software.

Der GCC (in seinen verschiedenen Binärdistributionen) ist der einzige ARM Compiler der [http://de.wikipedia.org/wiki/C%2B%2B11 C++11] unterstützt.

=== Freie Software/Freeware ===
==== Selber zusammenstellen ====
Man nehme...:
* Eine Entwicklungsumgebung nach Wahl:
** [http://www.eclipse.org Eclipse] mit [http://www.eclipse.org/cdt/ C/C++ Development Tooling] und [http://gnuarmeclipse.livius.net/blog/ GNU ARM Plug-in] (Bei Verwendung vom GCC-ARM-Embedded als Toolchain "Sourcery G++ Lite" auswählen, dieser sieht für eclipse gleich aus) (Linux, Windows)
** [http://netbeans.org/ Netbeans] mit [http://plugins.netbeans.org/plugin/37426/gdbserver GDBserver-Plugin] (Linux, Windows)
** [http://www.kdevelop.org/ KDevelop] (Linux)
** [http://www.geany.org/ Geany] (Linux, Windows)
** Oder ein einfacher Texteditor
* Einen C,C++ Compiler:
** Eine der [[ARM_GCC#GCC_Bin.C3.A4rdistributionen|GCC-Binärdistributionen]], siehe auch [[#GCC|GCC]] (je nach Distribution Linux, Windows)
* Programmiersoftware zum Flashen des Target:
** [http://openocd.sourceforge.net/ OpenOCD] unterstützt viele Debug/Programmier-Adapter (Linux, Windows)
** [https://github.com/texane/stlink Texane stlink] funktioniert gut mit den ST-Link Adaptern wie sie zB. auf den STM32 Discovery Boards zu finden sind (Linux)
** Turtelizer2 oder andere JTAG Programmieradapter
** Bei Verwendung eines Segger J-Link, den [http://www.segger.com/admin/uploads/productDocs/UM08005_JLinkGDBServer.pdf Segger GDB-Server] in Verbindung mit dem beim GCC mitgelieferten GDB (Linux, Windows)

==== Komplette IDE's ====
* [http://www.codesourcery.com/sgpp/lite_edition.html Codesourcery Lite Edition]
* [http://www.coocox.org/ Coocox Eclipse IDE] kostenlose IDE für STM32F0 / F1 / F4 Hilfreiche Infos gibt es im [http://www.mikrocontroller.net/topic/214719?goto=new#2228482 hier] und [http://www.mikrocontroller.net/topic/214719?goto=new#2229943 hier] Forum, Artikel: [[STM32 CooCox Installation]]
* [http://emide.org/ emIDE] kostenlose IDE die mit dem Segger J-LINK funktioniert.
* [http://www.emblocks.org EmBlocks] kostenlose IDE, Code::Blocks basiert, unterstützt STM32 L1/F0/F1/F2/F3/F4/W, integrierter Compiler (ARM-GCC), integrierter GDB Debugger, Jlink/ST-Link, System view (Peripherie Register anzeigen) beim Debuggen, Project Wizard (Eigene Wizards können mit Squirrel geschreiben werden), Basiert auf Code::Blocks, [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks STM32 - Einstieg mit Em::Blocks]

=== Kommerzielle Umgebungen ===

* [http://www.keil.com/arm/mdk.asp Keil µVision] (Demo max. 32KB Code): Die sehr komfortable µVison IDE ist neben dem ARM Compiler per Menue auch für einen beliebigen GNU-Compiler konfigurierbar. Damit besteht das 32k-Limit nur noch für den integrierten Debugger / Simulator. µVison selbst kann kostenlos mit dem MDK-Evaluationkit heruntergeladen werden. [https://www.keil.com/arm/demo/eval/arm.htm#DOWNLOAD download]
* [http://www.iar.com/en/Products/IAR-Embedded-Workbench/ IAR-Embedded-Workbench] (Demo max. 32KB Code) [http://supp.iar.com/Download/SW/?item=EWARM-EVAL download]
* [http://www.isystem.com/products/itag winIDEAiTag] Keine Code Limitierung, GCC und Testwerkzeug beinhaltet. Läuft mit dem iTag Adapter.
* [http://www.raisonance.com Raisonance Ride7] (GCC Compiler, kostenlose Version auf Debugging von max. 32KB Code limitiert, keine Limitierung beim Complilieren)
* [http://www.atollic.com Atollic] (Lite Version (bis V2.3.0) ohne Code-Limit, auf GCC basierend. Die neueste Version ab V3 hat fast keine Beschränkungen mehr außer jetzt einen Code-Limit von 32kB. Außerdem werden jetzt die meisten ARM Familien unterstützt. )
* [http://www.rowley.co.uk/arm/ Rowley Crossworks] (Demo 30 Tage unbeschränkt, 150$ für nichtkommerzielle Nutzung, auf GCC basierend)
* [http://www.code-red-tech.com Code Red] (GCC basierend)
* [http://www.sisy.de/index.php?id=17&no_cache=1 SiSy ARM oder SiSy Micrcontroller++] (Demo verfügbar keine Gößenbegrenzung, basiert auf GNU-Compiler, grafische Programmierung mit UML möglich, integrierter Debugger)
* [http://www.comsytec.eu/epsdebugger.php EPS Debugger Plugin, für STM32 Development mit Code::Blocks]

=== Tutorials für diverse Tool-Kombinationen ===
[[STM32 Eclipse Installation|Windows,Linux, Eclipse + Yagarto/CodeSourcery + OpenOCD/ST-Link]]

* Windows
** Eclipse
*** [http://www.mikrocontroller.net/topic/216554 Windows, Eclipse, codesourcery, st-link ]
*** [http://www.firefly-power.de/ARM/debugging.html Eclipse Plugin "GDB Hardware Debugging" mit OpenOCD]
** Code::Blocks
*** [http://www.mikrocontroller.net/topic/265600 Windows, Code::Blocks, STM32F4]
** STM32 mit EmBlocks
*** [http://www.emblocks.org/web/downloads-main Download EmBlocks]
*** [https://www.youtube.com/watch?v=coHPJylnzC8 Video STM32 Project Wizzard in EmBlocks]
** Atollic TrueSTUDIO
*** [[STM32 LEDBlinken AtollicTrueStudio|Atollic TrueSTUDIO Installation + Demo]]
** MDK-ARM Lite mit Einstellungen für STM32F0/F4-Discovery Board
*** [https://www.keil.com/demo/eval/arm.htm KEIL MDK-ARM Download]
*** [https://www.youtube.com/watch?v=RXOOxby5nns&list=PL6-W3FoUyb48WFI5PQv3SDJj2G1t2FonV&index=1 Installations Video STM32F4 Discovery Board]
*** [https://www.youtube.com/watch?annotation_id=annotation_203294&feature=iv&index=4&list=PL6-W3FoUyb48WFI5PQv3SDJj2G1t2FonV&src_vid=sN4gDZ7H8gw&v=BeZcQjXxk9A Einstellungen STM32F0 Discovery Board Video]
** SiSy ARM, STM32
*** Download: [http://www.sisy.de/index.php?id=59 SiSy DEMO] kein Begrenzung der Codegröße
*** [http://www.youtube.com/watch?v=84Y3jYLWYpo Videobeispiel]
** Microsoft Visual Studio
*** [http://visualgdb.com/tutorials/arm/stm32/f4_discovery/ "STM32F4-Discovery tutorial with Visual Studio"]
* Ubuntu
** [http://www.seng.de/downloads/HowTo_ToolChain_STM32_Ubuntu.pdf Ubuntu, eclipse, Code Sourcery, OpenOCD] ([http://www.seng.de/downloads/HowTo_ToolChain_STM32_Ubuntu.odt Das Gleiche im bearbeitbaren ODT-Format])
** [http://fun-tech.se/stm32/index.php Ubuntu, Selbstcompilierter GCC, STM32/Cortex-M3]
** [http://thetoolchain.com The ToolChain] - Automatisch installierende Entwicklungsumgebung mit eigenen und externen Treibern, Unterstützt QtCreator als IDE, Flexibel erweiterbar über Shellskripte

* [http://www.mikrocontroller.net/topic/214719 Tipps für Installation mit Eclipse]

===Programmieradapter===
* [http://www.segger.com/jlink-model-overview.html SEGGER J-LINK / J-TRACE] für u.a. alle ARM7/9/11, Cortex-M0/M1/M3/M4/A5/A8/A9/R4 als [http://www.segger.com/cms/j-link-edu.html NonComercial] J-LINK-EDU für ca. 60,- zu haben, läuft in µVision, IAR, GDB (Linux & Windows über einen eigenen [http://www.segger.com/admin/uploads/productDocs/UM08005_JLinkGDBServer.pdf GDB-Server]), Keil, ...
* Keil [http://www.keil.com/ulinkme/ ULINK-ME], [http://www.keil.com/arm/ulink2/ ULINK2], [http://www.keil.com/arm/ulinkpro/ ULINK pro]
* [http://www.st.com/internet/evalboard/product/219866.jsp ST-LINK], [http://www.st.com/internet/evalboard/product/251168.jsp ST-LINK/V2]
* Jedes STM32 Discovery board hat einen ST-Link für Programmierung/Debugging per SWD on-board, welcher auch für eigene STM32 Target Hardware benutzt werden kann (ca. 12,- bis 19,-€, je nach Typ).
* [http://www.raisonance.com/~rlink-debugger-programmer__microcontrollers__tool~tool__T018:4cn9ziz4bnx6.html Raisonance RLink]
* [http://www.amontec.com Amontec] (Achtung: keine Reaktion auf Bestellung, Telefon, Email...)
* [http://www.hjtag.com H-JTAG] Personal Edition für ca. 60,- zu haben, läuft mit ADS, SDT, IAR, Vision und RVDS
* [http://www.isystem.com/products/itag iTag] für 50.- bei Amazon zu bestellen, oder als Eigenbau version (offenes Design) läuft mit der freien winIDEAiTag version (siehe oben)

In der Regel haben die [[JTAG]] Adapter einen 20-Poligen Stecker, den man direkt auf die Demo-Boards, die auch einen 20-Poligen [[JTAG]]-Anschluss haben, einstecken kann. Die Pinbelegung ist genormt, siehe Artikel [[JTAG]]. Die Discovery-Boards haben keinen seperaten JTAG-Stecker, aber zumindest für das STM32F4 Discovery kann man sich leicht einen Adapter Pinheader->JTAG Stecker selber bauen.

Andere [[JTAG]] Adapter wie z.B. der ULink von Keil funktionieren nur mit dem Keil Compiler.

===Programmieradapter Open-Source===

* [https://www.olimex.com/Products/ARM/JTAG/ARM-JTAG-COOCOX/ ARM-JTAG-COOCOX], CoLinkEX Nachbau von Olimex, unterstützt JTAG sowie SWD
** [http://www.coocox.org/colinkEx.htm unterstützte uC]
** unterstütze IDEs: [http://www.keil.com/arm/mdk.asp Keil MDK-ARM 4.03] oder neuer, [http://www.iar.com/en/Products/IAR-Embedded-Workbench/ IAR Embedded Workbench 5.xx] oder neuer sowie die [http://www.coocox.org/CooCox_CoIDE.htm CooCox CoIDE]
* [https://www.olimex.com/Products/ARM/JTAG/ Olimex] ARM-USB-OCD (ca. 60.-, hat zusätzlich einen Spannungsausgen und einen COM Port)
* [http://www.oocdlink.com/ OOCDLink]
* [https://github.com/texane/stlink Stlink]
* [http://www.randomprojects.org/wiki/Floss-JTAG FLOSS-JTAG]
* [http://capitanio.org/mlink/ Linux Demo Code für die Discovery's ST-Link Programmierung]

Der Controller hat auch einen fest eingebauten Boot-Lader. Damit läßt er sich auch über eine gewöhnliche serielle Schnittstelle programmieren, ohne dass man einen JTAG-Adapter benötigt. Dies erfordert ggf. entsprechende Konfiguration über die BOOTx-Pins und/oder die Option-Bytes.

=== Demo-Projekte ===

* Einführung in die GPIO Programmierung der STM32F10x und STM32F30x Prozessoren am Beispiel des STM32F3 Discovery Boards und Vergleich zur AVR IO Registerstruktur [http://www.mikrocontroller.net/topic/300472#new]
* [[prog_bsp_timer_1_timer2|Programmbeispiel für die Verwendung von Timer2 zusammen mit dem Interrupt]]
* [http://www.firefly-power.de/ARM/printf.html Printf() debugging mit minimalem Aufwand]
* [[STM32_BLDC_Control_with_HALL_Sensor|Programmbeispiel für BLDC Motoransteuerung (Timer 1) mit HALLSensor (Timer 3)]]
* [[Cortex_M3_OCM3U]]
* Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:
** [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html "ChaN's FAT-Module with STM32 SPI"]
* [[STM32 USB-FS-Device Lib]]
* Modellbau-Sender auf STM32-Basis mit vielen Treibern [http://www.rcos.eu www.rcos.eu]
* Ausführliches [https://github.com/jkerdels/stm32edu Einstiegs-Tutorial] in Codeform für das [http://www.st.com/internet/evalboard/product/252419.jsp STM32F4 discovery board]
* [http://www.redacom.ch/keillab/ Schweizer Gondelbahnsteuerung über Webserver auf ETT STM32F ARM KIT Board in Keil RTOS] mit Webcam
* Die [http://ethernut.svn.sourceforge.net/viewvc/ethernut/trunk/ Ethernut SVN Version] unterstützt inzwischen viele STM32 Typen, viele Devices und einige STM32 Demoboards
* [http://mikrocontroller.bplaced.net/wordpress/?page_id=744 Uwe Bonnes' Libraries für den STM32F4]
* [http://mikrocontroller.bplaced.net/wordpress/?page_id=3290 Uwe Bonnes' STM32F429 Discovery Board Oszilloskop], hier der [http://www.mikrocontroller.net/topic/319831#new Thread]

== Debug- und Trace-Interface (CoreSight™ Debug and Trace Technologie)==

Übersicht über beide Funktionalitäten und den Schnittstellen:
http://www.keil.com/support/man/docs/ulink2/ulink2_cs_core_sight.htm

Die Coresight-Debug-Architektur ermöglicht ein nicht-invasives Debugging, d.h. es können während des Betriebes (meistens) ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

=== Debugger Funktionen ===

Der Debugger-Teil besitzt drei Funktionen:
* Run Control: z.B. Programm-Start, Stopp und Einzel-Schritte.
* (Program) Break Points: Ein Programm hält an, wenn der Programm Counter eine bestimmte Programm-Adresse erreicht.
** Die maximale Anzahl der gleichzeitig möglichen Break Points ist begrenzt (z.B. 6 bei einem STM32).
** Die Anzahl der Break Points ist nahezu unbegrenzt, wenn ein Debugger über den Memory Access (s.u.) sogenannte Flash Break Points unterstützt. Dabei wird ein geladenes Programm im Flash umprogrammiert, um den Debugger anzuhalten. Diese Funktionalität ist meistens ein kostenpflichtiges Zusatz-Feature des Debugger-Herstellers.
** Beinhaltet keine Data Watch Funktionalität, welche im Trace-Teil (DWT) realisiert wird.
* Memory Access: Lesen und Schreiben von Speicheradressen.
** Diese Funktionalität beinhaltet keine direkte Flash-Programmierung. Der Programmiervorgang für einen Flash ist herstellerspezifisch und muss von dem verwendeten Debugger unterstützt werden.

=== Trace Funktionen ===
Die Trace-Funktionalität wird in drei Funktionen aufgeteilt:
* ETM (Embedded Trace Macrocell): Optional, nicht jede CPU besitzt diese Hardware (Kostenfaktor, Austattung).
* ITM (Instrumentation Trace Macrocell): Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht werden, sowie "printf-ähnlich" Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.
* DWT (Data Watchpoint & Trace Unit):
** Data Watch: 4 Access-Break-Points ( z.B. der Debugger bleibt stehen, wenn das Programm auf einen Speicher zugreift oder der Wert einer Variablen einen bestimmten Wert annimmt).
** Trace Unit: Programmverlauf (durch Lesen des Program Counters) und Interrupt Aufrufe verfolgen, sowie Zeitmessungen.

Einige der Trace-Funktionalitäten können über die JTAG-Schnittstelle angesprochen werden. Die schnelle Trace-Funktionalität (mit 4 bit Parallel-Port) steht nur mit der erweiterten DEBUG + ETM Schnittstelle zur Verfügung. Im Gegensatz zum Debugger-Teil (Run Control, Break Points und Memory Access) werden Trace-Funktionen nicht von allen Debuggern unterstützt. Debugger mit der vollen Trace-Funktionalität kosten deutlich mehr.

* Beispiele für Trace-Port-Aktivierungen für verschiedene Hersteller: http://www.keil.com/support/man/docs/jlink/jlink_capture_tracedata.htm

Die Aktivierung des parallelen Trace-Ports erfordert, je nach CPU Hersteller, zusätzliche Debugger-Makros für die Aktivierung und Port-Freischaltung. Zusätzlich sind die Schnittstellenauswahl und Einstellung (Frequenzen) im Entwicklungs-Tool (IDE) wichtig, um erfolgreich den Programm-Verlauf "tracen" zu können.

=== Debug und Trace-Schnittstellen ===
Als Debug Interface stehen zwei Varianten zur Auswahl:
* [[JTAG]]: Dafür sind mindestens 6 Steuerleitungen nötig. Unterstützt Device Chaining: Mehrere verbundene Geräte können mit einem Debugger/Programmer gleichzeitig angesteuert werden.
* SWD (Serial Wire Debug): Hier mindestens 2 Steuerleitungen (3 mit SWO, zzgl GND und 3,3V). Die SWD Schnittstelle ist in der Regel schneller und kann auch Funktionen aus dem Trace-Teil beinhalten (z.B. ITM, dafür wird der SWO-Pin benötigt). Device Chaining ist mit dieser Schnittstelle nicht möglich.

Standard-JTAG Steckerbelegungen:
http://www.keil.com/support/man/docs/ulink2/ulink2_hw_connectors.htm

=== Der 10polige JTAG-Stecker von mmvisual ===
mmvisual hat mit dieser Steckerbelegung die Standard JTAG Schnittstelle erweitert:

Ich habe diesen Part in den Artikel [http://www.mikrocontroller.net/articles/JTAG#Der_10-polige_JTAG_Stecker_von_mmvisual JTAG] verschoben.
Hinzu gekommen ist die Adapterplatine 10-Polig auf Standard JTAG 20 Polig mit TTL/V24 Wandler. [http://www.mikrocontroller.net/articles/JTAG#Die_Adapterplatine Siehe hier.]

== Hardware-Beschaltung ==

Der STM32 benötigt für den Betrieb nur (Minimalbeschaltung):

* VCC 2..3,3V (je nach Typ)
* AVCC 2..3,3V (sehr wichtig, der STM32 lässt sich ohne diese Spannung nicht programmieren)
* GND
* Reset Pin 100nF nach GND (ein Pull-Up Widerstand von ca. 40k ist intern vorhanden)
* [[#Bootmodi|Boot-Pins]]

ansonsten nur ein paar einzelne Cs 100nF an VCC/GND.

Um Programmieren zu können wird entweder noch die serielle Schnittstelle (Programmieren über den vorprogrammierten Bootloader) oder JTAG oder die SWD Schnittstelle benötigt.

=== Bootmodi ===
Unterschiedliche Bootmodi lassen sich mittels der PINs BOOT0 und BOOT1 auswählen . Siehe Application Note [https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Attachments/18225/AN2606.pdf AN2606]. Ausser F1 besitzen neuere Familien ein SYSCFG_MEMR Register. In dieses Register kann man die gewünschten Boot0/1 Werte schreiben und nach einem Core-Reset (!= System_Reset) startet der Prozessor im gewünschten Mode. Eine Neu- bzw. Deinitialisierung der Peripherie empfiehlt sich!

==== Boot from FLASH ====
Startadresse wird von 0x08000004 geladen
BOOT0 Lo
BOOT1 X

==== Boot from SRAM ====
PC Startadresse wird an 0x200001E0 direkt angesprungen.
BOOT0 Hi
BOOT1 Hi
Da der interne FLASH der stm32f1x laut Datenblatt nur für 1000 Schreibvorgänge ausgelegt ist, kann mittels BOOT0 (High) und BOOT1 (High) auch aus dem zuvor mit dem Debugger (JTAG/SWD) beschriebenen SRAM booten.
Hierbei gilt zu beachten:
VTOR auf die NVIC Tabelle im SRAM vor dem auslösen des ersten Interrupts remappen.

Um ein vergleichbares Startverhalten zum FLASH zu erreichen, empfiehlt es sich,
0xF1E0F85F an 0x200001E0 zu schreiben. Diese implizite Ausführung von "ldr.w pc,
[pc, #-0x01E0]" beim Start erzwingt ein laden der Startadresse von 0x20000004.

==== Boot from SYSMEM (RS232, CAN und USB) ====
PC Startadresse wird von 0x1FFFF004 geladen
BOOT0 Hi
BOOT1 Lo

Ab F2 gibt es auch ein SYSCFG_MEMRMR Register. Schreibt man hier den Wert für "System Flash" und macht einen Corereset (keinen Systemreset), so landet ,man auch im Bootloader, unabhängig von dem wert der Boot Pins.

Auch ohne JTAG lässt sich ein STM32 programmieren (Bootloader-Aktivierung). Dabei stehen, je nach CPU-Typ, verschiedene Möglichkeiten zur Verfügung:
* RS-232 (bisher alle STMs)
* USB (alle USB fähigen CPUs > F103)
* CAN (wie USB nur in bestimmten MCUs)

3 zusätzliche Verbindungen müssen auf dem Board gepatcht werden. Für einen Test geht es auch mit Tastern für RESET und BOOT0.<br>
RESET=RTS (L-aktiv)<br>
BOOT0=DTR (H-aktiv)<br>
BOOT1=LOW<br>

Details sind hier im Forum: [http://www.mikrocontroller.net/topic/141711 STM32 Programmiertool]

Tools für den Download über den STM32-Bootlaoder:
* [http://www.st.com/web/en/catalog/tools/PF257525 STSW-MCU005 STM32 and STM8 Flash loader demonstrator]
* [https://code.google.com/p/stm32flash/ Open source flash program for the STM32 ARM processors using the ST serial bootloader (for Linux)]

== Bewertung ==
=== Vorteile ===

'''Vorteile gegenüber ARM7:'''

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vektortabelle, keine Sprungliste wie bei ARM7. Durch Automatismen zwischen Core und NVIC (auto register save r0..r3, lr, sp, pc) bei Interrupt Entry wird eine deutlich schnellere Ausführungszeit bei Interrupts erreicht. Der Interrupt Code muss sich nicht mehr selbst um die Sicherung der o.g. Register kümmern und eine besondere Konfiguration der Handler im Compiler entfällt. Sind vor Beendigung einer ISR (d.h. Rücksprung zum User Code) weitere Interrupts pending, so werden diese ausgeführt, ohne dass eine komplette pop-push-sequenz der Register notwendig ist. Schön beschrieben ist es hier im [http://www.hitex.com/fileadmin/pdf/insiders-guides/stm32/isg-stm32-v18d-scr.pdf Insider's Guide] unter 2.4.5 / Seite 20.
* Thumb-2 Befehlssatz, deutlich schneller als Thumb-1 und ebenso kompakt
* Weniger Pins für Debugging benötigt durch SWD
* Mehr Hardware Breakpoints machen debuggen einfacher
* Software ist einfacher weil die Umschaltung zwischen ARM Mode und Thumb Mode wegfällt

'''Vorteile gegenüber LPC1700 und LPC1300:'''

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* FW-Lib für alle STM32 gleich, alle AppNotes/Demos beziehen sich auf diese eine FW-Lib was die Entwicklung der eigenen Applikation sehr beschleunigt.
* Genauerer und flexiblerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010) Allerdings gibts den LPC1100 mit Cortex-M0 schon ab 0,65 $!

'''Vorteile gegenüber SAM3/4:'''

* Fast alle Pins sind 5-Volt tolerant.

'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* Schnelle direkte Offset-Adressierung ermöglich effizienten Zugriff auf Stack-Variablen, lokal gespeicherte Flash-Konstanten, struct/Array-Elemente
* Einfache einheitliche Adressierung des gesamten Adressraums, d.h. Pointer auf Peripherieregister, RAM & Flash können exakt gleich behandelt werden, keinerlei Banking/Umschalt-Mechanismen erforderlich auch bei großem Flash/RAM
* Interrupt-Prioritäten und Prioritätsgruppen
* Effiziente Pointerarithmetik da Registerbreite=Adressbreite
* bessere Peripherie wie USB, Ethernet, Vielzahl an Timern
* der ARM-Core hat eine höhere Taktfrequenz und kann gleichzeitig mehr in weniger Takten berechnen
* Hardware-Division, bei einigen FPU zur effizienten float-Berechnung
* Mit größerem Flash/RAM verfügbar
* Code kann direkt aus dem RAM ausgeführt werden, Speicherschutz und privilegierter Ausführungsmodus können "Kernel"- vor "Anwendungs"-Code schützen, somit wird das dynamische Nachladen von Anwendungen aus externem Speicher effizient & sicher möglich
* ... und weitere 1000 Punkte ...

'''Links'''
* [http://www.arm.com/files/pdf/ARM_Microcontroller_Code_Size_%28full%29.pdf Code Size Analyse zwischen verschiedenen µC]

=== Nachteile ===

'''Nachteil gegenüber LPC1700:'''
* STM32F1xx: nur 72 MHz statt 100 MHz (LPC1759: 120 MHz) Taktfrequenz; STM32F2xx hat diesen Nachteil nicht (ebenfalls 120MHz, STM32F4xx mit 180MHz)
* Der LPC1700 besitzt deutlich mehr Mechanismen, um die Auswirkung der Waitstates des Flash-ROMs auf Code- und Datenzugriffe zu reduzieren und das bedeutet mehr Performance bei gleicher Taktfrequenz. Beim STM32F2 entfällt dieser Nachteil wohl aufgrund des ART Accelerators.
* Alle LPC1xxx haben 32 Bit Timer. Bei den STM32 haben das nur die STM32F2xx (2 Stück)
* I2S Einheit von ST hat keinen FIFO und im 24/32Bit Modus müssen 2x16Bit Halbwörter übertragen werden. Wobei allgemein bei neuen ARM Prozessoren die vorhandenen DMA-Kanäle (basierend auf eigenen BUS-Kanälen und Speicherzugriffen) FIFO in beliebiger Größe bedeutet.

'''Nachteil für Hobby-Anwender'''

* Nicht direkt "Steckbrettauglich", da kein DIL Gehäuse verfügbar. Der ebay-Shop dipmicro führt jedoch sehr günstige Lötadapter für Umsetzung von LQFP48 auf DIP48. QFP64 in 0.5mm Pinabstand und nicht 0.8mm wie AVR. Von NXP gibt es Cortex-M0 µC im DIL Gehäuse.

* Viel Peripherie, Clocks müssen alle richtig eingestellt werden, ggf. Anpassung des Startup Codes usw.

'''

== Errata, Tipps und Tricks ==
=== Hardware ===
* AD-Wandler PA0: Im Errata steht, dass hier Fehler in der Wandlung entstehen könnten, also einen anderen Pin verwenden.
* CAN-Bus PD0/PD1: Remap geht erst ab der 100-Pin-Version. Steht im RM0008 unter 9.3.3.: "CAN1 alternate function remapping". Alle Infos von RM0008 9.3.x sind interessant
* CAN und USB sind bei der F1 Serie nur bei der "◦Connectivity-Line" gleichzeitig nutzbar. Siehe Datenblätter.
* Mit internem RC-Oszillator kann die CPU mit maximal 64MHz betrieben werden. Mit einem externen Quarz sind dann 72MHz möglich.
* Für USB Betrieb muss die CPU mit 48MHz oder 72MHz betrieben werden (bei STM32F1xx).
* Der Idle Interrupt vom Usart wird zwar ausgelöst, aber nicht vom entsprechenden Statusflag angezeigt
* Der DMA fängt beim aktivieren immer von vorn an zu zählen, auch wenn er nur kurz angehalten wurde
* STM32F2xx hat kein Flash Size Register, bei STM32F4xx ist zwar ein flash Size Register beschrieben, kollidiert aber in der Adresse mit einem anderen Register
* Derivate mit internem EEPROM und nur einer Speicherbank haben das "Feature" bei write/erase des Data-Flashes (EEPROM) einen kompletten stall der code execution zu verursachen (inkl. ISR's, DMA). Desgleichen bei write/erase des internen Flash (ISP-routinen, EEPROM-Emulation).
* Der I2C hat diverse Fehler, welche im Errata des jeweiligen Modells (z.B. [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/errata_sheet/CD00238166.pdf STM32F105xx and STM32F107xx Errata sheet] ) zu finden sind. Workarounds hierzu finden sich in der Application Note [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/CD00209826.pdf AN2824]. Am Besten benutzt man jedoch die I2C Communication peripheral application library (CPAL) von ST ([http://www.st.com/web/catalog/tools/FM147/CL1794/SC961/SS1743/PF258336 STSW-STM32127])
* [http://blog.frankvh.com/category/stm32/ weitere undokummentierte Features]
* Interrupt-Flags in Statusregistern der diversen Peripherals wie der Timer müssen zu '''Beginn''' (bzw. möglichst weit vor dem Return) der ISR zurückgesetzt werden, da die ISR sonst eventuell 2x ausgeführt wird ([http://www.mikrocontroller.net/topic/312393#new Siehe Forum]).

=== Software ===
==== GCC ====
Um den GCC direkt zu verwenden (zB. mit selbstgebautem makefile), falls man das nicht von einer Entwicklungsumgebung machen lässt, siehe zunächst [[ARM GCC]]. STM32-spezifisches ist:
* Wird die [[#.E2.80.8ESTM32_Standard_Peripheral_Library|STM32 Standard Peripheral Library]] und ein Quarz verwendet, so muss noch per Präprozessor-Definition die Frequenz des Quarzes angegeben werden mittels z.B. -DHSE_VALUE=8000000 für 8MHz (wie auf dem STM32F4 Discovery).

===== Startupcode & Linkerscript =====
* Damit der compilierte Code an den richtigen Stellen im Controller landet (d.h. dem Flash) muss man dem Linker ein Linkerscript mitgeben. Dies geht per "-T ''pfad_zum_linkerscript.ld''" an den Linker-Befehl. Im Archiv der [[#.E2.80.8ESTM32_Standard_Peripheral_Library|STM32 Standard Peripheral Library]] befindet sich ein Beispiel-Linkerscript für die Atollic TrueSTUDIO IDE, dieses kann direkt mit dem GCC verwendet werden. Beispielsweise für den STM32F4 befindet sich das Script im Pfad "/STM32F4xx_DSP_StdPeriph_Lib_V1.1.0/Project/STM32F4xx_StdPeriph_Templates/TrueSTUDIO/STM324x7I_EVAL/stm32_flash.ld" des Archives.
* Damit beim Starten die richtigen Initialisierungen vorgenommen werden (wie globale Variablen und bei C++ Konstruktoren globaler Objekt-Instanzen) muss als erstes ein Startupcode laufen, der dann die main()-Funktion aufruft. Der Startupcode ist meistens in Assembler geschrieben, C-Code ist aber auch möglich. Im Archiv der [[#.E2.80.8ESTM32_Standard_Peripheral_Library|STM32 Standard Peripheral Library]] befindet sich ein Beispiel-Startupcode für die Atollic TrueSTUDIO IDE, dieser kann direkt mit dem GCC verwendet werden. Beispielsweise für den STM32F4 befindet sich der Code in Assemblerform im Pfad "/STM32F4xx_DSP_StdPeriph_Lib_V1.1.0/Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/TrueSTUDIO/startup_stm32f40xx.s" des Archives. Der Assemblercode kann per arm-none-eabi-as (Flags s.o.) assemblisiert werden, die resultierende .o -Datei normal mitgelinkt.

Zusammen bieten die beiden Dateien der Anwendung ein Standard-C-Interface, d.h. man kann wie gewohnt globale Variablen verwenden und seinen Code in die main()-Funktion schreiben.

=== Tipps für Umsteiger von Atmel/PIC/8051 ===
* Prozessortakt hat unterschiedliche Taktquellen und eine PLL.
* Alle Peripheriemodule haben einen extra Clock, den man aktivieren muss.
* Wenn man z.B. einen UART benutzen möchte, so muss man den Clock vom UART, Alternate Function IO (AFIO) und dem GPIO-Port aktivieren.
* Ansonsten hat man nahezu doppelt so viele Möglichkeiten in den Peripheriemodulen.
* Interrupt-Flags müssen in der ISR selber gelöscht werden
* Forum zu [http://www.mikrocontroller.net/topic/175888 Interrupts vs. Events]

=== Errata vom STM32F4xx die nicht im Errata von ST stehen ===
* [http://www.mikrocontroller.net/topic/267439#2788478 Aktivieren von DMA], wenn mehr als 3 DMA Kanäle aktiviert werden, kann es sein dass die nicht alle korrekt bedient werden. Auch klappt der DMA mit dem FSMC nicht immer zuverlässig. [https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Flat.aspx?RootFolder=%2Fpublic%2FSTe2ecommunities%2Fmcu%2FLists%2Fcortex_mx_stm32%2FWarning%20limit%20simultaneous%20DMAs%20to%202&FolderCTID=0x01200200770978C69A1141439FE559EB459D7580009C4E14902C3CDE46A77F0FFD06506F5B&currentviews=811 siehe hier] [http://blog.frankvh.com/2012/01/13/stm32f2xx-stm32f4xx-dma-maximum-transactions/ und hier]
* [http://www.mikrocontroller.net/topic/260637#2700761 Nerviger Bug in "stm32f4xx.h"] Änderung Struktur GPIO_TypeDef
* [http://www.mikrocontroller.net/topic/261690#2714754 Batterie wird leer gezogen], nur bei manchen Chips mit Rev. A
* [http://www.efton.sk/STM32/STM32F4xx_doc_errors.txt Liste von Dokumentations-Fehlern]

== Bezugsquellen ==

=== Controller ===

Versandhäuser für Privatpersonen
* [http://www.reichelt.de/STM-Controller/2/index.html?;ACTION=2;LA=2;GROUPID=2950; Reichelt]
* [http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html Darisus]
* [http://www.hbe-shop.de HBE (Farnell Programm für Private)]
* [http://www.sander-electronic.de/be00069.html Sander]
* [http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+ TME]
* [http://teske-electronics.de/index.php?cPath=3_9_53 Teske electronics]
* [http://de.rs-online.com/web/c/halbleiter/prozessoren-und-mikrocontroller/mikrocontroller/?sort-by=default&sort-order=default&applied-dimensions=4294417325&lastAttributeSelectedBlock=4294425895 RS-Online]

Gewerblich liefern natürlich viele wie EBV, Mouser, Farnell, Digikey usw...

=== Evaluation Boards ===

* [http://shop.embedded-projects.net/index.php?module=artikel&action=gruppe&id=14 Im Shop von Embedded Projects]
* [http://www.watterott.com/de/Boards-Kits/ARM/ARM-Cortex-M3 Cortex M3 bei Watterott]
* [http://www.raisonance.com/~primer-starter-kits__microcontrollers__tool~tool__T018:4enfvamuxbtp.html Primer und Primer2 von Raisonance]
* [http://www.sander-electronic.de/es0028.html Sander Electronic]
* [http://www.mikrocontroller.net/articles/MP32F103-Stick:_Ein_Mini-Mikrocontroller-Board_mit_USB_und_bis_zu_4MB_Datenspeicher Artikel im Wiki, ARM mit USB und 4MB Speicher]
* [http://www.futurlec.com/STM32_Development_Board.shtml Futurlec Evalboard, ebenso Header-Board]
* [http://www.propox.com/products/t_174.html Propox, Header-Boards für 103R und 103V sowie Trägerplatine dafür]
* [http://www.mikrocontroller.net/articles/Cortex_M3_OCM3U Cortex M3 Artikel im Wiki]
* [http://olimex.com/dev/index.html STM32 bei Olimex]
* [http://de.farnell.com/jsp/displayProduct.jsp?sku=1824325&action=view&CMP=GRHS-1000962 STM32Discovery bei Farnell] Mikrocontroller Board (STM32F100RBT6B) mit onboard USB-Programming Interface für ca. 12,50€
* [http://www.de.rs-online.com/web/p/products/7458434/ STM32Discovery bei RS-Components] 12,65 € +MwSt.
* [http://www.segor.de/#Q=STM32 VL DISCOVERY] STM32 Discovery bei Segor
* [http://www.watterott.com/de/STM32F4Discovery STM32F4DISCOVERY] STM32F4 Cortex M4 Controller mit JTAG-Debugger auf der Platine bei Watterott für 16,66EUR.
* [http://www.conrad.de/ce/de/product/443910/ STM32F4 Discovery Kit bei Conrad] 17,11 €
* [http://www.mcu-raisonance.com/~open4-development-platform__microcontrollers__tool~tool__T018:g65gu6ghg2n.html/ Open 4 oder auch genannt Evo-Primer]
* [http://www.wayengineer.com/index.php?main_page=index&cPath=50_66&page=1&sort=3a WayEngineer]
* [http://thinkembedded.ch/ST-STMicroelectronics:::24.html Im Thinkembedded Shop] in der Schweiz / DiscoveryF4, div. ETT und Olimex Boarde ab 20,18 CHF / 16,15 EUR (inkl. MwSt.) zzgl. Versandkosten
* [http://shop.myavr.de/ARM-Produktlinie/STM32F4-Discovery.htm?sp=article.sp.php&artID=200072 Im myAVR Shop] DiscoveryF4 mit möglichem Zubehör 16,45 EUR (inkl. MwSt.) zzgl. Versandkosten
* [http://www.keil.com/boards/cortexm.asp Keil/ARM Demoboards]
* [http://www.phytec.de Phytec]
* [http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=37 verschiedene ARM Produkte und Erweiterungen bei myAVR]
* [http://re.reworld.eu/de/produkte/s64dil-405/index.htm S64DIL-405 STM32Fxxx ARM Cortex M3 Mikrocontrollermodul mit USB-Schnittstelle, Steckbretttauglich] (Leerplatine eignet sich auch für STM32F1xx Prozessoren.)

== Weblinks, Foren, Communities, Tutorials ==
* [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks STM32 - Einstieg mit Em::Blocks Tutorial]
* [http://www.mikrocontroller.net/topic/173753 Diskussion zum Artikel]
* [http://www.mikrocontroller.net/forum/mikrocontroller-elektronik?filter=ARM*+STM32*+Cortex* Suche im Forum]
* [[STM32 für Einsteiger]]
* [[STM32 CooCox Installation]]
* [https://my.st.com/public/STe2ecommunities/mcu/Lists/ARM%20CortexM3%20STM32/AllItems.aspx Forum auf der ST Homepage]
* [http://www.stm32circle.com/hom/index.php STM32 Community]
*[http://joe-c.de/pages/posts/einstieg_mikrocontroller_stm32f103_101.php Einstieg: STM32board mit Kamera (deutsch)]
* [http://www.ebv.com/fileadmin/products/Press_Print/Brochures/Product_Brochures/EBV_Cortex%20Collection_V2.pdf Übersicht der Cortex Prozessoren und deren Hersteller (nicht nur ST, von EBV)]
* [http://www.mikrocontroller.net/topic/258652 Tutorial]
* [http://diller-technologies.de/stm32_wide.html STM32 Tutorial in Deutsch von Diller Technologies]
* [http://mySTM32.de STM32 C und C++ Tutorial in Deutsch ]
* [http://mikrocontroller.bplaced.net STM32F4 Quellcode-Librarys und CooCox-Projekte in Deutsch ]
* [http://myugl.de Tutorial für Grafik-Librarys und SiSy-Projekte in Deutsch ]
* [http://www.st.com/web/en/catalog/tools/FM147/CL1794/SC961/SS1533/PF251717 MicroXplorer MCU graphical configuration tool ]

<references/>
[[Kategorie:ARM]]
[[Kategorie:STM32]]
[[Kategorie:Mikrocontroller]]

STM32 - Einstieg mit Em::Blocks

2014-02-28T15:41:54Z

Avrprogger: /* Core-Coupled-RAM verwenden */

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
Um Libraries, wie hier im Tutorial, einzubinden, wird ein existierendes Projekt, wie ein im Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Das_erste_Projekt_erstellen Das Erste Projekt erstellen] beschrieben wird, vorausgesetzt.

===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Ich kopiere die Standard-Peripheral-Library immer per Hand in das Projekt. Darduch hat man auch gleich die aktuellste Version (in den älteren Version gibt es einige Bugs).

*1. Den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis kopieren
*2. Die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren.
*3. In der IDE den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen
*4. Und das/den Define '''''USE_STDPERIPH_DRIVER''''' hinzufügen
*4. Source- und Include-Dateien zum Projekt hinzufügen
**Achtung: Es dürfen nur die Dateien hinzugefügt werden, für die der Controller auch die entsprechende Peripherie bereit stellt. Diese Dateien dürfen nicht beim STM32F4-Discovery/STM32F407VG hinzugefügt werden.
***stm32f4xx_dma2d.c/.h
***stm32f4xx_fmc.c/.h
***stm32f4xx_ltdc.c/.h
***stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

Hier ist noch ein "BasicFramework", dass die komplette CMSIS- und Standard-Peripheral-Library enthält und kann Quasi als Basis für alle Projekte verwendet werden. Allerdings ist das Framework primär auf die STM32F405/7 und STM32F415/7 ausgelegt. Die neueren STM32F401, STM32F42X und STM32F43X haben noch etwas andere Peripherie, dass Framework müsste dann entsprechend angepasst werden. Download: [[Datei:StdPeriphDriver_BasicFramework.zip]]

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').

*1. Source-Dateien des benötigten Moduls zum Projekt hinzufügen. ('''''<ProjektName> -> Rechts Klick -> Add files...''''')
*2. '''''arm_math.h''''' in der '''''main.c''''' einbinden
*3. Damit die Warnung "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" verschwindet, muss der Define '''''__FPU_PRESENT''''' hinzugefügt werden. (Keine Ahnung, wieso es die Warnung gibt)

Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerufen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Core-Coupled-RAM verwenden===
Auf den normale SRAM kann durch den Core und die verschiedenen DMA-Controller zugegriffen werden. Jedoch können Core und DMA nicht gleichzeitig auf den SRAM zugreifen. Deswegen gibt es einen zweiten kleinen RAM, den Core-Coupled-RAM (CCRAM), auf den nur vom Core zugegriffen werden kann und nicht von einem DMA-Controller. Der CCRAM ist über einen anderen Bus an dem Cortex angeschlossen. Daduch wird ermöglicht, dass der Core sinnvoll weiterarbeiten kann, wenn ein DMA-Controller Daten aus den "Haupt"-RAM ließt/schreibt, indem der Core Daten aus dem CCRAM verarbeitet. Um Daten in den CCRAM zu legen, geht man wie folgt vor:

1. Eine neue Section im Linkerscript anlegen:
<syntaxhighlight lang="c">
Sections:
{
...

.ccram :
{
*(.ccram)
} > CCRAM

...
}
</syntaxhighlight>

2. Um die neue Section zu verwenden benutzt man diesen Define:
<syntaxhighlight lang="c">
#define CCRAM __attribute__((section(".ccram")))

...

int CCRAM dataInCCRAM;
</syntaxhighlight>

Beim Debuggen stellt man fest das die Variable an der Adresse 0x10000000 liegt, der ersten Adresse das CCRAM's.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

[[Datei:bootsram_1.png Booten aus dem SRAM]] [[Datei:bootsram_2.png Booten aus dem SRAM]]

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-28T15:32:16Z

Avrprogger: /* Core-Coupled-RAM verwenden */

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
Um Libraries, wie hier im Tutorial, einzubinden, wird ein existierendes Projekt, wie ein im Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Das_erste_Projekt_erstellen Das Erste Projekt erstellen] beschrieben wird, vorausgesetzt.

===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Ich kopiere die Standard-Peripheral-Library immer per Hand in das Projekt. Darduch hat man auch gleich die aktuellste Version (in den älteren Version gibt es einige Bugs).

*1. Den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis kopieren
*2. Die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren.
*3. In der IDE den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen
*4. Und das/den Define '''''USE_STDPERIPH_DRIVER''''' hinzufügen
*4. Source- und Include-Dateien zum Projekt hinzufügen
**Achtung: Es dürfen nur die Dateien hinzugefügt werden, für die der Controller auch die entsprechende Peripherie bereit stellt. Diese Dateien dürfen nicht beim STM32F4-Discovery/STM32F407VG hinzugefügt werden.
***stm32f4xx_dma2d.c/.h
***stm32f4xx_fmc.c/.h
***stm32f4xx_ltdc.c/.h
***stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

Hier ist noch ein "BasicFramework", dass die komplette CMSIS- und Standard-Peripheral-Library enthält und kann Quasi als Basis für alle Projekte verwendet werden. Allerdings ist das Framework primär auf die STM32F405/7 und STM32F415/7 ausgelegt. Die neueren STM32F401, STM32F42X und STM32F43X haben noch etwas andere Peripherie, dass Framework müsste dann entsprechend angepasst werden. Download: [[Datei:StdPeriphDriver_BasicFramework.zip]]

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').

*1. Source-Dateien des benötigten Moduls zum Projekt hinzufügen. ('''''<ProjektName> -> Rechts Klick -> Add files...''''')
*2. '''''arm_math.h''''' in der '''''main.c''''' einbinden
*3. Damit die Warnung "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" verschwindet, muss der Define '''''__FPU_PRESENT''''' hinzugefügt werden. (Keine Ahnung, wieso es die Warnung gibt)

Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerufen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Core-Coupled-RAM verwenden===
Auf den normale SRAM kann durch den Core und die verschiedenen DMA-Controller zugegriffen werden. Jedoch können Core und DMA nicht gleichzeitig auf den SRAM zugreifen. Deswegen gibt es einen zweiten kleinen RAM, den Core-Coupled-RAM (CCRAM), auf den nur vom Core zugegriffen werden kann und nicht von einem DMA-Controller. Der CCRAM ist über einen anderen Bus an dem Cortex angeschlossen. Daduch wird ermöglicht, dass der Core sinnvoll weiterarbeiten kann, wenn ein DMA-Controller Daten aus den "Haupt"-RAM ließt/schreibt, indem der Core Daten aus dem CCRAM verarbeitet. Um Daten in den CCRAM zu legen, geht man wie folgt vor:

1. Eine neue Section im Linkerscript anlegen:
<syntaxhighlight lang="c">
Sections:
{
...

.ccram :
{
*(.ccram)
} > CCRAM

...
}
</syntaxhighlight>

2. Um die neue Section zu verwenden benutzt man diesen Define:
<syntaxhighlight lang="c">
#define CCRAM __attribute__((section(".ccram")))

...

int CCRAM dataInCCRAM1;
char CCRAM dataInCCRAM2;
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

[[Datei:bootsram_1.png Booten aus dem SRAM]] [[Datei:bootsram_2.png Booten aus dem SRAM]]

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-28T15:29:49Z

Avrprogger: /* Die FPU */

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
Um Libraries, wie hier im Tutorial, einzubinden, wird ein existierendes Projekt, wie ein im Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Das_erste_Projekt_erstellen Das Erste Projekt erstellen] beschrieben wird, vorausgesetzt.

===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Ich kopiere die Standard-Peripheral-Library immer per Hand in das Projekt. Darduch hat man auch gleich die aktuellste Version (in den älteren Version gibt es einige Bugs).

*1. Den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis kopieren
*2. Die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren.
*3. In der IDE den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen
*4. Und das/den Define '''''USE_STDPERIPH_DRIVER''''' hinzufügen
*4. Source- und Include-Dateien zum Projekt hinzufügen
**Achtung: Es dürfen nur die Dateien hinzugefügt werden, für die der Controller auch die entsprechende Peripherie bereit stellt. Diese Dateien dürfen nicht beim STM32F4-Discovery/STM32F407VG hinzugefügt werden.
***stm32f4xx_dma2d.c/.h
***stm32f4xx_fmc.c/.h
***stm32f4xx_ltdc.c/.h
***stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

Hier ist noch ein "BasicFramework", dass die komplette CMSIS- und Standard-Peripheral-Library enthält und kann Quasi als Basis für alle Projekte verwendet werden. Allerdings ist das Framework primär auf die STM32F405/7 und STM32F415/7 ausgelegt. Die neueren STM32F401, STM32F42X und STM32F43X haben noch etwas andere Peripherie, dass Framework müsste dann entsprechend angepasst werden. Download: [[Datei:StdPeriphDriver_BasicFramework.zip]]

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').

*1. Source-Dateien des benötigten Moduls zum Projekt hinzufügen. ('''''<ProjektName> -> Rechts Klick -> Add files...''''')
*2. '''''arm_math.h''''' in der '''''main.c''''' einbinden
*3. Damit die Warnung "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" verschwindet, muss der Define '''''__FPU_PRESENT''''' hinzugefügt werden. (Keine Ahnung, wieso es die Warnung gibt)

Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerufen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Core-Coupled-RAM verwenden===
Auf den normale SRAM kann durch den Core und die verschiedenen DMA-Controller zugegriffen werden. Jedoch können Core und DMA nicht gleichzeitig auf den SRAM zugreifen. Deswegen gibt es einen zweiten kleinen RAM, den Core-Coupled-RAM (CCRAM), auf den nur vom Core zugegriffen werden kann und nicht von einem DMA-Controller. Der CCRAM ist über einen anderen Bus an dem Cortex angeschlossen. Daduch wird ermöglicht, dass der Core sinnvoll weiterarbeiten kann, wenn ein DMA-Controller Daten aus den "Haupt"-RAM ließt/schreibt, indem der Core Daten aus dem CCRAM verarbeitet. Um Daten in den CCRAM zu legen, geht man wie folgt vor:

1. Eine neue Section im Linkerscript anlegen:
<syntaxhighlight lang="c">
Sections:
{
...

.CCRAM :
{
*(.CCRAM)
} > CCRAM

...
}
</syntaxhighlight>

2. Um die neue Section zu verwenden benutzt man diesen Define:
<syntaxhighlight lang="c">
#define CCRAM __attribute__((section(".ccram")))

...

int CCRAM dataInCCRAM1;
char CCRAM dataInCCRAM2;
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

[[Datei:bootsram_1.png Booten aus dem SRAM]] [[Datei:bootsram_2.png Booten aus dem SRAM]]

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

Datei:StdPeriphDriver BasicFramework.zip

2014-02-16T19:08:03Z

Avrprogger:

STM32 - Einstieg mit Em::Blocks

2014-02-16T19:07:38Z

Avrprogger: cvb

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
Um Libraries, wie hier im Tutorial, einzubinden, wird ein existierendes Projekt, wie ein im Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Das_erste_Projekt_erstellen Das Erste Projekt erstellen] beschrieben wird, vorausgesetzt.

===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Ich kopiere die Standard-Peripheral-Library immer per Hand in das Projekt. Darduch hat man auch gleich die aktuellste Version (in den älteren Version gibt es einige Bugs).

*1. Den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis kopieren
*2. Die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren.
*3. In der IDE den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen
*4. Und das/den Define '''''USE_STDPERIPH_DRIVER''''' hinzufügen
*4. Source- und Include-Dateien zum Projekt hinzufügen
**Achtung: Es dürfen nur die Dateien hinzugefügt werden, für die der Controller auch die entsprechende Peripherie bereit stellt. Diese Dateien dürfen nicht beim STM32F4-Discovery/STM32F407VG hinzugefügt werden.
***stm32f4xx_dma2d.c/.h
***stm32f4xx_fmc.c/.h
***stm32f4xx_ltdc.c/.h
***stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

Hier ist noch ein "BasicFramework", dass die komplette CMSIS- und Standard-Peripheral-Library enthält und kann Quasi als Basis für alle Projekte verwendet werden. Allerdings ist das Framework primär auf die STM32F405/7 und STM32F415/7 ausgelegt. Die neueren STM32F401, STM32F42X und STM32F43X haben noch etwas andere Peripherie, dass Framework müsste dann entsprechend angepasst werden. Download: [[Datei:StdPeriphDriver_BasicFramework.zip]]

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').

*1. Source-Dateien des benötigten Moduls zum Projekt hinzufügen. ('''''<ProjektName> -> Rechts Klick -> Add files...''''')
*2. '''''arm_math.h''''' in der '''''main.c''''' einbinden
*3. Damit die Warnung "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" verschwindet, muss der Define '''''__FPU_PRESENT''''' hinzugefügt werden. (Keine Ahnung, wieso es die Warnung gibt)

Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerufen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

[[Datei:bootsram_1.png Booten aus dem SRAM]] [[Datei:bootsram_2.png Booten aus dem SRAM]]

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

Datei:Bootsram 2.png Booten aus dem SRAM

2014-02-13T14:27:40Z

Avrprogger:

Datei:Bootsram 1.png Booten aus dem SRAM

2014-02-13T14:27:25Z

Avrprogger:

STM32 - Einstieg mit Em::Blocks

2014-02-13T14:27:05Z

Avrprogger: fgh

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
Um Libraries, wie hier im Tutorial, einzubinden, wird ein existierendes Projekt, wie ein im Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Das_erste_Projekt_erstellen Das Erste Projekt erstellen] beschrieben wird, vorausgesetzt.

===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Ich kopiere die Standard-Peripheral-Library immer per Hand in das Projekt. Darduch hat man auch gleich die aktuellste Version (in den älteren Version gibt es einige Bugs).

*1. Den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis kopieren
*2. Die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren.
*3. In der IDE den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen
*4. Und das/den Define '''''USE_STDPERIPH_DRIVER''''' hinzufügen
*4. Source- und Include-Dateien zum Projekt hinzufügen
**Achtung: Es dürfen nur die Dateien hinzugefügt werden, für die der Controller auch die entsprechende Peripherie bereit stellt. Diese Dateien dürfen nicht beim STM32F4-Discovery/STM32F407VG hinzugefügt werden.
***stm32f4xx_dma2d.c/.h
***stm32f4xx_fmc.c/.h
***stm32f4xx_ltdc.c/.h
***stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').

*1. Source-Dateien des benötigten Moduls zum Projekt hinzufügen. ('''''<ProjektName> -> Rechts Klick -> Add files...''''')
*2. '''''arm_math.h''''' in der '''''main.c''''' einbinden
*3. Damit die Warnung "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" verschwindet, muss der Define '''''__FPU_PRESENT''''' hinzugefügt werden. (Keine Ahnung, wieso es die Warnung gibt)

Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

[[Datei:bootsram_1.png Booten aus dem SRAM]] [[Datei:bootsram_2.png Booten aus dem SRAM]]

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-13T14:18:19Z

Avrprogger: gj

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
Um Libraries, wie hier im Tutorial, einzubinden, wird ein existierendes Projekt, wie ein im Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Das_erste_Projekt_erstellen Das Erste Projekt erstellen] beschrieben wird, vorausgesetzt.

===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Ich kopiere die Standard-Peripheral-Library immer per Hand in das Projekt. Darduch hat man auch gleich die aktuellste Version (in den älteren Version gibt es einige Bugs).

*1. Den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis kopieren
*2. Die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren.
*3. In der IDE den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen
*4. Und das/den Define '''''USE_STDPERIPH_DRIVER''''' hinzufügen
*4. Source- und Include-Dateien zum Projekt hinzufügen
**Achtung: Es dürfen nur die Dateien hinzugefügt werden, für die der Controller auch die entsprechende Peripherie bereit stellt. Diese Dateien dürfen nicht beim STM32F4-Discovery/STM32F407VG hinzugefügt werden.
***stm32f4xx_dma2d.c/.h
***stm32f4xx_fmc.c/.h
***stm32f4xx_ltdc.c/.h
***stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').

*1. Source-Dateien des benötigten Moduls zum Projekt hinzufügen. ('''''<ProjektName> -> Rechts Klick -> Add files...''''')
*2. '''''arm_math.h''''' in der '''''main.c''''' einbinden
*3. Damit die Warnung "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)" verschwindet, muss der Define '''''__FPU_PRESENT''''' hinzugefügt werden. (Keine Ahnung, wieso es die Warnung gibt)

Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-13T14:13:39Z

Avrprogger: dfg

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
Um Libraries, wie hier im Tutorial, einzubinden, wird ein existierendes Projekt, wie ein im Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Das_erste_Projekt_erstellen Das Erste Projekt erstellen] beschrieben wird, vorausgesetzt.

===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Ich kopiere die Standard-Peripheral-Library immer per Hand in das Projekt. Darduch hat man auch gleich die aktuellste Version (in den älteren Version gibt es einige Bugs).

*1. Den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis kopieren
*2. Die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren.
*3. In der IDE den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen
*4. Und das/den Define '''''USE_STDPERIPH_DRIVER''''' hinzufügen
*4. Source- und Include-Dateien zum Projekt hinzufügen
**Achtung: Es dürfen nur die Dateien hinzugefügt werden, für die der Controller auch die entsprechende Peripherie bereit stellt. Diese Dateien dürfen nicht beim STM32F4-Discovery/STM32F407VG hinzugefügt werden.
***stm32f4xx_dma2d.c/.h
***stm32f4xx_fmc.c/.h
***stm32f4xx_ltdc.c/.h
***stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-13T10:50:26Z

Avrprogger: jkl

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Ich kopiere die Standard-Peripheral-Library immer per Hand in das Projekt. Darduch hat man auch gleich die aktuellste Version (in den älteren Version gibt es einige Bugs). Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst (den Haken bei '''''Use Standard Peripherals Library''''' also auch wieder weg nehmen) und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' ein, wie bereits bei der CMSIS-Library (s.o.) beschrieben.
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-13T10:50:01Z

Avrprogger: fgh

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Ich kopiere die Standard-Peripheral-Library immer per Hand in das Projekt. Darduch hat man auch gleich die aktuellste Version (in den älteren Version gibt es einige Bugs). Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst (den Haken bei '''''Use Standard Peripherals Library''''' also auch wieder weg nehmen''''') und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' ein, wie bereits bei der CMSIS-Library (s.o.) beschrieben.
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T16:43:17Z

Avrprogger: dfg

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T16:42:49Z

Avrprogger: cvb

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
STM32F3 und STM32F4 Controller haben eine FPU.
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T16:41:20Z

Avrprogger: xcv

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===3. Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T16:40:48Z

Avrprogger: sdf

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''<ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T16:40:07Z

Avrprogger: fgh

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Rechts Klick -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T16:38:16Z

Avrprogger: ghj

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T16:37:53Z

Avrprogger: jhk

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU, Optimierung usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T16:37:20Z

Avrprogger: cvb

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

=====Verschiedene C-Standards=====
Unter '''''<ProjektName> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU, Optimierung usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Compiler-Optimierung===
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T16:36:13Z

Avrprogger: cvb

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

====Compiler Optionen====
=====Optimierung=====
=====Verschiedene C-Standards=====
Unter '''''<ProjektName> Rechts Klick -> Build options... -> Categories: Language standard''''' kann man zwischen verschieden C-Standard auswählen, wie z.B, C99.
(Mit C99 können auch die Lauf-Variable in der for-Schleife deklariert werden: for(int i;..))

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU, Optimierung usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Compiler-Optimierung===
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T16:30:25Z

Avrprogger: dfs

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Hinzufügen von globalen Defines zum Build===
Unter '''''<ProjektName> Rechts Klick -> Build options... -> #defines''''' können globale Defines hinzugefügt werden.

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU, Optimierung usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Compiler-Optimierung===
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T16:27:35Z

Avrprogger: ghj

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU, Optimierung usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Compiler-Optimierung===
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T16:26:45Z

Avrprogger: ghj

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===
STM32F3 / STM32F4 Microcontroller haben neben der FPU noch einen Digital-Signal-Processor (DSP). Die DSP dient hauptsächlich dazu, viele Daten schnell zu verarbeiten (z.B. Video- oder Audiosignal). Der CMSIS-Download beinhaltet dazu neben der eigentlichen CMSIS-Library auch noch eine DSP-Library. Diese Library stellt sowohl einfache, mathematische Funktionen wie addieren, multiplizieren usw. als auch komplexe Funktionen, wie z.B einen IIR-Filter, zur Verfügung. Die DSP-Library ist weiter aufgeteilt in kleinere Module, wie z.B. BasicMathFunctions, FilteringFunctions usw. (siehe '''''CMSIS\DSP-Library\Source''''').
Um die DSP-Library zu verwenden müssen eigentlich nur die Source-Files des benötigten Moduls einbinden.
('''''<ProjektName> -> Add files...'''''). Außerdem muss in der '''''main.c''''' der Include '''''arm_math.h''''' eingebunden werden. Aus irgendeinem Grund gibt es dann jedoch die Warnung: "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)". Ich hab noch nicht rausgefunden, wieso diese Warnung auftaucht. Die Warnung verschwindet, wenn man in der '''''Build options...''''' das Define '''''__FPU_PRESENT''''' hinzufügt (Ich weiß selber das das keine schöne Lösung ist, eine andere hab ich jedoch noch nicht gefunden). Jetzt kann die DSP-Library verwedet werden. Das Beispiel multipliziert zwei Buffer miteinander. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"
#include "arm_math.h"

int main(void)
{
float32_t x[1024];
float32_t y[1024];
float32_t z[1024];

for(uint16_t i = 0; i < 1024; i++)
{
x[i] = i;

}

for(uint16_t i = 0; i < 1024; i++)
{
y[i] = PI;
}

arm_mult_f32(x, y, z, 1024);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU, Optimierung usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Compiler-Optimierung===
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-11T15:32:34Z

Avrprogger: sdf

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

===Einbinden der DSP-Library===

==Startup-Code, Linker-Script, Takt, FPU, Optimierung usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Compiler-Optimierung===
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T21:26:08Z

Avrprogger: dsf

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU, Optimierung usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Compiler-Optimierung===
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories: Optimization''''' kann zwischen verschieden Optimierungen ausgewählt werden.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T21:25:11Z

Avrprogger: cvb

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU, Optimierung usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Compiler-Optimierung===
Standardmäßig verwendet Em::Blocks keine Optimierung. Unter '''''<ProjektName> -> Rechts Klick -> Build options... -> Categories''''' kann zwischen verschieden Optimierungen ausgewählt werden.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T21:20:38Z

Avrprogger: dfg

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU, Optimierung usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = (t2 - t1) - 9; //9 Takt-Zyklen werden für die Messung gebraucht

while(1)
{
}
}
</syntaxhighlight>

===Compiler-Optimierung===

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T21:19:20Z

Avrprogger: dfg

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU, Optimierung usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

===Compiler-Optimierung===

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T21:09:52Z

Avrprogger: dfgf

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T16:55:02Z

Avrprogger: ghj

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

Die Messung alleine braucht davon 9 Takt-Zyklen. Zum Vergleich ist das aber nicht relevant.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T16:39:48Z

Avrprogger: vbnb

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

Die Messung alleine braucht aber auch noch 9 Takt-Zyklen. Zum Vergleich reicht es aber.

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T16:33:48Z

Avrprogger: dg

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
Em::Blocks stellt zwei fertige Linker-Scripts bereit, eins für die Ausführung des Programmes aus dem Flash ('''''*_flash.ld'''''), das andere für die Ausführung aus dem SRAM ('''''*_sram.ld''''').

Normalerweise muss auch hier nichts geändert werden, es sei den Daten sollen in bestimmten Adressbereichen abgelegt werden (z.B. im Core-Coupled RAM), was ich später noch zum Tutorial hinzufüge.

===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T16:29:13Z

Avrprogger: fd

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn '''''__NO_SYSTEM_INIT''''' nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T16:28:38Z

Avrprogger: fdg

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
Em::Blocks fügt standardmäßig einen Startup-Code mit in das Projekt ein. Die wichtigsten Dinge die darin erledigt werden sind folgende:

*Stack und Heap wird angelgt
*Die Vector-Table wird angelegt
*Ein Default Reset-Handler wird implementiert, dieser erledigt folgende aufgaben:
**Kopieren der definierten Daten aus dem Flash in den SRAM
**'''''SystemInit()''''' wird aufgerfen, wenn __NO_SYSTEM_INIT nicht definiert ist
**Sprung in die '''''main()''''' Funktion
*Allen anderen Interrupt-Handler wird eine Default-Funktion '''''def_irq_handler''''' mit einer '''''while(1)'''''-Schleife zugewiesen, falls kein anderer Interrupt-Handler existiert.

Normalerweise muss am Startup-Code nichts verändert werden.

===Linker-Script===
===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T16:21:17Z

Avrprogger: dfgf

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linker-Script, Takt, FPU usw.==
===Startup-Code===
===Linker-Script===
===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T16:20:29Z

Avrprogger: cvb

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Startup-Code, Linkerscript, Takt, FPU usw.==
===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T15:25:39Z

Avrprogger: bnm

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Libraries einbinden/verwenden==
===Einbinden der Standard-Peripheral-Library===
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Takt, FPU usw.==
===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T15:24:49Z

Avrprogger: vbn

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Einbinden der Standard-Peripheral-Library==
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Takt, FPU usw.==
===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T15:22:50Z

Avrprogger: dfhf

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Takt, FPU usw.==
===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Die Theorie wird durch folgendes Programm verifiziert. Der geviertelte System-Takt SYSCLK wir am Pin PC9 ausgegeben. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

GPIO_InitTypeDef GPIOC_InitStructure;
GPIOC_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIOC_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIOC_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIOC_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIOC_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &GPIOC_InitStructure);

RCC_MCO2Config(RCC_MCO2Source_SYSCLK, RCC_MCO2Div_4);

while(1)
{
}
}
</syntaxhighlight>

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

==Einbinden der Standard Peripheral Library==
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-10T15:03:13Z

Avrprogger: vcb

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Takt, FPU usw.==
===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Achtung!:
In dem "Kommentar-Header" der '''''system_stm32f4xx.c''''' steht in der letzten Zeile immer:
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* Require 48MHz for USB OTG FS, | Disabled
* SDIO and RNG clock |
*-----------------------------------------------------------------------------
</syntaxhighlight>

Das ist jedoch falsch, weil der Takt für USB, SDIO und RNG immer mit der PLL über den Teiler PPL_Q eingestellt wird. Der Takt ist somit immer vorhanden und muss nicht extra Eingeschaltet werden. (Erspart langes Suchen, nach den entsprechenden Registern)

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

==Einbinden der Standard Peripheral Library==
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //Als Ausgang
GPIOD_InitStructure.GPIO_OType = GPIO_OType_PP; //Push-Pull Betrieb
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15; //Pin 15 (STM32F4-Discovery: Blaue LED)
GPIOD_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //Kein Pull-Up oder Pull-Down Widerstand aktiviert
GPIOD_InitStructure.GPIO_Speed = GPIO_Speed_25MHz; //25MHz Update-Rate
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-09T18:40:07Z

Avrprogger: dfg

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Takt, FPU usw.==
===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Achtung!:
In dem "Kommentar-Header" der '''''system_stm32f4xx.c''''' steht in der letzten Zeile immer:
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* Require 48MHz for USB OTG FS, | Disabled
* SDIO and RNG clock |
*-----------------------------------------------------------------------------
</syntaxhighlight>

Das ist jedoch falsch, weil der Takt für USB, SDIO und RNG immer mit der PLL über den Teiler PPL_Q eingestellt wird. Der Takt ist somit immer vorhanden und muss nicht extra Eingeschaltet werden. (Erspart langes Suchen, nach den entsprechenden Registern)

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

==Einbinden der Standard Peripheral Library==
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15;
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-09T18:39:39Z

Avrprogger: fdg

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Download: [[Datei:FirstProject.zip]]

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Takt, FPU usw.==
===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Achtung!:
In dem "Kommentar-Header" der '''''system_stm32f4xx.c''''' steht in der letzten Zeile immer:
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* Require 48MHz for USB OTG FS, | Disabled
* SDIO and RNG clock |
*-----------------------------------------------------------------------------
</syntaxhighlight>

Das ist jedoch falsch, weil der Takt für USB, SDIO und RNG immer mit der PLL über den Teiler PPL_Q eingestellt wird. Der Takt ist somit immer vorhanden und muss nicht extra Eingeschaltet werden. (Erspart langes Suchen, nach den entsprechenden Registern)

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

==Einbinden der Standard Peripheral Library==
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15;
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-09T18:39:21Z

Avrprogger: fgh

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Download: [[Datei:FirstProject.zip]]

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Takt, FPU usw.==
===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Achtung!:
In dem "Kommentar-Header" der '''''system_stm32f4xx.c''''' steht in der letzten Zeile immer:
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* Require 48MHz for USB OTG FS, | Disabled
* SDIO and RNG clock |
*-----------------------------------------------------------------------------
</syntaxhighlight>

Das ist jedoch falsch, weil der Takt für USB, SDIO und RNG immer mit der PLL über den Teiler PPL_Q eingestellt wird. Der Takt ist somit immer vorhanden und muss nicht extra Eingeschaltet werden. (Erspart langes Suchen, nach den entsprechenden Registern)

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

Download: [[Datei:FPU_Test.zip]]

==Einbinden der Standard Peripheral Library==
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15;
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]

STM32 - Einstieg mit Em::Blocks

2014-02-09T18:39:04Z

Avrprogger: uzt

In diesem Tutorial werde ich versuchen, möglichst einfach, die ersten Schritte zur Entwicklung von STM32 Anwenungen mit der Em::Blocks IDE zu erklären. Hier soll nicht so stark auf die einzelnen Peripherie-Module der Controller eingegangen werden, sondern mehr auf die IDE und die verschieden Libraries, wie die CMSIS Library, die DSP-Library, die Standard-Peripheral-Library, die USB-Library und vllt. über Ethernet. Ich denke ein Kapitel zu FreeRTOS wird es auch geben. Auserdem steht im Vordergrund Sachen wie z.B. booten aus dem SRAM, In-Application-Programming, FPU, Core-Coupled-RAM usw. Mal sehn wie weit ich komme ;)

==Die Entwicklungsumgebung==
===Hardware===
Zum testen der Anwendungen, benutze ich das STM32F4-Discovery Board, welches einen Debugger, Peripherie und natürlich einen STM32 Controller (STM32F407VGT6) enthält. Deshalb sind alle Beispiele hier für den STM32F407VG Controller ausgelegt, können aber meisten 1:1 auf andere Controller portiert werden. Ich werde auch möglichsts keine STM32F4-Discovery Board spezifischen Libraries verwenden, damit der Portierungs-Vorgang möglichsts einfach bleibt.

===Software===
In diesem Tutorial verwende ich [http://www.emblocks.org/ Em::Blocks] als IDE. Em::Blocks ist eine kostenlose, uneingeschränkte IDE, die alle STM32 Mikrcontroller unterstützt und sehr einfach zu bedienen ist.
nach dem Download kann die IDE per Dialog, sehr einfach, installiert werden. Als Compiler beinhaltet Em::Blocks den '''''ARM GCC Compiler'''''.
Die IDE unterstützt zurzeit den ST-Link, den J-Link und es gibt eine Generic-Vorlage, durch welche andere Debugger konfiguriert werden können.

Außerdem muss noch der passende Treiber für den Debugger installiert werden. Verwendet man ein Discovery-Board muss der [http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-Link/V2]-Treiber heruntergeladen und installiert werden. (Die Installation muss evtl. als Administrator ausgeführt werden, da sonst die Installation unvollständig wird.) Nach der Installation des Treibers kann man den Debugger über die entsprechende USB Schnittstelle an den PC anschließen und es sollte die Meldung von Windows kommen, dass der richtige Treiber gefunden wurde.

===Libraries===
Zum programmieren benötigt man noch die [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php CMSIS] und die Standard-Peripheral-Library (z.B. für die F4 Controller [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW Standard-Peripheral-Library-F4]), die man am besten in einen Ordner (z.B. '''''Dokumente\STM32''''') entpackt

==Basis-Wissen zur IDE==
Einige Grundfunktionalitäten der IDE:

===Hinzufügen von Dateien zum Projekt===
Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Add files...'''''

===Enfernen von Dateien aus dem Projekt===
Im Projekt-Manager '''''Rechts Klick auf die Datei / mehrere Dateien auswählen -> Remove file from project'''''
Die Dateien werden lediglich aus dem Projekt entfernt und nicht von der Festplatte gelöscht.

===Hinzufügen von Include-Pfaden===
Sofern die Include-Datei(en) nicht im standard Include-Ordner '''''inc''''' des Projektes liegen, muss man den Pfad zum Projekt hinzufügen, damit der Compiler die Include-Dateien später auch finden kann. Man geht wie folgt vor: Im Projekt-Manager '''''Rechts Klick auf <ProjektName> -> Build options... -> Search Directories -> Add'''''

===Compilieren===
Entweder über das '''''Build''''' Menü oder über '''''F7'''''

Um eine genau Ausgabe des Compiler-Aufrufes mit allen Argumenten zu bekommen, geht man im '''''Settings''''' Menü auf '''''Tools...''''' und dann auf '''''Toolchain executables'''''. Ganz unten, unter '''''Logging''''' kann man dann '''''Full command line''''' auswählen.

===Debuggen===
*Als erstes den Debugger starten über das '''''Debug''''' Menü und '''''Start/stop Debug Session''''' oder über '''''F8'''''

*Danach läuft die Anwendung auf dem Controller und warten im '''''Reset_Handler''''' auf Einzelschritt- bzw. Run- Befehle ('''''F5, F10, F11''''' usw..(siehe '''''Debug-Menü''''' für alle Möglichkeiten))

*Mit '''''F8''''' wird die Debug-Session auch wieder beendet

*Unter '''''Debug -> Interfaces -> Target settings''''' können Eigenschaften, wie z.B '''''Run to main()''''' aktiviert werden.

===Projekt als Template abspeichern===
Unter '''''File -> Save project as template...'''''. Das Template erscheint dann im Projekt-Dialog unter '''''User templates'''''

==Das erste Projekt erstellen==
Hier erkläre ich, wie man am Besten (aus meiner Sicht), ein neues Projekt von Grund auf erstellt, sodass man hinterher, den Controller-Kern über die CMSIS-Library und die Peripherie über die Register steuern kann.

===1. Projekt mit der IDE erstellen===
Nach der Installation der oben beschriebenen Komponenten erstellt man am besten ein Verzeichnis (z.B. '''''Dokumente\EmBlocks'''''), indem später alle Projekte gespeichert werden. Für Libraries kann man auch noch ein Verzeichnis (z.B. '''''Dokumente\STM32''''') erstellen, wo alle Libraries gespeichert werden, die man für die Projekt brauchen.

Als nächstes starten man EmBlocks. Bei dem ersten Start öffnet sich ein Fenster, wo verschiedene Compiler angezeigt werden, die Em::Blocks findet. Dort wählt man den '''''ARM GCC Compiler''''' aus und klickt '''''OK'''''. Nun sollte sich das Hauptfenster von Em::Blocks öffnen. Über '''''Create a new Project''''' oder '''''File -> New -> Project''''' ruft man den Projekt-Dialog auf und kann ein neues Projekt erzeugen.

Auf der Ersten Seite wählen man den '''''STmicro-ARM''''' Projekt-Typ aus.

[[Datei:new_project_1.png|Neues Projekt erstellen]]

Auf der nächsten Seite wird man darauf hingewiesen, dass das der entsprechende Projekt-Typ-Dialog ausgeführt wird. Hier kann man ein Häkchen bei '''''Skip this page next time''''' setzen und auf '''''OK''''' klicken.

Im nächsten Schritt wählen man das zuvor erstellt Verzeichnis unter '''''Folder to create Project in''''' aus, indem später alle Projekt gespeichert werden. Außerdem geben wir dem Projekt einen Namen (z.B. '''''FirstProject''''').

[[Datei:new_project_2.png|Neues Projekt erstellen]]

Danach muss man einen Compiler auswählen und bestimmen, welche Projekt-Konfigurationen erszeugt werden sollen. Unter '''''Compiler''''' wählt man '''''ARM GCC Compiler''''' und man kann das Häkchen bei '''''Create "Release" configuration''''' entfernen, da diese unnötig ist, die Debug-Konfiguration sollte eig. immer ausreichen.

[[Datei:new_project_3.png|Neues Projekt erstellen]]

Auf den folgenden Seite wird der Controller ausgewählt. Verwendet man ein STM32F4-Discovery Board müssen folgende Dinge gewählt werden: '''''Cortex_M4 (F3xx - F4xx) -> STM32F4xx (Cortex M4 with FPU) -> STM32F407VG'''''. Leider sind die Auswahl Möglichkeiten nicht ganz richtig, da auch die F3 Controller einen Cortex M4 Kern und eine FPU haben (Ist aber nicht so wichtig, ist nur eine formale Sache). Außerdem entfernt man das Häkchen bei '''''Standard Peripherals Library''''' (Wie man die Standard-Peripheral-Library einbindet und verwendet erkläre ich später). Man kann auch das Häkchen bei '''''Create hex file for Realease target''''' entfernen.
Unter '''''Stack Size''''' und '''''Heap Size''''' wird die Größe von Stack und Heap festgelegt. Für eine erste Anwendung kann man die Einstellungen so lassen (Stack-Size: 0x0100 => 256 Byte Stack und Heap-Size: 0x0000 => kein Heap). Mit '''''Finish''''' ist der Projekt Dialog abgeschlossen.

[[Datei:new_project_4.png|Neues Projekt erstellen]]

Danach sollten sich zwei neue Fenster öffnen, um die Debug-Eigenschaften fest zu legen.
Verwendet man ein Discovery Board/ST-Link müssen die Einstellungen wie auf dem Bild gewählt werden. Über den Button '''''Settings''''' öffnet sich das zweite Fenster, falls sich dieses nicht schon von alleine öffnen sollte. Nach den Schließen der Fenster über '''''OK''''' ist der Projekt Dialog beendet und ein neues Projekt steht zur Verfügung.

[[Datei:new_project_5_1.png|Debug Eigenschaften 1. Fenster]]

[[Datei:new_project_5_2.png|Debug Eigenschaften 2. Fenster]]

===2. CMSIS-Library und Startup-Code hinzufügen===
Wenn man sich, nachdem man ein neues Projekt in der IDE erstellt hat, die bereits vorhandenen Dateien im Projekt ansieht, stellt man fest, das bereits ein Ordner '''''cmsis''''' existiert, der einige wichtige Include-Dateien der CMSIS-Library enthält. Allerdings sind das wirklich nur die wichtigsten Include-Dateien der CMSIS-Library und dazu noch, die aus einer älternen Version. Ich ziehe es deshalb vor die "Mini-CMSIS-Libraray" und die '''''system_stm32f4xx.c/.h''''' Dateien des Projektes durch aktuellere Versionen zu ersetzen. So ist später auch die Integration von anderen Libraries, wie z.B. der CMSIS-DSP-Libarary einfacher.

Zunächst gehen man in das Projekt-Verzeichnis und löscht:
*Den Ordner '''''cmsis'''''
*Alle Dateien im Include Verzeichnis '''''inc'''''
*Die Datei '''''system_stm32f4xx.c''''' im '''''src''''' Ordner

Außerdem entfernt man auch alle gelöschten Dateien in der IDE aus dem Projekt mit '''''FirstProject -> Rechts Klick -> Remove file from project'''''

Es sollte folgende Verzeichnis Struktur überbleiben:

[[Datei:new_project_6.png|Überbleibende Dateien]]

Jetzt müssen die gelöschten Dateien durch die aktuelleren ersetzt werden.

*Dazu kopieren man den gesamten Ordner '''''CMSIS''''' aus dem CMSIS Download in das Projekt Verzeichnis.

*Aus dem Standard-Peripheral-Library Download kopiert man von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Include''''' alle Dateien in den '''''inc''''' Ordner des Projekt Verzeichnisses

*Aus der Standard-Peripheral-Library kopieren man ebenfalls von '''''Libraries\CMSIS\Device\ST\STM32F4xx\Source\Templates''''' die Datei '''''system_stm32f4xx.c''''' in den '''''src''''' Ordner des Projekts

Anschließend müssen die neuen Dateien in der IDE dem Projekt hinzugefügt werden. Dazu benutzt man '''''FirstProject -> Rechts Klick -> Add files'''''.
*Aus dem '''''CMSIS''''' Ordner im Projekt Verzeichnis werden aus den Unterorder '''''Include''''' folgende Dateien dem Projekt hinzugefügt:
**arm_common_tables.h
**arm_const_structs.h
**arm_math.h
**core_cm4.h
**core_cm4_simd.h
**core_cmFunc.h
**core_cmInstr.h
*Alle Dateien aus den '''''inc''''' Ordner des Projektes
*Die Datei '''''system_stm32f4xx.c''''' aus dem '''''src''''' Ordner

So sollte die Struktur dann aussehen:

[[Datei:new_project_7.png|Anwenungs-Grundgerüst]]

Da einige Dateien der Libraries später bearbeitet werden müssen und Schreibgeschützt sind, weise ich hier schonmal darauf hin, das der Schreibschutz in der IDE über '''''Rechts Klick auf die Datei -> Properties -> Häkchen bei "File is read only" entfernen''''' entfert werden kann.

Damit die IDE die Header-Dateien der CMSIS Library auch finden kann, weil diese ja nicht im standard Include Ordner '''''inc''''' liegen, muss unter '''''FirstProject -> Build Options -> Search Directories''''' der Pfad '''''CMSIS\Include''''' hinzugefügt werden.

Compiliert man jetzt das Projekt mit '''''F7''''' gibt es ein paar Fehler Meldungen, weil keine Controller-Reihe ausgewählt wurde. Ebenfalls unter '''''FirstProject -> Build Options -> Compiler Settings -> #defines''''' wird der Define '''''STM32F40_41xxx''''' hinzugefügt.

Beim erneuten Compilieren sollten sich nun keine neuen Fehler ergeben.

===Das erste Programm===
Nachdem ein grundsätzliches "Gerüst" fertig ist, kann man den ersten Code schreiben.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; //Takt für GPIO aktivieren
GPIOD->MODER |= GPIO_MODER_MODER15_0; //GPIOD Pin15 als Ausgang
GPIOD->BSRRL |= GPIO_BSRR_BS_15; //GPIOD Pin15 auf High ziehen

while(1)
{
}
}
</syntaxhighlight>

Download: [[Datei:FirstProject.zip]]

Mit '''''F8''''' wird dann der Debugger gestartet. Hat der Debugger das Projekt erfolgreich übertragen kann die Ausführung mit '''''F5''''' begonnen werden.

==Takt, FPU usw.==
===Der Takt===
Jeder Controller oder Prozessor braucht einen Takt, indem er die einzelnen Maschinen-Befehle abarbeiten kann.
Bei den STM32 Mikrocontrollern kann dieser Takt aus verschiedenen Quellen kommen:

1. High Speed Internal Oszillator (HSI)

2. High Speed External Oszillator (HSE)

3. Low Speed Internal Oszillator (LSI)

4. Low Speed External Oszillator (LSE)

5. Phase-Locked Loop (PLL) (generiert den Takt aus den ersten vier Taktquellen durch Teiler und Faktoren)

Nach einem Reset wird der Controller aus der HSI Taktquelle versorgt (16MHz beim STM32F407VG). Um die voll Performance des Controllers zu erreichen muss die PLL verwendet werden, welche den Takt durch geschickte Teiler und Faktoren vervielfältigt, sodass am Ende der Controller mit der maximalen Taktfrequenz läuft. Die notwendige Initialisierung der PLL findet in der Funktion '''''SystemInit()''''' statt. Die PLL erzeugt zunächst einen Basistakt:

PLL_VCO = (F_HSE / PLL_M) * PLL_N

Aus diesem Takt wird dann der Takt für den Controller-Kern abgeleitet:

SYSCLK = PLL_VCO / PLL_P

Und der Takt für SDIO / USB / RNG (48MHz):

48MHz = PLL_VCO / PLL_Q

Durch weiter Teiler werden, die Takte für die einzelnen Busse erzeugt, da diese nicht alle beliebig schnell betrieben werden dürfen.

Genaue Angaben findet man zu dem jeweiligen Clock-System des Controllers im Reference Manual.

Ein Blick in den "Kommentar-Header" verrät, dass von einem externen (HSE) Oszillator von 25MHz ausgegangen wird, der die PLL versorgen soll.

SYSCLK = ((25MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 168MHz

Allerdings stimmt diese Rechnung natürlich nur, wenn wirklich ein 25MHz Quarz am Controller angeschlossen ist. Auf dem STM32F4-Discovery Board befindet sich aber nur ein 8MHz Quarz. Demnach gilt:

SYSCLK = ((8MHz / PLL_M(25)) * PLL_N(336)) / PLL_P(2) = 53.76MHz

Der Controller läuft also nur mit 53.76MHz, wenn wie ober beschrieben ein Projekt erstellt wird. Allerdings kann dieses Problem durch ändern von den betroffen Defines behoben werden:

*Dazu geht man in die '''''system_stm32f4xx.c''''' Datei und passt zur Vollständigkeit erstmal die zum Controller passende Tabelle im "Kommentar-Header" an (Z.57f):
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* HSE Frequency(Hz) | 8000000
*-----------------------------------------------------------------------------
* PLL_M | 8
*-----------------------------------------------------------------------------
</syntaxhighlight>

*Danach passt man den PPL_M Define (Z.254) an:
<syntaxhighlight lang="c">
/************************* PLL Parameters *************************************/
/* PLL_VCO = (HSE_VALUE or HSI_VALUE / PLL_M) * PLL_N */
#define PLL_M 8
</syntaxhighlight>

*Außerdem muss man den HSE_VALUE Define in der '''''inc/stm32f4xx.h''''' angepasst werden (Z.122):
<syntaxhighlight lang="c">
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */

#endif /* HSE_VALUE */
</syntaxhighlight>

Eine neue Berechnung zeigt:

SYSCLK = ((8MHz / PLL_M(8)) * PLL_N(336)) / PLL_P(2) = 168MHz

Jetzt läuft der Controller mit maximaler Geschwindigkeit.

Achtung!:
In dem "Kommentar-Header" der '''''system_stm32f4xx.c''''' steht in der letzten Zeile immer:
<syntaxhighlight lang="c">
*-----------------------------------------------------------------------------
* Require 48MHz for USB OTG FS, | Disabled
* SDIO and RNG clock |
*-----------------------------------------------------------------------------
</syntaxhighlight>

Das ist jedoch falsch, weil der Takt für USB, SDIO und RNG immer mit der PLL über den Teiler PPL_Q eingestellt wird. Der Takt ist somit immer vorhanden und muss nicht extra Eingeschaltet werden. (Erspart langes Suchen, nach den entsprechenden Registern)

===Die FPU===
====Allgemeines====
Damit die FPU richtig verwendet wird, müssen normalerweise zwei Bedingungen erfüllt sein:

1. Der Controller muss in der Initialisierung-Funktion '''''SystemInit()''''' in '''''system_stm32f4xx.c''''' die FPU Hardware-seitig aktivieren

2. Damit die FPU auch was zu tuen bekommt, müssen vom Compiler FPU-Instructions erzeugt werden.

Die Em::Blocks IDE verwendet standardmäßig die FPU, wenn eine Vorhanden ist. Hier wird die FPU Hardware-seitig aktiviert ('''''system_stm32f4xx.c''''' Z.341):
<syntaxhighlight lang="c">
/* FPU settings ------------------------------------------------------------*/
#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
#endif
</syntaxhighlight>

__FPU_PRESENT wird in der '''''stm32f4xx.h''''' definiert.
__FPU_USED wird von der IDE übernommen (siehe Build-Log): '''''-D__FPU_USED'''''

Außerdem wird der Compiler von der IDE standardmäßig mit dem Argument '''''-mfloat-abi=hard''''' aufgerufen, wodurch FPU-Instructions erzeugt werden.

====FPU abschalten====
Um die FPU ab zu schalten (Mir würde jetzt nur Strom sparen als Grund einfallen) geht man wie folgt vor:

Unter '''''<ProjektName> -> Rechts Klick Build options -> Device -> Policy''''' wählt man '''''Use target settings''''' und über nimmt die Einstellungen, die vorher dort eingetragen waren, allerdings lässt man das Feld '''''FP-hardware''''' frei.

[[Datei:fpu_1.png|FPU Abschalten Schritt 1]]

Unter '''''Compiler Settings -> Policy''''' wählt man dann '''''Use target options only'''''. Dann kann man unter '''''Categories''''' die Option '''''ARM FPU architecture''''' auswählen. Dort stehen dann drei Möglichkeiten für die FPU zur Verfügung:

1. Software-FPU-Library für Gleitkomma-Berechnung verwenden - Keine FPU-Instructions werden generiert (Compiler-Argument: '''''-mfloat-abi=soft''''')

2. Eine Mischung aus Software- und Hardware-FPU wird verwendet (Compiler-Argument: '''''-mfloat-abi=softfp''''')

3. Hardware-FPU wird für Gleitkomma-Berechnungen verwendet (Compiler-Argument: '''''-mfloat-abi=hard''''')

[[Datei:fpu_2.png|FPU Abschalten Schritt 2]]

Um die FPU ab zu schalten wählt man natürlich die erste Möglichkeit.
Bei der 2. und 3. Möglichkeit fügt die IDE auch den Define '''''__FPU_USED''''' hinzu. Bei Der ersten Möglichkeit nicht. Der Code muss also nicht verändert / auskommentiert werden.

Um die FPU wieder zu aktivieren müssen alle Schritte wieder rückgängig gemacht werden.

Am besten ist es einfach mal alle Möglichkeiten im Einzelschritt durch zu probieren. Dann stellt man schnell fest, ob die FPU aktiviert wir oder nicht. Ein Blick in den erweiterten '''''Build-Log''''' gibt auch schnell Aufschluss darüber, wie der Compiler aufgerufen wird (siehe Kapitel [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks#Compilieren Compilieren]).

====Test Programm für die FPU====
Hier ein kleines Testprogramm, dass misst wie viele Taktzyklen für eine Gleitkomma-Multiplikation gebraucht werden. main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

#define CORE_SysTickEn() (*((u32*)0xE0001000)) = 0x40000001
#define CORE_SysTickDis() (*((u32*)0xE0001000)) = 0x40000000
#define CORE_GetSysTick() (*((u32*)0xE0001004))

uint32_t t1, t2, dt;
float x, y, z;

int main(void)
{
x = 53.64f;
y = 0.27f;

CORE_SysTickEn();
t1 = CORE_GetSysTick();

z = x * y;

t2 = CORE_GetSysTick();
CORE_SysTickDis();

dt = t2 - t1;

while(1)
{
}
}
</syntaxhighlight>

Mein Ergebnis:
*Mit Hardware-FPU: dt = 25
*Ohne Hardware-FPU: dt = 83

Download: [[Datei:FPU_Test.zip]]

==Einbinden der Standard Peripheral Library==
Um nicht immer die einzelnen Register, wie im ersten "bare-metal" Beispiel, aus dem Reference-Manual zu suchen und zu beschreiben, gibt es von ST die Standard Peripheral Library, die diese Aufgaben übernimmt und mit der sich die "normale/grundlegende" (Alles außer USB und Ethernet) Peripherie recht einfach steuern lässt. Um die Library zu verwenden erzeugt man wie oben beschrieben ein neues Grundgerüst und kopiert als erstes den Ordner '''''Libraries\STM32F4xx_StdPeriph_Driver''''' aus dem Standard-Peripheral-Library Download in das Projekt-Verzeichnis. Außerdem muss man die Datei '''''Project\STM32F4xx_StdPeriph_Templates\stm32f4xx_conf.h''''' ebenfalls aus dem Standard-Peripheral-Library Download in den '''''inc''''' Ordner des Projektes kopieren. In der IDE fügt man den Include-Path '''''STM32F4xx_StdPeriph_Driver\inc''''' hinzufügen, wie bei der CMSIS-Library (s.o.).
Außerdem muss noch '''''USE_STDPERIPH_DRIVER''''' als Define in der IDE hinzugefügt werden (s.o.).
Danach fügt man die Source- und Include-Dateien aus dem Ordner '''''STM32F4xx_StdPeriph_Driver\inc''''' und '''''STM32F4xx_StdPeriph_Driver\src''''' dem Project mit '''''<Project Name> -> Rechts Klick -> Add files''''' hinzu, allerdings nur die, für welche auch der Controller die entsprechende Peripherie besitzt. Beim STM32F4-Discovery Board / STM32F407VG Controller dürfen also nicht folgende Dateien nicht mit hinzugefügt werden, weil diese Peripherie nur bei anderen Controller vorhanden ist:

*stm32f4xx_dma2d.c/.h
*stm32f4xx_fmc.c/.h
*stm32f4xx_ltdc.c/.h
*stm32f4xx_sai.c/.h

Daraus resultiert folgende Struktur:

[[Datei:stdperiphlib_2.png|Header-Struktur]] [[Datei:stdperiphlib_1.png|Source-Struktur]]

Anschließen kann die Standard-Peripheral-Library benutz werden.
main.c:
<syntaxhighlight lang="c">
#include "stm32f4xx.h"

int main(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

GPIO_InitTypeDef GPIOD_InitStructure;
GPIOD_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIOD_InitStructure.GPIO_Pin = GPIO_Pin_15;
GPIO_Init(GPIOD, &GPIOD_InitStructure);

GPIO_SetBits(GPIOD, GPIO_Pin_15);

while(1)
{
}
}
</syntaxhighlight>

Download: [[Datei:StdPeriphLib_Project.zip]]

==Booten aus dem SRAM==
STM32 Controller haben die Möglichkeit Code aus dem Flash als auch aus dem SRAM auszuführen. Um eine Anwenung per Debugger in des SRAM zu laden sind nur wenige Schritte erforderlich:

*Um das Linkerscript für den SRAM zu verwenden geht man zu: '''''Build options... -> Device''''' dort wählt man unter '''''Policy''''' '''''Use target settings''''' aus und übernimmt die vorherigen Einstellungen, nur unter '''''Linker script*''''' gibt man '''''.\stm32f407vg_sram.ld''''' an

*Dann muss man noch unter '''''Debug -> Interfaces -> Settings''''' '''''Vector table start''''' auf 0x20000000 ändern und '''''Execute from RAM''''' auswählen.

Anschließend kann man die Anwendung ganz normal debuggen. Nach einem Reset muss die Anwenung erneut mit dem Debugger gestartet werden.

=Fortsetzung folgt..=
Kritik, Wünsche usw. sind gerne erwünscht, am besten hier in den Thread posten: [http://www.mikrocontroller.net/topic/323750 Neues STM32 Tutorial]

[[Category:ARM]]
[[Category:STM32]]