STM32 Tutorial #2: GPIO blinkende LED

In diesem neuen Tutorial widmen wir uns der Verwendung von der GPIO (Allgemeiner Ein- und Ausgang) Peripherie innerhalb der System-Workbench Software. Nach all diesen Schritten werden wir eine LED blinken sehen. Zuerst zeige ich euch das Standardverfahren zur Erstellung eines neuen Projekts mit Hilfe der autonomen Code-Generierungssoftware STM32CubeMX. Danach werden wir unseren Benutzercode hinzufügen und auf den Chip programmieren.

Ich arbeite mit einem Nucleo-303K8 Entwicklungsboard. Aus diesem Grund kann es vorkommen, dass einige Schritte ein wenig anders sind als mit einem anderen Entwicklungsboard. Es kann Unterschiede in der Code-Erstellung sowie im Pinning des Chips im STM32CubeMX-Tool geben. Nichtsdestotrotz werdet ihr neue Kenntnisse im Umgang mit der Software lernen, wenn ihr diesem Tutorial folgt. Wenn ihr auf Probleme stoßt postet das bitte in den Kommentaren und ich werde versuchen, euch so schnell wie möglich zu helfen. Lange Rede kurzer Sinn, lasst uns mit dem programmieren beginnen.

Verwendung von STM32CubeMX

Zuerst müssen wir das Programm STM32CubeMX öffnen.

Jetzt wählen wir File – New Project.

Auswahl des Mikrocontrollers oder des Entwicklungs-Boards

Nach diesem Schritt müssen wir nun unser Board oder unseren Mikrocontroller auswählen. Wenn ihr ein Nucleo-Board oder ein anderes Entwicklungsboards verwendet, klickt auf die Registerkarte „Board Selector“, wie unten dargestellt. Wenn ihr kein Entwicklungs-Board sondern nur den Mikrocontroller auf einer selbstgebauten Platine verwendet könnt ihr direkt den „MCU-Selektor“ verwenden. Nach der Auswahl klickt auf Start Project. Auf Nachfrage geben wir an, dass das Tool die Peripherie nicht mit den Standard-Werten initialisieren soll.

Konfiguration der Port Pins

Nach der Auswahl des Boards oder auch des Mikrocontrollers werdet ihr ein Bild des Controllers mit dem zugehörigen Pinning vor euch sehen. Hier könnt ihr den Pins Funktionen zuweisen. Wie ihr sehen könnt gibt es auch einige Standardeinstellungen, die für die SWD (Single Wire Debuggen) Schnittstelle, den VCP (virtueller COM-Port) und die LED verwendet werden. Darüber hinaus werden die Power-Supply-Pins eingezeichnet.

Detaillierte Konfiguration des GPIO Peripherie Moduls

Als Nächstes klicken wir auf System Core – GPIO und dann auf die Zeile die PB3 beinhaltet. Hier können wir den GPIO-Pin im Detail konfigurieren.

In diesem Fenster können wir mehrere Einstellungen des Moduls GPIO selbst und allen Ports, die wir zuvor definiert haben, verändern. Hier seht ihr eine Liste über die Bedeutung der einzelnen Parameter:

• GPIO output level: Dies ist der logische Pegel auf den der Pin nach der Initialisierung des Moduls GPIO liegt. In unserem Fall beginnen wir mit einem low oder auch logisch „0“ genannt.
• GPIO Mode: Hier können könnt ihr auswählen, ob der Ausgang als Push-Pull oder Open Drain Konfiguration betrieben wird. Bei Push-Pull kann man den Ausgang sowohl auf logisch ‚1‘ als auch auf logisch ‚0‘ legen. Bei Open-Drain kann man den Ausgang nur auf logisch ‚0‘ ziehen. Andernfalls ist dieser offen und liegt auf keinem bestimmten Level. Im letzteren Fall solltet ihr einen Pull-up-Widerstand hinzufügen, so dass ihr sowohl auf Low als auch auf High ziehen könnt.
• GPIO Pull-up/Pull-down: Hier könnt ihr Pull-Up und Pull-Down Widerstände definieren. In diesem Fall brauchen wir keinen der beiden.
• Maximum output speed: Hier könnt ihr den Port auf verschiedene Geschwindigkeiten einstellen. In unserem Fall wird die LED nur alle 500 ms geschalten, was sehr langsam ist. Wir benötigen somit nur einen langsamen Ausgang.
• User Label: Ich habe das User Label mit „LED“ definiert. Später im eigentlichen Programm kann der Port dann mit dem definierten Label angesprochen werden. Ich würde euch empfehlen das Label gleich zu benennen, damit unser Code kompatibel bleibt.

Clock-Konfiguration

Nach diesem Schritt wechseln wir zur Clock-Konfiguration. Dort ist zu sehen, dass die system clock sowie die Peripherie Module mit 8 MHz getaktet sind. Das ist ok für uns, da wir keine Spezifikationen erfüllen müssen, die uns einschränkt. Als nächstes klicken wir, wie unten dargestellt, auf „Project Manager“.

Generierung vom Programm-Code

Nach diesem Schritt sind wir mit der Konfiguration fertig. Nun müssen wir ein paar Projekt-Einstellungen treffen bevor wir die Code-Generierung starten.

In diesem Fenster können wir den Namen des Projekts und den Speicherort angeben. Als Toolchain muss SW4STM32 definiert sein in unserem Fall, da wir andernfalls auf Probleme stoßen. Ich habe auch „Generate under Root“ aktiviert. Nun können wir den Button „Generate Code“ drücken.

Installiert nun das fehlende Repository für den Microcontroller, falls es noch nicht erledigt ist. Bitte folgt dazu einfach den Anweisungen.

Importieren des Projekts

Nach erfolgter Code-Generierung können wir das Projekt direkt öffnen. Falls du das Projekt selbst importieren willst findest du hier die entsprechende Anleitung.

Öffne die Software „System Workbench“, auch SW4STM32 genannt, und wähle deinen Workspace aus. Um das Projekt hinzuzufügen, klickt auf „Datei – Import“.

Hier müsst ihr „Existing Projects into Workspace“ auswählen.

Im folgenden Fenster müsst ihr auf „Durchsuchen“ klicken, um das Projektverzeichnis festuzulegen.

Klickt einfach auf den Projektordner und wählt „Öffnen“.

Es findet automatisch die notwendigen Projekt-Dateien. Wählt nun einfach das Projekt aus und klickt auf „Fertigstellen“.

Das waren die erforderlichen Schritte um euer Projekt in System-Workbench einzurichten und wir sind jetzt bereit, die Dateien dort zu verwenden. Im nächsten Abschnitt werde ich die Projektstruktur erklären. Außerdem lassen wir endlich die LED blinken.

Projektstruktur

Auf der linken Seite seht ihr die erweiterten Ordner der Projektstruktur. Zunächst beginnen wir mit den Inc und Src Ordnern.

Dort ist der gesamte Code der von uns benutzt und verändert wird. Die main.c Datei ist selbsterklärend. Es ist der Ausgangspunkt unseres Programms. Die Datei „stm32f3xx_hal_msp.c“ enthält die Initialisierung des „MCU specific package“ MSP. Diese Funktionen sind für die verschiedenen Mikrocontroller geschrieben. Wir müssen in dieser Datei nichts umschreiben. Die „stm32f3xx_it.c“ Datei enthält den gesamten Interrupt-bezogenen Code. Wir werden diese in späteren Tutorials verwenden. Sie ist nicht relevant für dieses einfache GPIO-Tutorial. Die „system_stm32f3xx.c“ Datei beinhaltet startup code welcher den Mikrocontroller initialisiert.

Der startup-Ordner enthält den Startcode, der notwendig ist damit der Mikrocontroller unser Programm überhaupt findet.

Der Ordner „Drivers“ befindet sich auf der gleichen Ebene wie die Src und Inc Ordner und stellt den erforderlichen Code für das Handling der Peripherie über HAL (Hardware Abstraction Layer) und CMSIS (Cortex Microcontroller Software-Schnittstelle) bereit.

Der HAL Driver Ordner enthält Code für die einzelnen Peripheriemodule. Wenn ihr einen genaueren Blick darauf werfen möchtet öffnet die Dateien und schaut sie euch an. Ich würde euch auch empfehlen, die passenden Header-Dateien zu öffnen, weil diese sehr oft Beschreibungen enthalten, wie die verschiedenen Module zu verwenden sind. Die Header-Dateien findet ihr in den Include-Ordnern ganz oben in der Projektstruktur oder auch in den .c-Dateien selbst. Sie sind dort definiert. Mit einem Strg-Klick (Cmd-Klick auf dem Mac) auf die Include-Anweisung könnt ihr die Datei öffnen.

Hinzufügen von Benutzercode

OK, jetzt sind die Einstellungen sind alle fertig und wir können mit dem eigentlichen Code beginnen. Leider müssen wir für unser Projekt nur zwei Code-Zeilen ergänzen. Bitte fügt folgenden Code im Abschnitt wie in der Abbildung unten gezeigt wird ein.

HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
HAL_Delay(500);

Die erste Codezeile aktiviert bzw. deaktiviert den angegebenen Pin abwechselnd. Es ist möglich, die Bezeichnungen LED_GPIO_Port und LED_Pin zu verwenden, da wir das Benutzer-Label in STM32CubeMX definiert haben. Wenn wir das nicht getan hätten, müssten wir Folgendes schreiben:

HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_3;

Die zweite Codezeile fügt nur eine Verzögerung von 500 ms ein, bevor der LED Pin wieder umschaltet.

Kompilieren des Codes

Nach dem Hinzufügen des erforderlichen Codes müssen wir ihn kompilieren. Dies geschieht über den „Build All“ Button, wie in der Abbildung unten gezeigt.

Es erscheint ein neues Fenster mit dem aktuellen Status des Build-Prozesses.

Der nächste Schritt ist die Binärdatei in den Mikrocontroller zu programmieren. Bitte stellt sicher, dass euer Entwicklungsboard mit dem PC verbunden ist, bevor ihr auf diese Schaltfläche klickt. Es wird sonst scheitern.

Im nächsten Fenster müsst ihr die Binärdatei auswählen.

Nach der Programmierung solltet ihr das gleiche Ergebnis wie im Video unten sehen. Jede halbe Sekunde wechselt die LED den Zustand.

Zusammenfassung

In diesem Beispiel wurde gezeigt, wie man eine LED kontinuierlich umschaltet, unter der Verwendung des automatischen Code-Generation-Tools von ST Microelectronics. Wie ihr gesehen habt, ist das sehr einfach und unkompliziert. Das STM32CubeMX-Tool erledigt die Initialisierung. Das ist ein großer Vorteil im Hinblick auf die Umsetzungszeit und -mühe. Wie immer könnt ihr eure Fragen gerne in den Kommentaren stellen, ich werde diese schnellstmöglich beantworten Auch wenn euch Verbesserungen einfallen könnt ihr diese gerne posten.

Im nächsten Blog-Eintrag werden weitere Funktionen des GPIO HAL Treibers erklärt werden. Ich freue mich euch dort wieder zu sehen.