STM32 für Einsteiger

Immer wiederkehrend hier im Forum "Mit welchem Mikrocontroller anfangen?". Es gibt eine große Auswahl und eben so viele Empfehlungen. In diesem Artikel soll zu erst geholfen werden ob ein Cortex-M3/M4 Kern überhaupt der Richtige für den Start ist. Nicht für jeden ist der Cortex zu empfehlen, denn die Anforderungen und Wünsche die man realisieren möchte, sowie die eigenen Fähigkeiten sind verschieden.

Es werden meist die Prozessoren AVR, PIC, Arduino, MSP430, LPC1xxx und STM32 empfohlen. Seltener auch 8051 und M16C. Alle haben Vorzüge und ebenso auch Nachteile.

STM32F417 auf einem Selbstbau-Board

Eigene Fähigkeiten und Wünsche

Dieser Artikel geht davon aus, dass bereits Elektronikkenntnisse vorhanden sind. Wenn nicht dann sollte man erst einmal den Artikel "Absolute Beginner" durcharbeiten, sowie die anderen Artikel aus der Kategorie "Grundlagen".
Weitere Artikel die andere Prozessoren näher darstellen da sich dieser Artikel hauptsächlich auf STM32 konzentriert: Entscheidung Mikrocontroller und Mikrocontroller Vergleich. Die Seiten AVR, MSP430, LPC1xxx und PIC zeigen mehr Details über diese µC. Hier werden nur grob ein paar Tabelle zum Vergleichen gezeigt.

Zu erst einmal die Randbedingungen, mit der man sich selbst zu erst einmal einschätzen sollte:

Fähigkeit	Cortex	AVR	Arduino	PIC			MSP430
Bitbreite, jedoch unwichtig für Einsteiger	32-bit	8-bit		8-bit (PIC18)	16-bit (PIC24)	32-bit (PIC32)	16-bit
Neueinsteiger, kaum Elektronikkenntnisse, noch nie programmiert	O	O	X	O			O
Wunsch ist SD-Card oder Grafik-Display	X	O		O	X	X	X
Wunsch ist TCP/IP Netzwerk	X	O		X			O
Wunsch ist Kamera und Video-/Bildbearbeitung	X	-		-	-	X	-
Möchte die Erkenntnisse beruflich nutzen	X	X	-	X			X
Stromsparende Anwendungen	- 300 nA Sleep 230 μA/MHz	- 100 nA Sleep 340 μA/MHz	-	X 9 nA Sleep 35 μA/MHz		-	X 100 nA Sleep 100 μA/MHz
Multithreading, RTOS, Schedulern	X	-	-	-	X	X	X
Besonders große, speicherintensive Programme z.B. Grafiken, Fonts	bis 2MB Flash bis 1024kB SRAM	bis 256kB Flash bis 16kB SRAM		bis 128kB Flash bis 4kB SRAM	bis 2MB Flash bis 98kB SRAM	bis 2MB Flash bis 512kB SRAM + 32MB DRAM (PIC32MZ DA)	bis 512KB Flash bis 66kB SRAM
Sehr viel PWM mit komplexem Timing	X	AT90Spwm	-	-	X	X	O
Deutschsprachige Community	O	X	X	X	-	-	-
Anzahl möglicher HW-Breakpoints	4 bis 6	2		1 bis 5	1 bis 10	6	2

• X = ja
• O = Teilweise, Einschränkungen
• - = nicht empfohle

Nur um nicht zu verwirren, auch wenn Teile "nicht empfohlen" sind, heißt das nicht dass es mit dem Prozessor nicht geht, vielmehr dass es mehr Aufwand ist das zu realisieren oder mehr Einschränkungen hat. Viele Eigenschaften weisen nur bestimmte Modelle einer Mikrocontrollerfamilie auf. Der Wechsel innerhalb einer Familie gestaltet sich jedoch oft einfach (z.B. innerhalb STM32 oder innerhalb PIC24).

Die Spalte Cortex zeigt die Prozessorfamilie von STM32F0xx bis STM32F4xx mit einem Cortex-M0 oder M3/M4 Kern. Die technischen Daten sind ähnlich anderer Hersteller die auch einen Cortex-Mx Kern verbauen wie z.B. NXP (LPC1xxx), Freescale, Atmel, TI, Toshiba, usw. Jedoch bietet ST mit dem STM32 eine hohe Flexibilität an Gehäuse-Variationen (vergleichbar mit NXP LPC1xxx) und ist privat recht leicht beschaffbar. Übersicht aller verfügbaren STM32 µC von ST.

Der STM32Fxxx ist in der Tat nicht der beste in der Kategorie "Stromsparend", die neueren STM32L0xx und STM32L4xx sind deutlich sparsamer, besonders bei hohen Temperaturen. Eine interessante Alternative mit Cortex-Mx Kern:
"EFM32" von Silabs benötigt nur 0,9 µA im Sleep Mode.

Die Spalte PIC zeigt die Eigenschaften der 8-Bit PIC18 (vergleichbar mit AVR), 16-Bit PIC24/dsPIC (vergleichbar mit MSP430) und 32-Bit PIC32 (vergleichbar mit STM32). Ein Wechsel des Mikrocontrollers innerhalb der Familien ist Codetechnisch problemlos möglich. Hardwaretechnisch sind verschiedene Modelle gleicher Familie zudem auch meist Pin-Kompatibel sodass ohne Design-Änderung zwischen verschiedenen Modellen gewechselt werden kann. Ein Wechsel zwischen den Familien ist Architekturbedingt aufwendiger, vor allem von 8-Bit auf 16/32-Bit. Aufgrund gleichbleibender IDE (Mplab) sowie gleichbleibenden Libraries bei Verwendung einer Hochsprache (C) jedoch vor allem zwischen 16-Bit und 32-Bit ohne weitere Probleme möglich .
Ein PIC10/12/16 ist für den Einstieg nicht empfohlen, da diese Architekturbedingt viele Einschränkungen haben, die eher hinderlich für das Lernen sind.

Der "Arduino" ist kein eigenständiger Prozessor, sondern ein fertiges Board (mit z.B. einem AVR oder STM32 Prozessor) und einer "Arduino" Programmierumgebung, extra geschaffen für Einsteiger. Allerdings ist da der Lerneffekt viel geringer da man den Prozessor mit der Arduino-Software programmiert und nicht direkt die Register. Anderseits ist der Arduino besser für jemanden geeignet, der eigentlich nicht lernen möchte, sondern nur mal schnell etwas steuern/basteln will und so ohne großartige µC Kenntnisse zum Ziel kommt. Für diese Zielgruppe ist der Arduino perfekt.

Unwichtige Randbedingungen

Oftmals werden fälschlicherweise Argumente für oder gegen eine µC-Familie ausgesprochen, die in der Praxis zum Einstieg (bei konkreten Anwendungen kann das anders aussehen) eher unwichtig sind.

• Spannungsversorgung 3,3V / 5V (Wobei z.B Atmel XMega keine 5V Tolerante Eingänge besitzt)
• 8 (z.B. AVR), 16 (z.B. MSP430) oder 32 (z.B. STM32) Bit
• Prozessorkern Cortex-M0/M3/M4, MIPS, ARM7/9/..., AVR-RISC, PIC-RISC, 8051, ...
• Interrupt System mit mehr oder weniger Features
• Programmiersprache (Assembler, Basic, C, C++, Pascal)
• Programmierumgebung - ist ohnehin Geschmackssache
• Assembler verstehen (Sollte nur theoretisch verstanden werden, ein Programm sollte in einer Hochsprache geschrieben sein)
• DIL Gehäuse - steckbretttauglich (STM32-Prozessoren gibt es auch fertig gelötet auf einem steckbretttauglichen Board)
• Programmieradapter - solange er auch debuggen kann
• zu 90% reicht doch ein kleiner Prozessor (AVR/PIC), andererseits sind STM32 Modelle nicht wesentlich teurer.

Kosten

Grobe Abschätzung was das alles denn kosten wird. Hier sind nur einige Beispiele gezeigt (Einzelpreise bei Bezugsquellen in Deutschland).

Board	STM32	AVR	PIC18/24/32	MSP430
Demo-Board	Nucleo64 Boards und STM32 Discovery Boards ab 15€ (incl. Debugger)	Arduino Uno clone ab 9€	Microchip Demoboard ab 18€ (Für 16 und 32bit auch mit integriertem Debugger)	MSP430 Demoboard ~35€
Steckbrettaugliches Board	Blue-Pill Board ab 1,50€, S64DIL-405 mit STM32F405 30€	Arduino Nano clone ab 2€	PIC Microstick
Einzelchip (Einzelstückpreise)	1..15€ nur SMD (TSSOP..LQFP..BGA)	0,6..15€ SMD + DIP	0,5..15€ SMD + DIP
Programmieradapter mit Debugger	ST-Link clone 2,50€ ST-Link original 48€ Segger J-LINK EDU 50€	Atmel AVR Dragon 40€ Atmel ICE ohne Gehäuse ab 99€	PICkit 3 clone 8€ Microchip PICkit 3 original 90€

Das Demo-Board sollte preisgünstig sein, um eventuelle Verluste bei falscher Benutzung gering zu halten. Wenn einem der Prozessor gefällt, so kann man später immer noch auf ein umfangreicheres Board (z.B. mit Display) umsteigen.

Zum Debuggen von STM32 Mikrocontrollern benötigt man einen Programmieradapter mit SWD oder JTAG Protokoll. Die meisten Demo Boards von ST enthalten bereits einen SWD fähigen ST-Link Adapter. Aktuell (2022) z.B. STLINK-V3SET und STLINK-V3MINI

Der Segger J-LINK EDU ist zwar nicht der günstigste Programmieradapter/Debugger, hat jedoch einen guten Ruf und ist nutzbar für praktisch alle Prozessoren mit ARM-Kern. Der Hersteller bewirbt ihn als besonders schnell.

Programmierumgebungen

Bei den Programmierumgebungen gibt es zu allen Prozessorfamilien kostenlose und leistungsfähige Software.

Aktuell (2022) ist für den Einstieg die STM32CubeIDE und STM32CubeMX zu empfehlen. STM32CubeIDE ist die IDE für die SW Entwicklung in C und C++ inkl. Debugging. STM32CubeMX ist ein grafisches Tool zur Konfiguration des Controllers (IO's, Timer, Interrupts, Clocktree, ...) mit automatischer Codegenerierung, Energieverbrauchsberechung und Visualisierung und enthält auch die Downloadmöglichkeit für viele Beispielprogramme in Abhängigkeit von der verwendeten MCU.

STM32CubeIDE basiert auf Eclipse, OpenOCD und GCC und läuft unter Linux und Windows. Unter Linux beträgt die Installationsgröße für STM32CubeIDE ca. 2,5 GB auf der Systempartition (/opt/stm32cubeide), für STM32CubeMX knappe 700 MB (/opt/stm32cubemx). Zusätzlicher Plattenplatz wird für Examples, Demos, Treiber (Hardware Abstraction Layer (HAL), Low-Level (LL), Board Supported Packages (BSP)) usw. benötigt und wird projektspezifisch von der verwendeten MCU im Ordner des Benutzers abgelegt. Hier sollte man ein paar hundert MB für reservieren.

Der vollständigkeithalber sei noch erwähnt, dass die beiden IDE's TrueStudio der Fa. Attolic und CooCox tot sind. True Studio ist in der STM32CubeIDE aufgegangen, CooCox ist bereits vor Jahren komplett eingestellt worden, auch ist die Homepage zu dem Projekt nicht mehr existent.

Alte Projekte von True Studio lassen sich so einfach leider nicht in STM32CubeIDE importieren, hier muss manuell nachgearbeitet werden..

Im professionellen Umfeld sind die folgenden Entwicklungsumgebungen verbreitet: Keil, IAR. Das Segger Enbedded Studio ist mit Einschränkungen kostenlos verwendbar.

Dokumentation

Bevor man sich für einen Prozessor entscheidet, sollte man unbedingt deren Dokumentation mal zumindest überfliegen und auch deren Errata lesen. Nicht dass man eine Anwendung erstellen möchte und stellt hinterher fest, dass genau dieser Teil so buggy ist, dass er nicht genutzt werden kann.

Beim STM32 hat die Dokumentation doch recht viele Seiten, viel mehr als bei einem AVR oder PIC, dabei ist vieles eher knapp beschrieben. Der Aufbau der STM32 Dokumentation ist hier beschrieben.
Bei den PICs ist die Dokumentation wiederum anders strukturiert, siehe im PIC Artikel.

Für die STM32, AVR und PIC Mikrocontroller gibt es zudem viele, auch deutschsprachige Einsteiger Hilfestellungen und Tutorials.

Parallel zur Dokumentation sollte man sich auch die Demo-Beispiele der Hersteller anschauen, dann wird vieles gleich verständlicher.

Eine Übersicht über die Funktionen gibt es im Artikel: STM32

Die Arbeit mit dem STM32

Zu erst einmal SOOO groß sind die Unterschiede zwischen den einzelnen Prozessoren nicht. Alle haben Ein-/Ausgänge und um mittels einem Port-Pin eine LED ansteuern zu können, muss bei jedem Prozessor der Pin erst einmal parametriert werden, egal ob das jetzt ein STM32 oder ein AVR oder ein MSP430 ist. Nur hat man bei einem STM32 doch einige Funktionen mehr, z.B. zuschaltbarer Pull-Up oder Pull-Down Widerstand und spezielle Setz-/Rücksetzregister, die andere Prozessoren nicht haben, jedoch das Programmieren vereinfachen. Der Hauptunterschied zu den anderen Prozessoren ist, dass der STM32 so viele Peripherie-Module beherbergt, dass man die einzeln immer mit einem Clock aktivieren muss, denn damit lässt sich viel Strom sparen.

Und mal ganz ehrlich, die Diskussion, welcher µC einfacher zu konfigurieren ist, ist doch absoluter Unsinn. Der Weg ist immer der Gleiche:

• 1. Blick ins Datenblatt, welche Register für diese Funktion benötigt werden.
• 2. Werte ermitteln, die in die Register eingetragen werden.
• 3. Werte ins Register schreiben. Da machte es GAR KEINEN UNTERSCHIED, ob es ein AVR, 8051/2, ARM, ... ist.

Noch einfacher und wesentlich schneller geht die Konfiguration mit dem STM32CubeMX Tool mit anschließender Codegenerierung, sofern die Konfiguration von STM32CubeMX geprüft und für OK befunden wurde.

Es stimmt schon, es gibt Unterschiede. Die Register haben anderen Namen, andere Adressen, andere Bitbedeutungen, ... Aber es steht doch alles im Datenblatt. Und ob ich jetzt einen AVR oder einen ARM das erste Mal vor mir liegen hab. Ich brauch in allen Fällen die oben beschriebenen Schritte.

Das Interruptsystem (NVIC, Nested Vectored Interrupt Controller) ist bei einem STM32 zusätzlich priorisiert. Damit kann man festlegen, welcher Interrupt vorrangig bearbeitet wird. Die Prioritätenvergabe ist auch kein Hexenwerk. Hier kann STM32CubeMX ein große Hilfe sein.

Zu allen Prozessoren liefern die jeweiligen Hersteller umfangreiche Demo-Codes und Libraries mit. Meist sind alle in C geschrieben, daher sollte auch die Programmiersprache C oder C++ verwendet werden. Vor allem auch wenn man berufliche Absichten verfolgt.

Und wenn man einen STM32 kann, dann ist ein Umstieg auf einen LPC1xxx (NXP) oder andere Hersteller überhaupt kein Problem (*), denn die bieten ebenfalls Prozessoren mit verschiedenen Cortex-M Kernen und man kann diese mit der gleichen Programmierumgebung programmieren. Somit ist man nicht zwingend herstellerabhängig. (* jeder Hersteller verbaut seine eigene Peripherie, die andere Funktionalitäten haben.)

Mit der STM32 Serie kann man nahezu alle Anwendungen realisieren. Die STM32-Serie hat genügend RAM, FLASH Speicher und eine entsprechende Anzahl an verschiedenste IO's, von einfachen GPIO's über SPI/I2C über I2S, SD-Card und USB, und auch ausreichend Geschwindigkeit und viele Gehäuse-Varianten. Viele Schnittstellen sind im Artikel STM32 beschrieben.

Für den Einstig gibt es diverse, auch deutschsprachige, Tutorials im Netz. Eine Übersicht ist hier auf der STM32 Seite. (Beispiel: STM32 Tutorial in Deutsch von Diller Technologies)
Wobei dazugesagt werden muss, dass diese meist auf die Standard ST-Libs aufbauen. Diese Libs vereinfachen zum einen das Ansteuern/die Benutzung der Peripheriefunktion zum anderen muss man diese erst einmal kennenlernen. Vereinfacht wird das da ALLE ST-Demo-Codebeispiele ebenfalls auf diesen Lib's basieren und somit wird der Wechsel innerhalb der STM32 Familie deutlich vereinfacht.
STM32F4xx Library von ST: "STSW-STM32065 STM32F4 DSP and standard peripherals library" incl. Dokumentation und Demo-Projekte zu allen CPU-Funktionen.

Der einzige Nachteil beim STM32: Man muss etwas mehr lesen, da eine Peripherie doch viel mehr Funktionalität hat (sofern man das Modul überhaupt benötigt). Ansonsten kenne ich nicht wirklich einen Grund, warum man als Neueinsteiger sich nicht für einen STM32 entscheiden sollte.

Wichtige Dokumente sind:

• User Manual zum verwendeten Board (Discovery Boards (grün), Nucleo Boards (weiß), ...)
• Getting started with .... (Application Note, AN....)
• Programming Manual STM32... (PM...)
• Reference Manual (RMxxxx)
• Datasheet zum Prozessor
• diverse User Guides für Examples, Treiber (BSP, HAL, LL), RTOS, FAT-FS, ...

Die Seitenzahl der Dokumente zusammen beträgt einige tausend. Es sind aber keine "Lesebücher", die von vorn bis hintengelesen werden möchten, sondern Nachschlagewerke. Man ließt im Grunde nur den Teil, der gerade interessant ist.

Programmiersprachen

• Wie bei vielen anderen Controllern wird beim STM32 auch hauptsächlich C und C++ verwendet. aber auch Pascal oder Basic ist problemlos möglich (z.B. von mikroe). Kennen sollte man die Programmiersprache C schon, wenn man davon noch keine Ahnung hat sollte man erst mal mittels einem Tutorial auf einem PC ein Konsoleprogramm schreiben, sodass man es einigermaßen kennen lernt. Hier im Forum gibt es ebenfalls Artikel dazu. Zielt man auf die (spätere) Anwendung in der Industrie, sollte aufgrund der Verbreitung auf jeden Fall C (oder C++) gewählt werden; außerdem sind die meisten verfügbaren Libraries in C geschrieben.
• Assembler sollte man nur grob verstehen, Details wie ein Befehl arbeitet ist unwichtig. Selbst wenn man die Zyklen für einen Funktionsaufruf wissen will, so bietet der STM32 (Cortex-M3) einen Cycle-Counter den man auslesen kann; durch die komplexere Pipeline und Cache-Effekte sind die Laufzeiten allerdings nicht genau vorhersehbar. Wird zyklengenaues Timing benötigt, sollten Timer verwendet werden - davon hat der STM32 genug.

Der 32 Bit-Adressraum, der RAM, Flash und I/O-Register vereinheitlicht ansprechen kann im Gegensatz z. B. zum AVR, ist ideal für eine Verwendung durch Hochsprachen. Bei Pointern muss keine zusätzliche Information verwaltet werden, in welche Art Speicher sie zeigen. Die Adresse gibt dies eindeutig an (es gibt nur eine Adresse 42, und nicht 2 wie z.B. beim AVR (Flash, RAM & I/O)) und die Hardware spricht automatisch den richtigen Speicher an. Die Möglichkeiten zur Offset-Adressierung, der Barrel-Shifter, Divsions-Einheit, die FPU (bei STM32F4), Interrupt-Modell etc. begünstigen ebenfalls die Erzeugung effizienteren Codes. Außerdem haben die STM32 einfach mehr "rohe Leistung", d.h. mehr Flash/RAM-Speicher und höhere Taktfrequenzen.

Folgerung: Die Programmierung in Hochsprachen ist bequemer als bei 8-Bittern, denn man muss sich einfach weniger Gedanken machen, ob der Compiler ein Programm nun effizent umsetzen kann (kann man natürlich trotzdem machen, um noch mehr Leistung "herauszuquetschen", wenn man will).

Weitere Randbedingungen für die Entscheidung

Der wichtige Punkt, der oftmals auch vergessen wird: die Beschaffbarkeit. Wenn jemand einen Renesas M16C oder Fujitsu empfiehlt, dann sucht man erst mal und findet nur wenige vereinzelte die man privat kaufen kann.

Oder auch die Unterstützung im Internet - ist bei einigen Exoten spärlich. Dieses Forum bietet die beste Hilfe für AVR, PIC, MSP430, LPC1xxx und STM32.

Andere Prozessoren sind schon sehr alt bzw. nicht mehr modern, da deren Peripherie zum Teil doch recht eingeschränkte Funktionalität bietet wie z.B. viele 8051 Typen oder PIC16 (oder auch dsPIC30). Die mögen für Mini-Anwendungen gut sein, aber wer will denn schon gerne sich extra für eine Kleinanwendung mit einem kleinen µC auseinandersetzen, wenn man schon einen STM32 kennt, mit dem man vieles machen kann und sich vllt. bereits gute Funktionen geschrieben hat?

Daher mein Resümee: Wer nicht gerade auf den Kopf gefallen ist, der kann getrost mit einem STM32 starten. Ein STM32F4DISCOVERY Board kostet nur ca. 20 EUR - und mehr muss für den ersten Start nicht investiert werden - wenn es doch zu komplex sein sollte gibt es hier im Forum auch viel Hilfe. Jedenfalls sind diese 20 EUR wirklich eine gute Investition.
Wer berufliche Absichten verfolgt, sollte zu einem späteren Zeitpunk sich unbedingt auch mit einem zweiten, anderen Prozessor beschäftigen um so die nötigen Erfahrungen zu gewinnen.

Ein paar Forenbeiträge:

• "Klein anfangen!" heisst die Devise
• Einen 8-Bitter nehme ich nur noch aus "Nostalgiegründen"

Übersicht CPU Funktionalitäten

In diesem Abschnitt ist kurz gezeigt welche Möglichkeiten die CPUs bei den oben empfohlenen Einsteigerboards haben.

STM32F407 - vom STM32F4DISCOVERY Board

Blockdiagramm STM32F407	STM32F4DISCOVERY Demoboard

Es sind sehr viele Peripheriemodule im µC implementiert. Jedes einzelne Peripherie-Modul (z.B. Ethernet, USB, CAN, Timer, AD-Wandler, usw.) kann aktiviert werden, indem der Clock freigeschaltet wird. So lange der Clock nicht aktiviert wurde verhält sich das Modul so als ob es nicht vorhanden wäre und beeinträchtigt in keiner Weise den Prozessor. Somit lässt sich der Stromverbrauch senken.

Eine ganze Auflistung der Einzelmodule steht im Artikel: STM32 und auf der Homepage von ST

Zu Anfang mag vielleicht die interne Busstruktur verwirren, jedoch braucht man diese nicht beachten. Wenn nun die CPU auf UART4 zugreifen möchte, so gehen die Daten durch die Busse "AHB1" -> "ABH/APB1-Bridge" -> "APB1". Dies erledigt der µC ganz von alleine. Diese Unterteilung ist technisch nötig, da die Peripheriebusse nicht mit dem gleichen Prozessortakt betrieben werden (wie z.B. bei [[MSP430], siehe Schaubild unten), die "Bridge" managt ganz alleine das Handling und generiert automatisch Wait-Befehle für die CPU.
Die "AHB-Bus-Matrix" ist ebenfalls für den Anwender meist uninteressant. ST hat damit ein System geschaffen, damit die CPU, DMAs und Displaycontroller gleichzeitig auf die verschiedenen RAM-Bereiche zugreifen können um mehr Daten parallel zu verarbeiten. Somit braucht man diese Matrix erst mal nicht beachten.

Ebenso braucht man zu Anfang sich auch keine Gedanken um den Prozessortakt machen, wenn man nichts initialisiert so läuft der STM32F4xx mit dem internen RC-Oszillator von 16 MHz und die Peripheriebusse laufen ebenfalls mit der gleichen Geschwindigkeit. Erst wenn man später umfangreichere Applikationen schreibt, bei der die 16MHz nicht mehr reichen, so kann man die PLL aktivieren und die Taktrate flexibel bis auf 168 MHz hochsetzen. (Siehe Demo-Projekt von STM32 CooCox Installation.)

LPC1x d.h. Cortex -M0 & -M3 Familie von NXP

Details können aus dem Leitartikel LPC1xxx und den darin verlinkten Artikeln entnommen werden.

Tipps und Tricks bei der Programmierung

Interruptcontroller vom Cortex-M3/M4

Der "Nested Vectored Interrupt Controller" (NVIC) ist eine Funktion der ARMv7M Architektur und ist über die CMSIS verwendbar.

Beim STM32 hat jeder Interrupt eine Priorität von 4 Bit (bei ARMv7M je nach Implementation bis 8bit möglich). Diese 4 Bit können in eine "pre-emption priority" und "subpriority" unterteilt werden.

Beispiel 2 Bit zu 2 Bit Unterteilung:

NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 2 Bits für pre-emption priority

Somit kann "pre-emption priority" den Wert 0..3 und "subpriority" auch 0..3 erhalten. Je kleiner die Zahl ist, desto höherwertiger ist der Interrupt.

Beispiel:
ISR1 Pre 2 / Sub 1
ISR2 Pre 1 / Sub 1
ISR3 Pre 1 / Sub 2

Wenn jetzt ISR1 kommt, dann wird der aufgerufen. Kommt währenddessen ein ISR2, dann darf der den ISR1 unterbrechen, da er eine höhere "pre-emption priority" Wertigkeit hat.

Wenn ISR2 bereits aktiv ist, so darf ISR3 diesen nicht unterbrechen, ISR1 ebenfalls nicht.

Wenn ISR2 und ISR3 gleichzeitig kommen, so wird zu erst ISR2 bearbeitet, anschließend ISR3. Da beide die gleiche "pre-emption priority" haben, fällt die Entscheidung anhand der "subpriority".

Beispiel Interrupt Konfiguration für USART1 mittels CMSIS-Funktionen:

NVIC_InitTypeDef NVIC_InitSt;
NVIC_InitSt.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitSt.NVIC_IRQChannelPreemptionPriority = 3; // << Tiefe Prio
NVIC_InitSt.NVIC_IRQChannelSubPriority = 1;
NVIC_InitSt.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitSt);

Taktzeitberechnung und Überwachung

Bei zeitkritischen Applikationen stellt sich immer wieder die Frage wie viele Prozessortakte nun die Funktion verbraucht. Ist der Interrupt auch wirklich nicht zu lange und wie viel Reserve gibt es noch?
Der ARMv7M -Kern hat dafür extra einen Takt-Zähler in der DWT-Einheit implementiert, den man mittels der CMSIS nutzen kann:

#include <stdint.h> // für die Standard-Typen uint32_t etc.
#include <stm32f4xx.h> // hier die Header-Datei der CMSIS für die jeweilige Familie verwenden

// DWT-Einheit aktivieren
inline void DWT_Enable() {
  CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
}

// Takt-Zähler - Messen der Anzahl der Befehle des Prozessors:
inline void DWT_CycCounterEn () {
  DWT->CTRL = 0x40000001;
}

inline void DWT_CycCounterDis () {
  DWT->CTRL = 0x40000000;
}

inline uint32_t DWT_CycCounterRead () {
  return DWT->CYCCNT;
}

inline void DWT_CycCounterClear () {
  DWT->CYCCNT = 0;
}

int main () {
  // ... Programmcode ...

  // Systick-Zähler benutzen
  DWT_Enable(); // DWT-Einheit aktivieren
  DWT_CycCounterEn (); // Zähler aktivieren
  DWT_CycCounterClear (); // Zähler löschen
  // ... Programmbearbeitung ...
  uint32_t iZ = DWT_CycCounterRead (); // Zähler auslesen
  
  // ... weiterer Programmcode ...
}

In iZ steht nun wie viele Maschinentakte der Prozessor für die Bearbeitung benötigt hat und kann mit folgender Formel umgerechnet werden:

Zeit in µSec = iZ / CPU-Takt in MHz

FAQ - Anfängerfragen

• Was brauche ich zum Programmieren/Debuggen? - Alle STM32 Mikrocontroller können über die SWD Schnittstelle programmiert und debuggt werden. Auch die JTAG Schnittstelle eignet sich dazu, benötigt aber etwas mehr Leitungen. Geeignete Adapter findet man zum Beispiel unter dem Namen ST-Link oder J-Link. Alle Discovery Boards und Nucleo Boards von ST enthalten bereits einen ST-Link Adapter. Bei den Nucleo-64 Boards ist er sogar abtrennbar und einzeln nutzbar. Alle neueren STM32 besitzen einen internen Bootloader, so dass sich dieser per SPI, UART oder USB bespielen lässt. Wenn Debuggen per Printausgabe reicht und sowieso eine eine USB Schnittstelle vorhanden sein soll, kann auf extra Programmierhardware komplett verzichten und braucht nur einen Jumper am Boot Pin bestücken.
• Ich möchte eine eigene Platine entwickeln, jedoch der 20polige JTAG-Anschluss ist mir zu groß, gibt es eine Alternative? - Ja, "Der 10-polige JTAG Stecker von mmvisual"

Links

• STM32 Hauptartikel, dortige Linksammlung
• Anleitung: STM32 Eclipse Installation
• Anleitung: STM32 Anleitungen und ein kleines Buch für den Einstieg
• Diskussion: Totzeitrechner für STM32