STM32 CooCox Installation

Dieser Artikel beschreibt, wie man CooCox unter Windows installiert und für den Prozessor STM32 einrichtet, so dass ein Debuggen möglich ist.

Installation von CooCox unter Windows

Zu nächst müssen ein paar Programme, Tool und Bibliotheken aus dem Internet geladen und installiert werden. Zudem ist es vom Vorteil wenn man ein STM32F4DISCOVERY Board bereits besitzt, denn das gezeigte Demo-Blink LED Programm nutzt dieses Board. Es kann natürlich auch jedes andere Board genutzt werden, das einen STM32F2xx oder STM32F4xx Prozessor beinhaltet.

Die ersten Downloads - die IDE sowie der GCC Compiler:

• 1. die CooCox CoIDE laden (In diesem Beispiel V1.7.5)
• 2. GCC Toolchain (In diesem Beispiel "gcc-arm-none-eabi-4_8-2013q4-20131204-win32.zip", das ZIP Archiv, nicht die EXE)

Die Installation der CoIDE nach z.B. C:\CooCox ausführen.

Den Ordner C:\CooCox\CoIDE\gcc-arm-none-eabi-4.8 anlegen und die Dateien aus dem zweiten Download dort hinein entpacken. (Das ZIP reicht, da GCC weder Einträge in Systemverzeichnisse noch Registry benötigt.)

Nun muss der GCC Compiler in die CoIDE eingebunden werden. Das ist gut in der Doku von CooCox beschrieben: "Select Toolchain Path"

Start des ersten Projektes

Hierzu hilft die Quikstart-Guide von CooCox ebenfalls weiter.

• Auswahl "ST"
• Auswahl STM32F407VG (der Prozessor vom STM32F4DISCOVERY Board)
• Auswahl der Peripheriefunktionen, für das BlinkLED wird nur GPIO benötigt
• Frage: "Do you want create a new project now?" mit Yes beantworten
• Projektname: "BlinkLED" eingeben
• Nun die CoIDE bereits ein Projekt angelegt und noch weitere Häkchen automatisch gesetzt

Einstellung der Konfiguration

In der Konfigurations-Ansicht werden erst mal keine Änderungen vorgenommen. Da per Default als Debugger schon der Adapter ST-Link eingetragen ist.

Die Programmierung

Im linken Baum sind nun einige Dateien enthalten. Die wichtigste ist wohl die "stm32f4xx.h", denn darin sind alle Deklarationen der Prozessor Peripherieregister. Diese Datei ist mehrere 1000 Zeilen groß. Die Bezeichnungen stimmen mit der Dokumentation von ST überein. CoIDE kann diese Datei jedoch nicht komplett darstellen, da nach der Installation nur 5000 Codezeilen berücksichtigt werden und diesen Parameter muss man ändern: Menü "Edit" > "Preferences":

Das eigene Programm beginnt in der Datei "main.c". Diese wird mit Doppelklick geöffnet und es erscheint eine leere main() Routine, mit einer Endlos-While-Schleife. Nach dem Start vom Prozessor wird CooCox diesen schon automatisch initialisieren (Variablen) und anschließend wird in main() gesprungen, ab da ist man selbst für alles weitere was geschieht verantwortlich.

Das Programm:

Wir wollen auf dem Discovery Board nun LED's blinken lassen, in der der Doku vom Discovery Board sieht man wo die 4 LED's angeschlossen sind: an PortD 12..15

Zu erst muss die Datei "stm32F4xx.h" in main.c mit eingebunden werden, damit man Zugriff auf die Peripheriefunktionen hat.

Anschließend wird der Takt für Port D aktiviert und erst danach (ganz wichtig!) wird der Port initialisiert. Solange die Peripherieeinheit keinen Takt hat verhält sie sich so, als wenn sie nicht existent wäre.

In der while(1) Scheife werden die LED's gelöscht und nacheinander wieder gesetzt. Da der Prozessor mit gefühlter Lichtgeschwindigkeit das machen würde muss die Ausgabe mit einem Delay() verzögert werden.

Der Code:

// Demo Blink-LED für STM32F4xx mit einem STM32F4DISCOVERY Board
// (c) 2013, Markus Müller
// Dieser Code darf frei verwendet, modifiziert und kopiert werden. Benutzung auf eigene Gefahr.
#include "stm32f4xx.h" // Deklaration der Peripheriefunktionen

void Delay(long i);

// Haupt-Programmschleife
int main(void)
{

    RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN; // Clock für Port D aktivieren

    GPIOD->MODER = 0x55000000; // Pin 12..15 als Ausgang deklarieren

    while(1) // Endlos SChleife
    {
        GPIOD->BSRRH = 0xF000; // Alle LED's aus
        Delay(1000000);
        GPIOD->BSRRL = 0x1000; // LED 1 ein
        Delay(1000000);
        GPIOD->BSRRL = 0x2000; // LED 2 ein
        Delay(1000000);
        GPIOD->BSRRL = 0x4000; // LED 3 ein
        Delay(1000000);
        GPIOD->BSRRL = 0x8000; // LED 4 ein
        Delay(1000000);
    }
}

// Delay für Verzögerungen
void Delay(long i)
{
    volatile long iZ = i;
    while (iZ--);
}

Nun kann das Programm mit der Taste "Build" (F7) übersetzt werden. Es öffnet sich unten ein Console-Fenster und wenn alles richtigt abgetippt wurde erscheint "BUILD SUCCESSFIL". Ab nun ist das geschriebene Programm übersetzt in ein Binärformat das in den Prozessor geladen werden kann.

Einspielen in das Board

Den ST-LINK zum ersten mal benutzen

Zu erst einmal muss das Board STM32F4DISCOVERY mit dem PC verbunden werden. Dazu nimmt man ein USB Kabel Mini-USB Stecker steckt das im Stecker "CN1" der Platine ein. Der Stecker ist der Anschluss vom ST-LINK, also dem Debugger vom STM32F407 Chip. Vor dem ersten einstecken muss zu nächst ein USB Treiber installiert werden. Da der ST-LINK von ST kommt muss auch von deren Homepage der Treiber erst geladen werden:

• 3. ST-LINK/V2 Utility > STSW-LINK004 (Version 3.2.1)

Dieses Setup wird am besten nach "C:\CooCox\STM32 ST-LINK Utility" installiert, dann ist alles was CooCox benötigt in einem Ordner.

Nun kann das DISCOVERY Board eingesteckt werden, es wird automatisch der Gerätetreiber für den ST-LINK installiert. Wenn man doch schon vorher das Board einmal eingesteckt hatte, so installiert das doofe Windows einen NULL-Treiber den man im Gerätemanager (beim eingestecktem Discovery-Board) wieder löschen muss.

Nun sollte man auf dem Discovery Board den ST-LINK erst einmal updaten, da er vermutlich eine alte Firmware hat: "C:\CooCox\STM32 ST-LINK Utility\ST-LINK Utility\ST-LinkUpgrade.exe" erledigt das. "Device Connect" findet den ST-LINK und "YES >>>>" macht einen Upgrade.

Jetzt geht's los

Das STM32F4DISCOVERY Board ist eingesteckt, und somit hat auch die Ziel-CPU eine Stromversorgung.

In CoIDE wird nun die Debug-Sitzung mit Ctrl+F5 gestartet. Damit wird CoIDE automatisch das Projekt übersetzen und mittels J-LINK in die CPU laden und startet die CPU. Ein Breakpoint ist beim main() gesetzt die CPU (CoIDE) wartet auf weitere Befehle vom Anwender.

Die Taste "Run" (F5) startet anschließend das Programm.

Nun müssten die LED's nacheinander aufleuchten und wieder alle aus gehen.

Mit "Pause" (F9) kann man ein programm jederzeit anhalten. Dabei zeigt CoIDE automatisch die Programmposition. Mit dem Fahren der Maus über Variablen wird deren Inhalt gezeigt. "Run" (F5) führt die Bearbeitung fort.

Jederzeit kann man mittels Doppelklick am linken Editor-Rand einen Breakpoint setzen. Sobald die CPU an der Programmposition vorbei kommt bleibt diese stehen und dies wird in CoIDE gezeigt. Mit F10/F11 kann man in Einzelschritten weiter steppen.

Weblinks, Foren, Communities

• Artikel STM32
• Artikel STM32 Eclipse Installation