Let Google translate this article into english.

Gliederung

• Einleitung
• Modell Bezeichnungen
• Dokumentationen
• Elektrische Daten
  • Besondere Ausnahmen
• Boards
  • Nucleo-F103RB
  • Blue Pill Board
  • Maple Mini Board
  • STM32F103VET6 Minimum System Board
• Software
  • Entwicklungsumgebung
  • Zubehör
  • ARM Libraries
  • Projekt auf Basis von CMSIS erzeugen
• Programmier- und Debug-Schnittstellen
  • Boot Modi
  • Serieller Bootloader
  • USB Bootloader
  • SWJ Schnittstelle
    • ST-Link Adapter
    • Verbindungsoptionen
    • SWJ Deaktivieren
    • Trace Meldungen ausgeben
• GCC Optionen
  • Newlib
  • Assembler Listing
  • Optimizer
• Speicher-Stuktur
  • Funktionsaufrufe
  • Stack
  • Interrupt-Vektoren
• Startup-Code
• Taktgeber
• SysTick Timer
• Digitale Pins
• Analoge Eingänge
• PWM Ausgänge
• Echtzeituhr
  • Initialisieren
  • Lesen
  • Beschreiben
  • Kalibrieren
• USART Schnittstelle
• I²C Bus
• USB Schnittstelle
  • Virtueller COM-Port mit Cube HAL
  • Virtueller COM-Port ohne Cube HAL
• Power Management
• Arduino Umgebung
  • STM32duino Bootloader
  • Virtueller COM-Port mit Arduino
• Atollic TrueSTUDIO

STM32F1 Anleitung

Modell Bezeichnungen

Der STM32F103C8T6 ist also aus der Mainstream Familie, Performance line, Medium Density. Er läuft mit bis zu 72 MHz, hat 48 Pins, 64 kB Flash Speicher, ein LQFP Gehäuse und eignet sich für -40 bis +85 °C.

Dokumentationen

Weiterführende Doku:

• Einblick in die moderne Elektronik ohne viel Theorie Anleitung für den Einstieg
• Newlib Dokumentation der C Library
• ST Application Notes Anwendungshinweise und Programmierbeispiele
• STM32 Cortex M3 Programming Manual Beschreibung der Assembler Befehle
• STM32 F1 HAL Drivers Beschreibung des Cube HAL Frameworks, das CubeMX verwendet
• The Definitive Guide To The ARM Cortex-M3 von Joseph Yiu
• ARM Cortex M3 Technical Reference Manual von ARM

Elektrische Daten

Die Stromaufnahme ist im laufenden Betrieb mit 8bit Mikrocontrollern vergleichbar. Im Stop Modus ist sie jedoch mit ~20 µA viel höher. Für langfristigen Batteriebetrieb wird daher auf den sparsameren STM32L072 verwiesen.

Viele I/O Pins sind 5 V tolerant. Bei den STM32F103 Modellen sind das:
PA8-15, PB2-4, PB6-15, PC6-12, PD0-15, PE0-15, PF0-5, PF11-15, PG0-15.

Zulässige Spannungen an I/O Pins:

Die Ausgänge sind einzeln mit 20 mA und alle zusammen mit 150 mA belastbar. Gültige Logikpegel sind aber nur bis 8 mA garantiert. Die Ausgänge sind nicht Kurzschlussfest. Im open-drain Modus dürfen die 5 V toleranten Ausgänge durch externe Widerstände auf 5 V hoch gezogen werden.

Die internen Pull-Up und Pull-Down Widerstände haben ungefähr 40 kΩ. Alle I/O Pins haben ungefähr 5 pF Kapazität.

Der NRST (Reset) Pin hat intern einen Pull-Up Widerstand und kann sowohl vom Chip selber als auch von außen auf Low gezogen werden. Intern erzeugte Reset-Impulse sind garantiert mindestens 20 µs lang.

Besondere Ausnahmen

Die ESD Schutzdioden von PA4, PA5, PC13, PC14 und PC15 darf man nicht belasten.

Boards

Nucleo-F103RB Board

Das Nucleo-F103RB Board (alias Nucleo-64 mit STM32F103RBT6) ist ein hochwertiges Starter-Set zum günstigen Preis um 15 €. Die Besonderheit bei diesem Board ist, dass man einen ST-Link Adapter und einen USB-UART quasi dazu geschenkt bekommt.

• ARM Cortex-M3 Mikrocontroller Modell STM32F103RBT6
  • max. 72 MHz
  • 128 kB Flash
  • 20 kB RAM
  • 51·GPIO Pins, alle auf Stiftleisten herausgeführt
  • 2·ADC 12bit mit 15 Eingängen
  • 2·I2C, 3·USART, 2·SPI, 1·USB oder CAN, 7·DMA, 3·16bit Timer, RTC
• 8 MHz Hauptquarz und 32 kHz Uhrenquarz
• Eine programmierbare LED an PA5, die bei High Pegel leuchtet
• Ein programmierbarer Taster, der PC13 auf Low zieht, mit 4,7 kΩ Pull-Up Widerstand
• Reset Taster
• Stromversorgung wahlweise über USB, 7-12 V, 5 V oder 3,3 V
• Arduino UNO V3 kompatible Buchsenleisten für Erweiterungen (sogenannte Shields)
• Abtrennbarer ST-Link Adapter in Version 2.1
  • Zum Programmieren
  • Zum Debuggen
  • Virtueller Memory-Stick über den man Programme (*.bin Dateien) hochladen kann, kompatibel zu mbed
  • Virtueller COM Port (USB-UART) verbunden mit USART2, zur freien Verwendung
  • Der ST-Link kann für alle STM32 Mikrocontroller benutzt werden

Der I²C Anschluss an der rechten Arduino Buchsenleiste (beschriftet als SCL/D15 und SDA/D14) erfordert die Verwendung von I2C1 mit "remapped" Pin Konfiguration.

STM32 Nucleo-64 Manual Technische Beschreibung des "Nucleo" Boardes

Blue Pill Board

Das sogenannte "Blue Pill" Board aus China findet man bei AliExpress besser als "STM32F103C8T6 Board". Es kostet nur etwa 2 €, ein absoluter Knallerpreis. Wenn man besonders dünne Stiftleisten verwendet, passt das Board in einen 40-poligen DIP Sockel.

• ARM Cortex-M3 Mikrocontroller Modell STM32F103C8T6
  • max. 72 MHz
  • 64 kB Flash
  • 20 kB RAM
  • 27 nutzbare GPIO Pins herausgeführt
    • +2 wenn man auf USB verzichtet
    • +2 wenn man auf den Uhrenquarz verzichtet
    • +2 an der 4-poligen Stiftleiste wenn man auf SWD verzichtet
  • 2·ADC 12bit mit 10 Eingängen
  • 2·I²C, 3·USART, 2·SPI, 1·USB oder CAN, 7·DMA, 3·16bit Timer, RTC
• 8 MHz Hauptquarz und 32 kHz Uhrenquarz
• Zwei Jumper für den Boot Modus, über 100 kΩ mit dem µC verbunden
• Eine programmierbare LED an PC13, die bei Low Pegel leuchtet
• Reset Taster
• Stromversorgung wahlweise über USB, 3,3 V oder 5 V
• Separate Stiftleiste für die SWD Schnittstelle zum Anschluss des ST-Link Adapters

Der Boot1 Jumper (=PB2) kann im Normalbetrieb für eigene Zwecke verwendet werden.

Es wird geraten, den Rahmen der empfindlichen USB Buchse nachzulöten. Man darf das Board nicht gleichzeitig über USB und ein 5 V Netzteil versorgen (Kurzschluss). Eine zusätzliche 3,3 V Versorgung ist hingegen in Ordnung.

Der Widerstand R10 ist oft falsch mit 10 kΩ statt dem richtigen 1,5 kΩ bestückt, so dass der USB Port unzuverlässig funktioniert. Zur Korrektur kann man zusätzlich einen 1,8 kΩ Widerstand parallel schalten (von PA12 nach 3,3 V).

Wenn der 32 kHz Uhrenquarz benutzt wird, soll man die Stifte an PC14 und PC15 entfernen, damit er stabil schwingt.

Es wurde mehrfach berichtet, daß diese Boards mit aktiviertem Schreibschutz verkauft wurden. Das kann man über den SWD Anschluss oder über den seriellen Bootloader in den Option Bytes wieder entsperren.

Schaltplan des "Blue Pill" Boardes

Maple Mini Board

Nachbauten vom LeafLabs Maple Mini Board bekommt man aus China ab 3 €. Es ist mit dem selben Mikrocontroller bestückt, unterscheidet sich jedoch bei der Pinbelegung, und Stromversorgung. Dessen RTC ist mangels Quarz nicht benutzbar. Es hat keine SWD Stiftleiste, die entsprechenden Signale (SWD und SWCLK) sind jedoch auf einer der beiden Stiftleisten herausgeführt. Dieses Board passt nicht in 40 polige DIP Sockel.

Die aufgedruckte Beschriftung der Pins entspricht nicht dem Datenblatt, sondern bezieht sich auf das Arduino Framework.

• ARM Cortex-M3 Mikrocontroller Modell STM32F103C8T6
  • max. 72 MHz
  • 64 kB Flash
  • 20 kB RAM
  • 28 nutzbare GPIO Pins herausgeführt
    • +2 wenn man auf USB verzichtet
    • +2 wenn man auf SWD verzichtet
  • 2·ADC 12bit mit 9 Eingängen
  • 2·I²C, 3·USART, 2·SPI, 1·USB oder CAN, 7·DMA, 3·16bit Timer
• 8 MHz Hauptquarz
• Eine programmierbare LED an PB1, die bei High Pegel leuchtet
• Ein programmierbarer Taster an PB8 und Boot0, der die Pins über 1 kΩ auf High zieht, mit 10 kΩ Pull-Down Widerstand.
• Reset Taster
• Stromversorgung wahlweise über USB, 5..12 V oder 3,3 V

Der Spannungsregler kann leicht überhitzen wenn man ihn bei mehr als 7 V Versorgungsspannung mit zusätzlichen Verbrauchern belastet. Im Gegensatz zum "Blue Pill" Board darf man dieses Board gleichzeitig über USB und ein 5 V Netzteil versorgen.

Ein High Pegel an PB9 schaltet den USB Anschluss (Pull-Up Widerstand) ein.

STM32duino Wiki: Maple Mini Technische Beschreibung des "Maple Mini" Boardes

STM32F103VET6 Minimum System Board

Dieses Board aus China bekommt man ab 9 €. Es ist offensichtlich eine größere Variante vom "Blue Pill" Board. Ich habe es noch nicht ausprobiert.

• ARM Cortex-M3 Mikrocontroller Modell STM32F103VET6
  • max. 72 MHz
  • 512 kB Flash
  • 64 kB RAM
  • 74 nutzbare GPIO Pins herausgeführt
    • +2 wenn man auf USB verzichtet
    • +2 wenn man auf den Uhrenquarz verzichtet
    • +2 wenn man auf SWD verzichtet
  • 3·ADC 12bit mit 16 Eingängen
  • 2·DAC 12bit mit je 1 Ausgag
  • 2·I²C, 5·USART, 3·SPI, 2·I²S, 1·SDIO, 1·USB oder CAN, 12·DMA, 4·16bit Timer, 2·16bit PWM Timer, RTC
• Serielles EEPROM AT28C08 mit 8 kB Größe an PB6 und PB7 (= I²C 1)
• 8 MHz Hauptquarz und 32 kHz Uhrenquarz
• Zwei Jumper für den Boot Modus, über 100 kΩ mit dem µC verbunden
• Eine programmierbare LED an PC13, die bei Low Pegel leuchtet
• Reset Taster
• Stromversorgung wahlweise über USB, 3,3 V oder 5 V
• Separate Stiftleiste für die SWD Schnittstelle zum Anschluss des ST-Link Adapters

Die Firmware installiert man wahlweise über USART1 oder USB mit dem fest installierten Bootloader oder über SWD mit einem ST-Link Adapter.

Der Boot1 Jumper (=PB2) kann im Normalbetrieb für eigene Zwecke verwendet werden.

Man darf das Board nicht gleichzeitig über USB und ein 5 V Netzteil versorgen (Kurzschluss). Eine zusätzliche 3,3 V Versorgung ist hingegen in Ordnung.

Wenn USB verwendet wird, empfehle ich, den Pull-Up Widerstand an PA12 (D+) zu überprüfen. Er ist im Schaltplan mit 4,7 kΩ eingezeichnet, es sollten aber 1,5 kΩ sein.

Wenn der 32 kHz Uhrenquarz benutzt wird, soll man die Stifte an PC14 und PC15 entfernen, damit er stabil schwingt.

Schaltplan des STM32F103VET6 Minimum System Board

Software

Entwicklungsumgebung

Gehe direkt nach der Installation der System Workbench ins Menü "Help/Check for Updates...", um Fehlerkorrekturen zu erhalten!

Ganz unten findest du Hinweise zu anderen Entwicklungsumgebungen: Arduino IDE und Atollic TrueSTUDIO. Ich möchte aber darauf hinweisen, dass die Arbeitsschritte dieser Anleitung auf die System Workbench bezogen sind.

Hinweise für Linux

export SWT_GTK3=0

Tools

• STM32 Cube MX Code Generator für die Cube HAL
• STM32 Cube Programmer zum Flashen und Ändern der Option-Bytes über ST-Link, seriellem Port oder USB
• ST-Link Utility zum Anzeigen von Trace Meldungen, Flashen und Ändern der Option-Bytes über ST-Link Adapter
• Flash Loader Demonstrator zum Flashen über den seriellen Bootloader
• DFU Software zum Flashen über den eingebauten USB Bootloader

Optionale Software für Linux:

• STM32 Cube MX Code Generator für die Cube HAL
• STM32 Cube Programmer zum Flashen und Ändern der Option-Bytes über ST-Link, seriellem Port oder USB. Benötigt das Paket javafx für die GUI.
• ST-Link Tool zum Flashen mit ST-Link Adapter
• STM32 Flash zum Flashen über den seriellen Bootloader

ARM Libraries

Darauf aufbauend stellt die Firma ST ihr proprietäres Cube HAL Framework bereit, das den Zugriff auf die Hardware-Funktionen der STM32 Mikrocontroller durch Abstraktion erleichtern soll. Dazu gehört das Programm CubeMX, wo man sich Projekte samt Initialisierungs-Routinen für I/O Pins und Takterzeugung zusammen klickt.

Von 2007 bis 2011 war die inzwischen veraltete Standard Peripheral Library (SPL, StdPeriphLib) im Umlauf. Einige Beispiele im Internet beruhen noch darauf, zum Beispiel das oft gelobte STM32 Tutorial von Diller Technologies.

Die Firma ST nennt ihre Cube HAL und StdPeriphLib "Firmware". Von beiden rate ich ab, weil sie meiner Meinung nach nur wenig Erleichterung bringen und einen an die Produkte von ST binden.

Projekt auf Basis von CMSIS erzeugen

1. Lege mit dem Assistenten der IDE das eigentliche Arbeitsprojekt mit der Option "No Firmware" an.
2. Kopiere das ganze CMSIS Verzeichnis aus diesem Beispielprojekt in dein Arbeitsprojekt.
3. Füge die beiden Verzeichnisse (CMSIS/core und CMSIS/device) zur Projektkonfiguration hinzu. Das geht so: Rechte Maustaste auf den Projektnamen, dann Properties/C/C++ Build/Settings/Tool Settings/MCU GCC Compiler/Includes/Include paths.
4. In der Datei stm32f1xx.h habe ich unter dem Kommentar "Uncomment the line below according to the target STM32 device" (ungefähr Zeile 90) die zu meinem Mikrocontroller passende Zeile #define STM32F103xB aktiviert.

#include <stdint.h>
#include "stm32f1xx.h"

// delay loop for 8 MHz CPU clock
void delay(uint16_t msec)
{
    for (uint32_t j=0; j<2000*msec; j++)
    {
        __NOP ();
    }
}

int main(void)
{
    // Enable Port A and C
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPAEN);
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPCEN);

    // PA5 and PC13 = Output
    MODIFY_REG(GPIOA->CRL, GPIO_CRL_CNF5  + GPIO_CRL_MODE5,  GPIO_CRL_MODE5_0);
    MODIFY_REG(GPIOC->CRH, GPIO_CRH_CNF13 + GPIO_CRH_MODE13, GPIO_CRH_MODE13_0);

    while(1)
    {
        // LED Pin -> High
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BS5);
        WRITE_REG(GPIOC->BSRR, GPIO_BSRR_BS13);        
        delay(500);

        // LED Pin -> Low
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BR5);
        WRITE_REG(GPIOC->BSRR, GPIO_BSRR_BR13);        
        delay(500);
    }
}

Um das Programm mit einem ST-Link Adapter in den Mikrocontroller zu übertragen klickt man in der IDE mit der rechten Maustaste auf den Projektnamen, dann Target/Program Chip... wählen.

Programmier- und Debug-Schnittstellen

Boot Modi

Der fest eingebaute Bootloader ermöglicht Zugriff auf den Flash Speicher, das RAM und die Option Bytes über den seriellen Anschluss USART1 (bei den großen Modellen auch USB und CAN). Der Bootloader kann weder gelöscht noch verändert werden.

Um den Bootloader auf dem µC zu aktivieren, setzt man die Pins Boot0=High und Boot1=Low. Dann drückt man den Reset Knopf.

Serieller Bootloader

Folgende Verbindungen sind nötig:

Als Taktquelle dient der interne R/C Oszillator, dessen Frequenz bei 3,3 V und Zimmertemperatur meistens ausreichend genau ist. Der Bootloader erkennt die Baudrate automatisch. Es werden 8 Datenbits und gerade Parität (even) verwendet.

USB Bootloader

Für Arduino gibt es für einige STM32F103 Boards den STM32duino Bootloader, der das Programmieren über USB ermöglicht. Dieser kann aber nur mit der Arduino Software verwendet werden.

SWJ Schnittstelle

SWJ ist die einzige Schnittstelle, die von der System Workbench direkt ohne zusätzliche Plugins unterstützt wird. Sie funktioniert unabhängig von Boot Modus, Taktquelle, Spannung und Temperatur. Die SWJ Schnittstelle ist während und nach einem Reset standardmäßig aktiviert, kann jedoch per Software deaktiviert werden.

Sie unterstützt zwei Übertragungsprotokolle: JTAG und SWD. Das neuere SWD Protokoll wird bevorzugt, da es nur drei Leitungen benötigt und schneller ist.

ST-Link Adapter

Den ST-Link Adapter vom Nucleo-64 Board kann man abtrennen, um damit andere Mikrocontroller zu programmieren. Oder man zieht die beiden Jumper ab, wodurch die Leitungen SWCLK und SWDIO unterbrochen werden.

Er ist folgendermaßen mit dem Mikrocontroller verbunden:

Das Programm "STM32 Cube Programmer" verlangt nach einem Firmware-Update, was auf beiden Adaptern problemlos klappt. Die anderen oben genannten Programme sind hingegen auch mit älteren Firmware Versionen zufrieden.

Unter Umständen erscheint in der in der System Workbench die folgende Meldung von OpenOCD:

Info: vid/pid are not identical <erwartete ID> <ID deines ST-Link>

Bei dem chinesischen Stick empfehle ich, die Rückseite der inneren Platine mit Isolierband abzudecken, damit kein Kurzschluss zum Aluminium-Gehäuse entsteht. Sein Reset-Ausgang funktioniert nur bei STM8. Wer eine ruhige Hand hat, kann die nicht vorhandene SWO Leitung direkt an den Chip löten:

Zwei dieser verbesserten Adapter verkaufe ich privat für jeweils 5 Euro.

Verbindungsoptionen

Um zu verhindern, dass das installierte Programm startet und die Schnittstelle deaktiviert, kann man den Bootloader aktivieren.

Die System Workbench benutzt beim Debuggen standardmäßig die Option "Hardware Reset".

Zum Ändern soll man den Debugger wenigstens einmal durch Klick auf den grünen Käfer gestartet haben, damit die IDE eine initiale Debug-Konfiguration anlegt. Gehe danach mit der rechten Maustaste auf das Projekt, dann auf Debug As/Debug Configurations.... Gehe in dem folgenden Dialog in den Debugger Tab und klicke dort auf den Knopf Show generator options... um die folgende Ansicht zu erhalten:

SWJ Deaktivieren

// Enable clock for alternate functions
SET_BIT(RCC->APB2ENR, RCC_APB2ENR_AFIOEN);
    
// Disable both SWD and JTAG to free PA13, PA14, PA15, PB3 and PB4
MODIFY_REG(AFIO->MAPR, AFIO_MAPR_SWJ_CFG, AFIO_MAPR_SWJ_CFG_DISABLE); 

or:

// Disable JTAG only to free PA15, PB3* and PB4. SWD remains active
MODIFY_REG(AFIO->MAPR, AFIO_MAPR_SWJ_CFG, AFIO_MAPR_SWJ_CFG_JTAGDISABLE); 

Die SWJ Schnittstelle kann danach weiterhin während des Reset geöffnet werden, siehe Verbindungsoptionen.

Trace Meldungen ausgeben

SWO wird mit dem ST-Link Adapter aktiviert und konfiguriert. Dann ist PB3 vorübergehend ein Ausgang mit Ruhe-Pegel High. Während der seriellen Datenübertragung liefert er Low-Impulse. Wenn man später die Verbindung des Debuggers schließt, arbeitet der Anschluss wieder als normaler programmierbarer I/O Pin.

Die CMSIS Funktion ITM_SendChar() gibt ein Zeichen auf der SWO Leitung aus. ITM bedeutet "Instrumentation Trace Message":

#include <stdio.h>
#include "stm32f1xx.h"

// delay loop for default 8 MHz clock with optimizer enabled
void delay(uint16_t msec)
{
    for (uint32_t j=0; j<2000*msec; j++)
    {
        __NOP ();
    }
}

// Output a trace message
void ITM_SendString(char *ptr)
{
    while (*ptr)
    {
        ITM_SendChar(*ptr);
        ptr++;
    }
}

int main(void)
{
    while (1)
    {
        ITM_SendString("Hello World!\n");
        delay(500);
    }
}

Die System Workbench kann diese Meldungen nicht anzeigen, aber man kann den Debugger so konfigurieren, dass er sie in eine Datei schreibt. Das geht so:

Zuerst musst du das Projekt einmal debuggen (auf den grünen Käfer klicken), damit die IDE ein "Configuration Script" anlegt. Danach klicke mit der rechten Maustaste auf das Projekt, dann auf Debug As/Debug Configurations.... Gehe in dem folgenden Dialog in den Debugger Tab und stelle auf ein User defined configuration script um. Dann schließe den Dialog mit dem Button "Close":

Nun öffne dieses "Configuration Script" im Texteditor und hänge zwei Zeilen an:

tpiu config internal debug.txt uart off 8000000
itm port 0 on

Bei der nächsten debug Sitzung werden die Trace Meldungen dann in die Datei debug.txt (im Hauptverzeichnis des Projektes) geschrieben. Zur forlaufenden Anzeige benutze ich unter Windows den Befehl tail -f debug.txt in einem CygWin Fenster:

Die Datei enthält zwischen den Buchstaben nicht darstellbare Steuerzeichen. Unter Linux benutze ich daher zur Anzeige den Befehl: tail -f debug.txt | tr -dc '[:print:]\n'

Man kann die Schnittstelle auch so konfigurieren, dass sie die Meldungen im gleichen Format ausgibt, wie ein normaler serieller Port:

monitor tpiu config external uart off 8000000 2000000
itm port 0 on

Außerhalb einer Debugger-Sitzung kann man das ST-Link Utility mit einem ST-Link Adapter zur Anzeige benutzen, und zwar über dem Menüpunkt ST-LINK/Printf via SWO Viewer. Stelle die richtige Taktfrequenz ein und klicke dann auf Start.

GCC Optionen

Newlib

Wenn das Programm die stdio.h Library benutzt, muss man entweder einige Funktionen zum Zugriff auf die Konsole implementieren oder durch die Option -specs=nosys.specs auf Dummy Funktionen zurückgreifen.

Wenn man Fließkommazahlen ausgeben möchte, muss man bei der newlib-nano zusätzlich die Option -u _printf_float angeben. Das kostet zusätzlich rund 9 kB Flash Speicher. Für das Parsen von Fließkommazahlen benötigt man die Option -u _scanf_float.

Ich habe gemessen, wie viel Speicher die Funktionen puts() und printf() ohne Fließkomma-Unterstützung benötigen:

Der Speicherbedarf von printf() ist unabhängig von der Anzahl der Argumente und Formatier-Optionen. Wenn weniger als 1468 Bytes Heap zur Verfügung stehen, belegt die Library stattdessen nur 436 Bytes und gibt dann jedes Zeichen einzeln mit _write() aus. Wenn weniger als 436 Bytes Heap zur Verfügung stehen, dann brechen die Funktionen mit einer HardFault Exception ab.

Assembler Listing

Du findest dann für jede Quell-Datei eine *.lst Datei im Verzeichnis Debug oder Release.

Optimizer

Optimierter Code stimmt stellenweise nicht mehr mit dem C-Quelltext überein, was die Benutzung des Debuggers beeinträchtigt. Zum Beispiel kann der Debugger nur Variablen anzeigen, die eine Adresse im RAM haben, aber der Optimizer bevorzugt CPU Register für Variablen. Unter Umständen entfernt der Optimizer ganze Prozeduren und ersetzt sie durch anderen (inline) Code. Wiederholschleifen werden teilweise durch eine längere Sequenz von Code ersetzt, wenn dadurch die Performance besser wird.

Die Vollständige Liste der Optimierungen befindet sich hier.

Speicher-Struktur

Die Befehle sind teilweise 16bit und teilweise 32bit groß.

Daten werden als 8, 16 oder 32bit geladen. Sie müssen nicht zwingend an der 32bit Wortgröße ausgerichtet sein. Aber man erreicht bessere Performance, wenn 16bit Daten an 16bit Adressen und 32bit Daten an 32bit Adressen ausgerichtet sind. Der Compiler kümmert sich automatisch darum.

Die Register für I/O Funktionen sind fast alle 16 Bit breit.

Funktionsaufrufe

Der Rückgabewert einer Funktion wird ebenfalls in einem Register übermittelt und sollte daher 32bit groß sein, falls Performance wichtig ist.

Stack

Es gibt zwei Stapelzeiger MSP und PSP, zwischen denen man umschalten kann. Der Prozessor startet mit dem MSP, welcher durch das erste Wort in der Interrupt-Vektor Tabelle (an Adresse 0) initialisiert wird. Der alternative Stapelzeiger PSP wird von Betriebssystemen genutzt, um den Programmen separate Stapel zuzuweisen. Unter dem Namen SP spricht man immer den Stapelzeiger an, der durch das SPEL Bit im CONTROL Register ausgewählt wurde (0=MSP (default), 1=PSP).

Relevante CMSIS Funktionen:

• __get_MSP()
• __set_MSP(addr)
• __get_PSP()
• __set_PSP(addr)
• __get_CONTROL()
• __set_CONTROL(value)

Interrupt Vektoren

Jeder Eintrag in der Tabelle ist eine 32bit Sprungadresse. Bei allen Sprungadressen muss das Bit 0 gesetzt sein, es wird aber immer an die Adresse davor gesprungen. Der Wert 0x00001001 führt zu einem Sprung nach Adresse 0x00001000.

Die folgende Tabelle gilt für alle STM32F100 bis 103 mit maximal 512 kB Flash. Für die größeren Modelle siehe STM32F1 Reference Manual Kapitel: Interrupt and exception vectors.

Über das VTOR Register kann man den Ort der Vektortabelle verändern und sie z.B. ins RAM verschieben.

Reset, NMI und HardFault haben stets die allerhöchste Priorität. Bei allen anderen Interrupts kann man die Priorität einstellen. Interrupt-Handler können nur durch höher priorisierte Interrupts unterbrochen werden.

Die wichtigsten CMSIS Funktionen zur Konfiguration des Interrupt-Systems sind:

• NVIC_EnableIRQ(CMSIS Interrupt Nr) Erlaube Hardware Interrupt
• NVIC_DisableIRQ(CMSIS Interrupt Nr) Sperre Hardware Interrupt
• NVIC_SetPriority(CMSIS Interrupt Nr, Priorität) Stelle die Priorität ein (0=höchste, 15=niedrigste)
• NVIC_SystemReset() Löse einen System Reset aus
• __enable_irq() Erlaube alle Interrupts
• __disable_irq() Sperre alle Interrupts
• __set_PRIMASK(1) Verbiete Interrupts (ausgenommen: NMI und HardFault)
• __get_PRIMASK() Lese die aktuelle Prioritäten-Maske aus

Um Unterbrechungen temporär zu verbieten (zum Beispiel für exklusiven Zugriff auf Daten oder Schnittstellen), wird folgende Vorgehensweise empfohlen:

uint32_t backup = __get_PRIMASK();
__set_PRIMASK(1);

Auf die Daten oder Schnittstelle zugreifen

__set_PRIMASK(backup);

Startup-Code

Falls vorhanden, führt der Startup-Code eine Funktion mit folgender Signatur aus, bevor statische Objekte konstruiert werden und bevor main() ausgeführt wird:

void SystemInit(void) {}

Taktgeber

Die Taktsignale für den ARM Kern (dazu gehört auch der SysTick Timer), sowie RAM und Flash sind automatisch aktiviert. Alle anderen Komponenten muss man ggf. selbst einschalten, was ganz einfach durch Setzen von Bits in den Registern RCC->APB1ENR, RCC->APB2ENR und RCC->AHBENR erledigt wird.

Jetzt kommt der komplizierte Teil. Der System-Takt (SYSCLK) kann aus folgenden Quellen bezogen werden:

• HSI Interner 8 MHz R/C Oszillator, auf 1% kalibriert (bei 3,3 V und 25 °C)
• HSE Externe Quelle oder Oszillator mit 4-16 MHz Quarz oder Keramik Resonator

Für Watchog und Echtzeit-Uhr (RTC) sind weitere Quellen vorgesehen:

• LSI Ist ein interner R/C Oszillator mit ungefähr 40 kHz für den Watchdog, recht ungenau (30-60 kHz)
• LSE Ist ein Quarz-Oszillator für die Echtzeituhr

Das folgende Bild zeigt die Standardvorgabe vom STM32F100, STM32F101, STM32F102 und STM32F103 nach einem Reset:

Bei den Modellen STM32F105 und STM32F107 ist es im unteren Bereich etwas komplexer:

Achtung, kleiner Fallstrick: PLLMUL kann bei den Modellen STM32F100 bis 103 auf 2 bis 16 gestellt werden, aber bei den Modellen STM32F105 und STM32F107 nur auf 4 bis 9.

Wenn man den Systemtakt über 24 MHz erhöht, muss man für den Flash Speicher 1 Wait-State einstellen. Bei mehr als 48 MHz sind 2 Wait-States nötig. Bei mehr als 36 MHz ist außerdem ein Vorteiler für den internen APB1 Bus (auch low-speed I/O genannt) einzustellen.

Beispiel für 64 MHz mit dem internen HSI Oszillator (nicht für STM32F105, STM32F107):

// The current clock frequency
uint32_t SystemCoreClock=8000000;

// Change system clock to 64 MHz using 8 MHz crystal
// Called by Assembler startup code
void SystemInit(void)
{
    // Flash latency 2 wait states
    MODIFY_REG(FLASH->ACR, FLASH_ACR_LATENCY, FLASH_ACR_LATENCY_1);

    // 64 MHz using the 8 MHz/2 HSI oscillator with 16x PLL, lowspeed I/O runs at 32 MHz
    WRITE_REG(RCC->CFGR, RCC_CFGR_PLLMULL16 + RCC_CFGR_PPRE1_DIV2);

    // Enable PLL
    SET_BIT(RCC->CR, RCC_CR_PLLON);

    // Wait until PLL is ready
    while(!READ_BIT(RCC->CR, RCC_CR_PLLRDY)) {}

    // Select PLL as clock source
    MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_CFGR_SW_PLL);

    // Update variable
    SystemCoreClock=64000000;
}

Durch die Angabe __attribute__((section(".data"))) könnte man Funktionen etwas schneller aus dem RAM ausführen, da dieser ohne Waitstates arbeitet.

Beispiel für 48 MHz mit einem 8 MHz Quarz (HSE Oszillator):

// The current clock frequency
uint32_t SystemCoreClock=8000000;

// Change system clock to 48 MHz using 8 MHz crystal
// Called by Assembler startup code
void SystemInit(void)
{
    // Flash latency 1 wait state
    MODIFY_REG(FLASH->ACR, FLASH_ACR_LATENCY, FLASH_ACR_LATENCY_0);
    
    // Enable HSE oscillator
    SET_BIT(RCC->CR, RCC_CR_HSEON);

    // Wait until HSE oscillator is ready
    while(!READ_BIT(RCC->CR, RCC_CR_HSERDY)) {}

    // 48 MHz using the 8 MHz HSE oscillator with 6x PLL, lowspeed I/O runs at 24 MHz
    WRITE_REG(RCC->CFGR, RCC_CFGR_PLLSRC + RCC_CFGR_PLLMULL6 + RCC_CFGR_PPRE1_DIV2);

    // Enable PLL
    SET_BIT(RCC->CR, RCC_CR_PLLON);

    // Wait until PLL is ready
    while(!READ_BIT(RCC->CR, RCC_CR_PLLRDY)) {}

    // Select PLL as clock source
    MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_CFGR_SW_PLL);

    // Update variable
    SystemCoreClock=48000000;
}

Beispiel für 72 MHz mit einem 8 MHz Quarz (HSE Oszillator):

// The current clock frequency
uint32_t SystemCoreClock=8000000;

// Change system clock to 72 MHz using 8 MHz crystal
// Called by Assembler startup code
void SystemInit(void)
{
    // Flash latency 2 wait states
    MODIFY_REG(FLASH->ACR, FLASH_ACR_LATENCY, FLASH_ACR_LATENCY_1);

    // Enable HSE oscillator
    SET_BIT(RCC->CR, RCC_CR_HSEON);

    // Wait until HSE oscillator is ready
    while(!READ_BIT(RCC->CR, RCC_CR_HSERDY)) {}

    // 72 MHz using the 8 MHz HSE oscillator with 9x PLL, lowspeed I/O runs at 36 MHz
    WRITE_REG(RCC->CFGR, RCC_CFGR_PLLSRC + RCC_CFGR_PLLMULL9 + RCC_CFGR_PPRE1_DIV2);

    // Enable PLL
    SET_BIT(RCC->CR, RCC_CR_PLLON);

    // Wait until PLL is ready
    while(!READ_BIT(RCC->CR, RCC_CR_PLLRDY)) {}

    // Select PLL as clock source
    MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_CFGR_SW_PLL);

    // Update variable
    SystemCoreClock=72000000;
}

SysTick Timer

#include <stdint.h>
#include "stm32f1xx.h"

// The current clock frequency
uint32_t SystemCoreClock=8000000;

// Counts milliseconds
volatile uint32_t systick_count=0;

// Interrupt handler
void SysTick_Handler(void)
{
    systick_count++;
}

int main(void)
{
    // Initialize the timer for 1 ms intervals
    SysTick_Config(SystemCoreClock/1000);
    
    // Delay 2 seconds
    uint32_t start=systick_count;
    while (systick_count-start<2000);    
    ...
}

Digitale Pins

Bevor man einen Pin als Ausgang verwendet, muss man ihn im Register GPIOx->CRL (für Pin 0-7) oder GPIOx->CRH (für Pin 8-15) konfigurieren. Hierbei wird zwischen normaler Ausgabe und alternativen Funktionen (wie z.B. serieller Port oder PWM Timer) unterschieden.

Für jeden Ausgang kann man die maximale frequenz auf 2, 10 oder 50 MHz einstellen. Damit beeinflusst man die Geschwindigkeit, mit der die Spannung von Low nach High (und zurück) wechselt. Der maximale Laststrom wird dadurch nicht verändert. Im Sinne von elektromagentischer Verträglichkeit soll man hier immer den niedrigsten Wert einstellen, der zur Anwendung passt.

Direkte Schreibzugriffe sind über das Register GPIOx->ODR möglich. Um einzelne Pins atomar auf High oder Low zu schalten, verwendet man jedoch das GPIOx->BSRR Register.

Schaue Dir die Beschreibung der GPIO Register CRL, CRH, IDR, ODR und BSRR im Referenzhandbuch an.

Analoge Eingänge

Bevor man einen Pin als analogen Eingang verwendet, muss man ihn im Register GPIOx->CRL (für Pin 0-7) oder GPIOx->CRH (für Pin 8-15) konfigurieren. Zum Beispiel so für PA4:

    // Configure PA4 as analog input
    MODIFY_REG(GPIOA->CRL, GPIO_CRL_CNF4 + GPIO_CRL_MODE4, 0);

Initialisierung des ADC für einzelne Lesezugriffe:

// Initialize the ADC for single conversion mode
void init_analog()
{
    // Divide APB2 clock frequency by 8
    MODIFY_REG(RCC->CFGR, RCC_CFGR_ADCPRE, RCC_CFGR_ADCPRE_0 + RCC_CFGR_ADCPRE_1);
    
    // Enable Power for ADC
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_ADC1EN);

    // Switch the ADC on
    SET_BIT(ADC1->CR2, ADC_CR2_ADON);

    // Select software start trigger
    MODIFY_REG(ADC1->CR2, ADC_CR2_EXTSEL, ADC_CR2_EXTSEL_0 + ADC_CR2_EXTSEL_1 + ADC_CR2_EXTSEL_2);

    // Set sample time to 41.5 cycles
    MODIFY_REG(ADC1->SMPR2, ADC_SMPR2_SMP0, ADC_SMPR2_SMP0_2);

    // Delay 20 ms
    uint32_t start=systick_count;
    while (systick_count-start<20);

    // Start calibration
    SET_BIT(ADC1->CR2, ADC_CR2_ADON + ADC_CR2_CAL);

    // Wait until the calibration is finished
    while (READ_BIT(ADC1->CR2, ADC_CR2_CAL));
}

Lesen eines analogen Eingangs:

// Read from an analog input
uint16_t read_analog(int channel)
{
    // Select the channel
    MODIFY_REG(ADC1->SQR3, ADC_SQR3_SQ1, channel);

    // Clear the finish flag
    CLEAR_BIT(ADC1->SR, ADC_SR_EOC);

    // Start a conversion
    // These two bits must be set by individual commands!
    SET_BIT(ADC1->CR2, ADC_CR2_ADON);
    SET_BIT(ADC1->CR2, ADC_CR2_SWSTART);

    // Wait until the conversion is finished
    while (!READ_BIT(ADC1->SR, ADC_SR_EOC));

    // Return the lower 12 bits of the result
    return ADC1->DR & 0b111111111111;
}

Der ADC kann so konfiguriert werden, dass er mehrere Eingänge kontinuierlich liest. Mittels DMA können die Messergebnisse automatisch ins RAM übertragen werden. Dafür habe ich hier kein Beispiel parat.

PWM Ausgänge

Der Timer zählt fortlaufend von 0 an hoch bis zum Maximum, welches durch das TIMx->ARR Register festgelegt wird. Wenn der Maximalwert als 50000 festgelegt wird, können die Ausgangsimpulse wahlweise 1 bis 50000 Takte breit sein.

Die Taktfrequenz wird vom Systemtakt abgeleitet und kann durch den ABP2 Prescaler (im Register RCC->CFGR) und den Timer Prescaler TIMx->PSC reduziert werden.

Für jeden Ausgang gibt es ein Vergleichs-Register TIMx->CCRy welches bestimmt, wie breit die Ausgangsimpulse sein sollen. Beim Extremwert 0 ist der Ausgang ständig Low. Bei Werten größer dem Maximum (in TIMx->ARR) ist der Ausgang ständig High. Mit der option "inverse polarity" im Register TIMx->CCER können die Ausgänge umgepolt werden, so dass sie Low-Impule liefern.

Das folgende Beispielprogramm benutzt die Ausgänge von Timer 3 (PA6, PA7, PB0 und PB1), um dort vier angeschlossene Leuchtdioden unterschiedlich hell flimmern zu lassen:

#include "stm32f1xx.h"

void init_io()
{
    // Enable Port A, B and alternate functions
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPAEN);
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPBEN);
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_AFIOEN);

    // PA6 = Timer 3 channel 1 alternate function output
    MODIFY_REG(GPIOA->CRL, GPIO_CRL_CNF6 + GPIO_CRL_MODE6, GPIO_CRL_CNF6_1 + GPIO_CRL_MODE6_0);

    // PA7 = Timer 3 channel 2 alternate function output
    MODIFY_REG(GPIOA->CRL, GPIO_CRL_CNF7 + GPIO_CRL_MODE7, GPIO_CRL_CNF7_1 + GPIO_CRL_MODE7_0);

    // PB0 = Timer 3 channel 3 alternate function output
    MODIFY_REG(GPIOB->CRL, GPIO_CRL_CNF0 + GPIO_CRL_MODE0, GPIO_CRL_CNF0_1 + GPIO_CRL_MODE0_0);

    // PB1 = Timer 3 channel 4 alternate function output
    MODIFY_REG(GPIOB->CRL, GPIO_CRL_CNF1 + GPIO_CRL_MODE1, GPIO_CRL_CNF1_1 + GPIO_CRL_MODE1_0);
}

void init_timer3_for_pwm()
{
    // Enable timer 3
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_TIM3EN);

    // Timer 3 channel 1 compare mode = PWM1 with the required preload buffer enabled
    MODIFY_REG(TIM3->CCMR1, TIM_CCMR1_OC1M + TIM_CCMR1_OC1PE, 
        TIM_CCMR1_OC1M_2 + TIM_CCMR1_OC1M_1 + TIM_CCMR1_OC1PE);

    // Timer 3 channel 2 compare mode=PWM1 with the required preload buffer enabled
    MODIFY_REG(TIM3->CCMR1, TIM_CCMR1_OC2M + TIM_CCMR1_OC2PE, 
        TIM_CCMR1_OC2M_2 + TIM_CCMR1_OC2M_1 + TIM_CCMR1_OC2PE);

    // Timer 3 channel 3 compare mode = PWM1 with the required preload buffer enabled
    MODIFY_REG(TIM3->CCMR2, TIM_CCMR2_OC3M + TIM_CCMR1_OC1PE, 
        TIM_CCMR2_OC3M_2 + TIM_CCMR2_OC3M_1 + TIM_CCMR1_OC1PE);

    // Timer 3 channel 4 compare mode = PWM1 with the required preload buffer enabled
    MODIFY_REG(TIM3->CCMR2, TIM_CCMR2_OC4M + TIM_CCMR1_OC1PE, 
       TIM_CCMR2_OC4M_2 + TIM_CCMR2_OC4M_1 + TIM_CCMR1_OC1PE);

    // Timer 3 enable all four compare outputs
    SET_BIT(TIM3->CCER, TIM_CCER_CC1E + TIM_CCER_CC2E + TIM_CCER_CC3E + TIM_CCER_CC4E);

    // Timer 3 inverse polarity for all four compare outputs
    // SET_BIT(TIM3->CCER, TIM_CCER_CC1P + TIM_CCER_CC2P + TIM_CCER_CC3P + TIM_CCER_CC4P);

    // Timer 3 clock prescaler, the APB2 clock is divided by this value +1.
    TIM3->PSC = 0; // divide clock by 1 
    
    // Timer 3 auto reload register, defines the maximum value of the counter in PWM mode.
    TIM3->ARR = 50000; // 8000000/50000 = 160 pulses per second

    // Timer 3 enable counter and auto-preload
    SET_BIT(TIM3->CR1, TIM_CR1_CEN + TIM_CR1_ARPE);
}

int main(void)
{
    init_io();
    init_timer3_for_pwm();

    // set PWM pulse width of all four outputs
    TIM3->CCR1 = 40;
    TIM3->CCR2 = 400;
    TIM3->CCR3 = 4000;
    TIM3->CCR4 = 40000; 
}

Die Timer 1 und 8 können komplementäre Ausgangssignale mit Tot-Zeit erzeugen, was für den Eigenbau von H-Brücken nützlich ist. Allerdings kollidieren die Ausgänge vom Timer 1 teilweise mit dem USB Port und der Timer 8 existiert nur bei den größeren High und XL Density Modellen.

Ich möchte darauf hinweisen, dass die Timer noch viele weitere Funktionen haben, die ich hier gar nicht alle zeigen kann.

Echtzeituhr

Nach einem Stromausfall ohne bzw. mit leerer Batterie werden die Zähler automatisch auf 0 gesetzt und die Uhr angehalten.

Neben der Uhr enthält die batteriegepufferte Einheit auch 10 so genannte Backup Register (mit je 16bit Breite) wo man an Daten ablegen kann. Das letzte Backup Register Nr. 9 ist für den Bootloader reserviert.

Der LSE Oszillator nutzt nur sehr wenig Energie und ist daher bei falscher Beschaltung störanfällig. Die Leitungen zum sorgfältig ausgewählten Quarz sollen so kurz wie möglich sein und die Kapazitäten müssen genau berechnet werden.

Der Anschluss PC13 wird ebenfalls durch den Low-Power Schaltkreis der RTC versorgt, also auch durch die Backup Batterie. Er soll daher nur mit niedriger Frequenz geschaltet werden und bei High Pegel nicht belastet werden.

RTC Initialisieren

#include "stm32f1xx.h"

void initRtc()
{
    // Enable the backup domain
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_BKPEN + RCC_APB1ENR_PWREN);

    // Enable write access to the backup domain
    SET_BIT(PWR->CR, PWR_CR_DBP);

    // Enable LSE oscillator
    SET_BIT(RCC->BDCR, RCC_BDCR_LSEON);

    // Wait until LSE oscillator is ready
    while(!READ_BIT(RCC->BDCR, RCC_BDCR_LSERDY)) {}

    // Select LSE as clock source for the RTC
    MODIFY_REG(RCC->BDCR, RCC_BDCR_RTCSEL, RCC_BDCR_RTCSEL_LSE);

    // Enable the RTC
    SET_BIT(RCC->BDCR, RCC_BDCR_RTCEN);

    // Wait until RTC is synchronized
    while(!READ_BIT(RTC->CRL, RTC_CRL_RSF)) {}

    // Wait until last write operation is done
    while(!READ_BIT(RTC->CRL, RTC_CRL_RTOFF)) {}

    // Enable second interrupt
    SET_BIT(RTC->CRH,RTC_CRH_SECIE);

    // Wait until last write operation is done
    while(!READ_BIT(RTC->CRL, RTC_CRL_RTOFF)) {}

    // Enter configuration mode
    SET_BIT(RTC->CRL,RTC_CRL_CNF);

    // Divide oscillator frequency by 32767+1 to get seconds
    RTC->PRLL=32767;
    RTC->PRLH=0;

    // Leave configuration mode
    CLEAR_BIT(RTC->CRL,RTC_CRL_CNF);

    // Wait until last write operation is done
    while(!READ_BIT(RTC->CRL, RTC_CRL_RTOFF)) {}

    // Enable interrupt in NVIC
    NVIC_EnableIRQ(3);
    __enable_irq();
}

void init_io()
{
    // Enable Port A
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPAEN);

    // PA5 = Output
    MODIFY_REG(GPIOA->CRL, GPIO_CRL_CNF5 + GPIO_CRL_MODE5, GPIO_CRL_MODE5_0);
}

void RTC_Handler(void)
{
    // Toggle LED
    GPIOA->ODR ^= GPIO_ODR_ODR5;

    // Clear interrupt flag
    CLEAR_BIT(RTC->CRL,RTC_CRL_SECF);
}

int main(void)
{
    init_io();
    initRtc();
    while(1){};
}

In der Interrupt-Vektor Tabelle in startup/startup_stm32.s muss ein Eintrag für den "RTC_Handler" hinzugefügt werden, falls nicht vorhanden.

RTC lesen

uint32_t read_rtc()
{
    // Wait until RTC is synchronized
    while(!READ_BIT(RTC->CRL, RTC_CRL_RSF)) {}

    // Repeat until got the same value 2 times.
    uint32_t old=0;
    uint32_t new=0;
    do
    {
        old=new;
        new = (((uint32_t) RTC->CNTH) << 16) | ((uint32_t)RTC->CNTL);        
    }
    while (old != new);
    return new;
}

RTC beschreiben

void update_rtc(uint32_t seconds)
{
    // Wait until last write operation is done
    while(!READ_BIT(RTC->CRL, RTC_CRL_RTOFF)) {}

    // Enter configuration mode
    SET_BIT(RTC->CRL,RTC_CRL_CNF);

    RTC->CNTH = (uint16_t)(seconds >> 16);
    RTC->CNTL = (uint16_t)(seconds & 0xFFFF);

    // Leave configuration mode
    CLEAR_BIT(RTC->CRL,RTC_CRL_CNF);

    // Wait until last write operation is done
    while(!READ_BIT(RTC->CRL, RTC_CRL_RTOFF)) {}
}

RTC Kalibrieren

Um die Uhr ohne teure Messinstrumente grob zu kalibrieren lässt man sie einige Tage lang laufen und ermittelt dabei ihre Abweichung von der soll-Geschwindigkeit durch Vergleich mit einem präzisen Zeitserver.

Dann verringert man ggf. den Vorteiler RTC->PRLL so weit, dass die Uhr gerade eben etwas zu schnell läuft. Jede Verringerung um 1 macht die Uhr 2,637 Sekunden pro Tag schneller. Anschließend stellt man im Register BKP->RTCCR einen Korrekturwert (0-127) ein, wobei jede Stufe die Uhr um 0,082s pro Tag verlangsamt.

Wenn die Uhr zum Beispiel 4 Sekunden pro Tag zu langsam wäre, würde man den Vorteiler um 2 verringern und dann den Korrekturwert auf 15 stellen:

Vorteiler:          2 * +2,637 = +5,274 Sekunden  (also RTC->PRLL = 32767 - 2)
Korrekturwert:     15 * -0,082 = -1,230 Sekunden  (also BKP->RTCCR = 15)
================================================
Summe:                           +4,044 Sekunden

USART Schnittstelle

Das folgende Beispielprogramm gibt "Hello World!" auf USART2 aus und schickt danach alle empfangenen Zeichen als echo an den PC zurück. Das Senden findet hier direkt statt (ggf. mit Warteschleife) während der Empfang interrupt-gesteuert stattfindet:

#include <stdio.h>
#include "stm32f1xx.h"

uint32_t SystemCoreClock=8000000;

// Redirect standard output to the serial port
int _write(int file, char *ptr, int len)
{
    for (int i=0; i<len; i++)
    {
        while(!(USART2->SR & USART_SR_TXE));
        USART2->DR = *ptr++;
    }
    return len;
}

// called after each received character
void USART2_IRQHandler(void)
{
    char received=USART2->DR;

    // send echo back
    while(!(USART2->SR & USART_SR_TXE));
    USART2->DR = received;
}

int main(void)
{
    // Enable clock for Port A and USART2
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPAEN);
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_USART2EN);

    // PA2 (TxD) shall use the alternate function with push-pull
    MODIFY_REG(GPIOA->CRL, GPIO_CRL_CNF2 + GPIO_CRL_MODE2, GPIO_CRL_CNF2_1 + GPIO_CRL_MODE2_1);

    // Enable transmitter, receiver and receive-interrupt of USART2
    USART2->CR1 = USART_CR1_UE + USART_CR1_TE + USART_CR1_RE + USART_CR1_RXNEIE;

    // Set baudrate
    USART2->BRR = (SystemCoreClock / 115200);

    // Enable interrupt in NVIC
    NVIC_EnableIRQ(38);
    __enable_irq();

    printf("Hello World!\n");
    while (1) {};
}

Bei der Ausgabe von Text mit printf() und putchar() ist zu Beachten, dass die newlib Library die Zeichen in einem Puffer ansammelt, bis dieser entweder voll ist oder ein Zeilenumbruch erfolgt. Mit fflush(stdout) kann man erzwingen, dass die Ausgabe sofort erfolgt.

I²C Bus

Der Bus besteht aus den beiden Leitungen SDA und SCL. An beide Leitungen gehört jeweils ein Pull-Up Widerstand, typischerweise mit 4,7 kΩ bei 5 V oder 2,7 kΩ bei 3,3 V. Die STM32F1 Mikrocontroller haben zwei I²C Busse, beide unterstützen 3,3 V und 5 V Pegel, aber nur wenige Slaves sind so flexibel.

Zum Remappen kann man das Bit I2C1_REMAP im Register AFIO->MAPR setzen. Nach der Initialisierung der I²C Schnittstelle muss man die betroffen I/O Pins im Register GPIOB->CRL bzw. GPIOB->CRH als "Alternate function output open-drain 2 MHz" konfigurieren.

Normalerweise hat man einen zentralen Master, der viele Slaves ansteuert. Jeder Slave hat eine eigene eindeutige 7bit Adresse. Innerhalb einer Transaktion kann der Master 0 oder mehr Bytes an den Slave senden und danach 0 oder mehr Bytes vom Slave empfangen. Der folgende Code kann dazu für den Master verwendet werden:

#include <stdint.h>
#include <stdbool.h>
#include "stm32f1xx.h"


/**
 * Initialize the I²C interface.
 * The related I/O pins must be configured for alternate I/O open-drain AFTER this function.
 *
 * @param registerStruct May be either I2C1 or I2C2
 * @param fastMode false=100 kHz, true=400 kHz
 * @param apb1_clock clock frequency of APB1 peripherals
 */
void i2c_init(I2C_TypeDef* registerStruct, bool fastMode, uint32_t apb1_clock)
{
    // Enable clock
    if (registerStruct==I2C1)
    {
        SET_BIT(RCC->APB1ENR, RCC_APB1ENR_I2C1EN);
    }
    else if (registerStruct==I2C2)
    {
        SET_BIT(RCC->APB1ENR, RCC_APB1ENR_I2C2EN);
    }
    
    // Configure timing
    MODIFY_REG(registerStruct->CR2, I2C_CR2_FREQ, apb1_clock/1000000); 
    if (fastMode)
    {
        MODIFY_REG(registerStruct->CCR, I2C_CCR_CCR, apb1_clock/800000);
        MODIFY_REG(registerStruct->TRISE, I2C_TRISE_TRISE, apb1_clock/4000000+1);
    }
    else
    {
        MODIFY_REG(registerStruct->CCR, I2C_CCR_CCR, apb1_clock/200000);
        MODIFY_REG(registerStruct->TRISE, I2C_TRISE_TRISE, apb1_clock/1000000+1);
    }
    
    // Enable the peripheral
    SET_BIT(registerStruct->CR1, I2C_CR1_PE);
}


/**
 * Perform an I²C transaction, which sends 0 or more data bytes, followed by receiving 0 or more data bytes.
 *
 * @param registerStruct May be either I2C1 or I2C2
 * @param slave_addr 7bit slave_addr (will be shifted within this function)
 * @param send_buffer Points to the buffer that contains the data bytes that shall be sent (may be 0 if not used)
 * @param send_size Number of bytes to send
 * @param receive_buffer Points to the buffer that will be filled with the received bytes (may be 0 if not used)
 * @param receive_size Number of bytes to receive
 * @return Number of received data bytes
 */
unsigned int i2c_communicate(I2C_TypeDef* registerStruct, uint8_t slave_addr, 
    void* send_buffer, unsigned int send_size, void* receive_buffer, unsigned int receive_size)
{
    unsigned int receive_count=0;

    // shift the 7bit address to the right position
    slave_addr=slave_addr<<1;

    // Send data
    if (send_size>0)
    {
        // Send START and slave address
        SET_BIT(registerStruct->CR1, I2C_CR1_START);                     // send START condition
        while (!READ_BIT(registerStruct->SR1, I2C_SR1_SB));              // wait until START has been generated
        WRITE_REG(registerStruct->DR,slave_addr);                        // send slave address
        while (!READ_BIT(registerStruct->SR1, I2C_SR1_ADDR))             // wait until address has been sent
        {
            if (READ_BIT(registerStruct->SR1, I2C_SR1_AF))
            {
                // did not receive ACK after address
                goto error;
            }
        }

        READ_REG(registerStruct->SR2);                                   // clear ADDR
        while (send_size>0)
        {
            WRITE_REG(registerStruct->DR,*((uint8_t*)send_buffer));      // send 1 byte from buffer
            while (!READ_BIT(registerStruct->SR1, I2C_SR1_TXE))          // wait until Tx register is empty
            {
                if (READ_BIT(registerStruct->SR1, I2C_SR1_AF))
                {
                    // did not receive ACK after data byte
                    goto error;
                }
            }
            send_buffer++;
            send_size--;
        }
        while (!READ_BIT(registerStruct->SR1, I2C_SR1_BTF))              // wait until last byte transfer has finished
        {
            if (READ_BIT(registerStruct->SR1, I2C_SR1_AF))
            {
                // did not receive ACK after data byte
                goto error;
            }
        }
    }

    CLEAR_BIT(registerStruct->CR1, I2C_CR1_POS);                         // POS=0
    SET_BIT(registerStruct->CR1, I2C_CR1_ACK);                           // acknowledge each byte

    // Receive data
    // The procedure includes workaround as described in AN2824
    if (receive_size>0)
    {
        // Send (RE-)START and slave address
        SET_BIT(registerStruct->CR1, I2C_CR1_START);                      // send START condition
        while (!READ_BIT(registerStruct->SR1, I2C_SR1_SB));               // wait until START has been generated
        WRITE_REG(registerStruct->DR,slave_addr+1);                       // send slave address + read mode
        while (!READ_BIT(registerStruct->SR1, I2C_SR1_ADDR))              // wait until address has been sent
        {
            if (READ_BIT(registerStruct->SR1, I2C_SR1_AF))
            {
                // did not receive ACK after address
                goto error;
            }
        }

        if (receive_size>2)
        {
            READ_REG(registerStruct->SR2);                                // clear ADDR
            while (receive_size>3)
            {
                while (!READ_BIT(registerStruct->SR1, I2C_SR1_RXNE));     // wait until a data byte has been received
                *((uint8_t*)receive_buffer)=READ_REG(registerStruct->DR); // read data
                receive_size--;
                receive_count++;
                receive_buffer++;
            }
            while (!READ_BIT(registerStruct->SR1, I2C_SR1_BTF));          // wait until 2 bytes are received
            CLEAR_BIT(registerStruct->CR1, I2C_CR1_ACK);                  // prepare to send a NACK
            *((uint8_t*)receive_buffer)=READ_REG(registerStruct->DR);     // read the penultimate data byte
            receive_size--;
            receive_count++;
            receive_buffer++;
            __disable_irq();
            {
                SET_BIT(registerStruct->CR1, I2C_CR1_STOP);               // prepare to send a STOP condition
                *((uint8_t*)receive_buffer)=READ_REG(registerStruct->DR); // read the last data byte
                receive_size--;
                receive_count++;
                receive_buffer++;
            }
            __enable_irq();
        }
        else if (receive_size==2)
        {
            SET_BIT(registerStruct->CR1, I2C_CR1_POS);                    // NACK shall be applied to the next byte, not the current byte
            __disable_irq();
            {
                READ_REG(registerStruct->SR2);                            // clear ADDR
                CLEAR_BIT(registerStruct->CR1, I2C_CR1_ACK);              // prepare to send a NACK
            }
            __enable_irq();
            while (!READ_BIT(registerStruct->SR1, I2C_SR1_BTF));          // wait until 2 bytes are received
            __disable_irq();
            {
                SET_BIT(registerStruct->CR1, I2C_CR1_STOP);               // prepare to send a STOP condition
                *((uint8_t*)receive_buffer)=READ_REG(registerStruct->DR); // read the penultimate data byte
                receive_size--;
                receive_count++;
                receive_buffer++;
             }
            __enable_irq();
        }
        else if (receive_size==1)
        {
            CLEAR_BIT(registerStruct->CR1, I2C_CR1_ACK);                  // prepare to send a NACK
            __disable_irq();
            {
                READ_REG(registerStruct->SR2);                            // clear ADDR
                SET_BIT(registerStruct->CR1, I2C_CR1_STOP);               // prepare to send a STOP condition
            }
            __enable_irq();
            while (!READ_BIT(registerStruct->SR1, I2C_SR1_RXNE));         // wait until a data byte has been received
        }

        *((uint8_t*)receive_buffer)=READ_REG(registerStruct->DR);         // read the last data byte
        receive_size--;
        receive_count++;
        receive_buffer++;
        while (READ_BIT(registerStruct->SR1, I2C_CR1_STOP));              // wait until STOP has been generated
    }

    else if (receive_size==0 && send_size>0)
    {
        SET_BIT(registerStruct->CR1, I2C_CR1_STOP);                       // send STOP condition
        while (READ_BIT(registerStruct->CR1, I2C_CR1_STOP));              // wait until STOP has been generated
    }

    return receive_count;

    error:
    SET_BIT(registerStruct->CR1, I2C_CR1_STOP);                           // send STOP condition
    while (READ_BIT(registerStruct->CR1, I2C_CR1_STOP));                  // wait until STOP has been generated
    CLEAR_BIT(registerStruct->CR1, I2C_CR1_PE);                           // restart the I2C interface clear all error flags
    SET_BIT(registerStruct->CR1, I2C_CR1_PE);
    //ITM_SendString("I2C bus error!\n");
    return receive_count;
}


int main(void)
{
    // Enable Port B and alternate functions
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPBEN);
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_AFIOEN);

    // Initialize I2C1, no fast mode, APB1 clock is 8 MHz
    i2c_init(I2C1,false,8000000);

    // I2C uses PB6=SCL, PB7=SDA, alternate function open-drain 2 MHz
    // Must be done after the I2C initialization otherwise the I/O pins would start with wrong logic level
    MODIFY_REG(GPIOB->CRL, GPIO_CRL_CNF6  + GPIO_CRL_MODE6,  GPIO_CRL_CNF6_0 + GPIO_CRL_CNF6_1 + GPIO_CRL_MODE6_1);
    MODIFY_REG(GPIOB->CRL, GPIO_CRL_CNF7  + GPIO_CRL_MODE7,  GPIO_CRL_CNF7_0 + GPIO_CRL_CNF7_1 + GPIO_CRL_MODE7_1);

    uint8_t send_buffer[4]={10,20,30,40};
    uint8_t receive_buffer[9];

    // Communicate with slave address 8: send 4 bytes, then receive 9 bytes
    int received=i2c_communicate(I2C1, 8, send_buffer, 4, receive_buffer, 9);
}

USB Schnittstelle

USB und CAN schließen sich gegenseitig aus, man kann nur eine davon gleichzeitig nutzen.

Der Systemtakt muss entweder 48 MHz oder 72 MHz betragen und aus einem Quarz gewonnen werden. Der USB Clock Prescaler muss je nach Modell und Systemtakt so eingestellt werden:

Die USB Buchse ist beim STM32F103 mit PB11 (D-) und PB12 (D+) verbunden. An D+ befindet sich ein 1,5 kΩ Pull-Up Widerstand, welcher dem Host Computer signalisiert, dass ein Gerät angeschlossen wurde.

Manche Boards schalten den Widerstand durch einen Transistor. Dadurch kann man den Host Computer dazu bringen, das Gerät erneut zu erkennen, ohne das Kabel abstecken zu müssen. Beim "Maple Mini" Board schaltet PB9=High den Widerstand ein. Beim "Blue Pill" Board ist dieser Widerstand fest mit 3,3 V verbunden. Darum muss man bei diesem Board das USB Kabel nach jedem Firmware-Upload abstecken und wieder anschließen.

Virtueller COM-Port mit Cube HAL

Mit dem Programm CubeMX kann man sich ein Projekt mit USB Unterstützung zusammenklicken. Das geht so:

• Cube MX starten.
• Ein neues Projekt anlegen, dabei den richtigen Mikrocontroller einstellen.
• Im Reiter Pinout
  • Links die Option RCC/High Speed Clock (HSE): Crystal/Ceramic Resonator einstellen.
  • Unter SYS soll die Debug Option: Serial Wire und Timebase Source: SysTick gewählt werden.
  • Weiter unten die Option USB/Device (FS) einschalten.
  • Danach erscheint oben Links eine neue Option USB_DEVICE, wo die Variante Class for FS IP: Communication Device Class (Virtual Port COM) gewählt werden muss.
  • Suche Dir einen freien I/O Pin für die Status LED aus (bzw. nimm den Pin, der durch dein Board vorgegeben ist).
    • Klicke auf den Pin und wähle die Betriebsart GPIO Output.
    • Gib dem Pin den Namen "LED" (rechte Maustaste, Enter User Label).
• Im Reiter Clock Configuration kontrollieren, ob HSE als Quelle eingestellt wurde und mittels PLL auf 48 MHz erhöht wird. Wenn dein Quarz nicht 8 MHz hat, musst du das hier noch einstellen.
• Jetzt kannst du dein Projekt durch Klick auf das Zahnrad erzeugen und danach mit der System Workbench öffnen.

Um Text vom Mikrocontroller an den PC zu senden, füge im Quelltext von main.c folgendes zwischen die genannten Markierungen ein:

/* USER CODE BEGIN Includes */

#include "usbd_cdc_if.h"

/* USER CODE END Includes */

...

  /* USER CODE BEGIN WHILE */
  while (1)
  {
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */

        // LED On
        HAL_GPIO_WritePin(LED_GPIO_Port,LED_Pin,GPIO_PIN_RESET);
        HAL_Delay(500);

        // LED Off
        HAL_GPIO_WritePin(LED_GPIO_Port,LED_Pin,GPIO_PIN_SET);
        HAL_Delay(500);

        // Send data
        char msg[]="Hallo!";
        CDC_Transmit_FS( (uint8_t*) msg, strlen(msg));

  }
  /* USER CODE END 3 */

Die LED blinkt im Sekundentakt. Starte ein Terminalprogramm (z.B. Hammer Terminal) und öffne den virtuellen COM-Port. Die Baudrate spielt keine Rolle. Du empfängst jetzt jede Sekunde den Text "Hallo!".

Diese Variante belegt etwa 13 kB Flash und 4,5 kB RAM.

Damit die Ausgabefunktionen der Standard C Library (z.B. printf) funktionieren, musst du folgende Funktion implementieren:

// Redirect standard output to the USB port
int _write(int file, char *ptr, int len)
{
    CDC_Transmit_FS( (uint8_t*) ptr, len);
    return len;
}

Virtueller COM-Port ohne Cube HAL

Das Programm lässt die LED an Anschluss PC13 jede Sekunde aufblitzen und sendet dabei "Hello World!" über USB an den angeschlossenen Computer. Es belegt nur 6 kB Flash und 1,7 kB RAM. Davon dienen jeweils 256 Byte als Sendepuffer und als Empfangspuffer (kann man ändern).

#include <stdio.h>
#include "stm32f1xx.h"
#include "usb.h"

// The current clock frequency
uint32_t SystemCoreClock=8000000;

// Counts milliseconds
volatile uint32_t systick_count=0;

// Interrupt handler
void SysTick_Handler(void)
{
    systick_count++;
}

// Delay some milliseconds
void delay_ms(int ms)
{
    uint32_t start=systick_count;
    while (systick_count-start<ms);
}

// Change system clock to 48 MHz using 8 MHz crystal
// Called by Assembler startup code
void SystemInit(void)
{
    // Flash latency 1 wait state
    MODIFY_REG(FLASH->ACR, FLASH_ACR_LATENCY, FLASH_ACR_LATENCY_0);

    // Enable HSE oscillator
    SET_BIT(RCC->CR, RCC_CR_HSEON);

    // Wait until HSE oscillator is ready
    while(!READ_BIT(RCC->CR, RCC_CR_HSERDY)) {}

    // 48 MHz using the 8 MHz HSE oscillator with 6x PLL, lowspeed I/O runs at 24 MHz
    WRITE_REG(RCC->CFGR, RCC_CFGR_PLLSRC + RCC_CFGR_PLLMULL6 + RCC_CFGR_PPRE1_DIV2);

    // Enable PLL
    SET_BIT(RCC->CR, RCC_CR_PLLON);

    // Wait until PLL is ready
    while(!READ_BIT(RCC->CR, RCC_CR_PLLRDY)) {}

    // Select PLL as clock source
    MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_CFGR_SW_PLL);

    // Set USB prescaler to 1
    MODIFY_REG(RCC->CFGR, RCC_CFGR_USBPRE, RCC_CFGR_USBPRE);

    // Update variable
    SystemCoreClock=48000000;
}

void init_io()
{
    // Enable USB
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_USBEN);

    // Enable Port A, B and C
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPAEN);
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPBEN);
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPCEN);

    // PC13 = Output for the LED
    MODIFY_REG(GPIOC->CRH, GPIO_CRH_CNF13 + GPIO_CRH_MODE13, GPIO_CRH_MODE13_0);
}

// Redirect standard output to the USB port
int _write(int file, char *ptr, int len)
{
    for (int i=0; i<len; i++)
    {
        UsbCharOut(*ptr++);
    }
    return len;
}

int main(void)
{
    init_io();
    UsbSetup();

    // Initialize system timer
    SysTick_Config(SystemCoreClock/1000);

    while (1)
    {
        // LED On
        WRITE_REG(GPIOC->BSRR,GPIO_BSRR_BR13);
        delay_ms(100);

        puts("Hello World!");

        // LED Off
        WRITE_REG(GPIOC->BSRR,GPIO_BSRR_BS13);
        delay_ms(1000);
    }
}

Nach der Initialisierung mittels UsbSetup() wird die Funktion UsbCharOut() benutzt, um einzelne Zeichen zu senden.

UsbSetup setzt voraus, dass Systemtakt und Anschluss bereits korrekt konfiguriert sind. Die entsprechenden Zeilen habe ich oben fett hervorgehoben. Außerdem muss man den Interrupt-Handler USB_LP_CAN_RX0_IRQHandler in die Datei startup/startup_stm32.s eintragen, fall noch nicht vorhanden.

Bei der Ausgabe von Text mit printf() und putchar() ist zu Beachten, dass die newlib Library die Zeichen in einem Puffer ansammelt, bis dieser entweder voll ist oder ein Zeilenumbruch erfolgt. Mit fflush(stdout) kann man erzwingen, dass die Ausgabe sofort erfolgt.

Für fortgeschrittene Programmierer hat Niklas Gürtler das USB-Tutorial mit STM32 im mikrocontroller.net Forum geschrieben. Er beschreibt dort detailliert, wie die USB Schnittstelle funktioniert. Sein Beispielprogramm implementiert einen dreifachen USB-UART Adapter in C++. Ich habe es hier für die System Workbench und das Blue-Pill Board angepasst. Funktioniert prima, verstanden habe ich den Code jedoch (noch) nicht.

Power Management

*) Wenn der WFI/WFE Sleep innerhalb einer Interruptroutine aktiviert wurde, kann er nur durch einen höher priorisierten Interrupt aufgeweckt werden. Wenn gerade ein Ereignis ansteht, während __WFE() augerufen wird, wird nur das Ereignis gelöscht und kein Sleep Modus aktiviert.

Durch Setzen von Bit 1 (SLEEPONEXIT) im Register SBC->SCR aktiviert man die "Sleep on exit" Funktion. Diese bewirkt, dass der Prozessor nach Abarbeitung jeder Interruptroutine automatisch in den WFI Sleep Modus geht.

Wenn im SBC->SCR Register das Bit 4 (SEVONPEND) gesetzt ist, löst ein anstehender Interrupt zugleich ein Ereignis aus, selbst wenn der Interrupt nicht freigeschaltet ist.

Arduino Umgebung

Falls Du es trotzdem ausprobieren möchtest, empfehle ich für STM32F1 folgende Installation:

• Installiere zuerst die aktuelle Arduino IDE.
• Gehe ins Menü Datei/Voreinstellungen. Gebe ins Feld "Zusätzliche Boardverwalter-URLs" die Adresse http://dan.drown.org/stm32duino/package_STM32duino_index.json ein.
• Gehe ins Menü Werkzeuge/Board/Boardverwalter um die folgenden beiden Cores in dieser Reihenfolge zu installieren:
  1. Arduino SAM Boards (32-bits ARM Cortex-M3) by Arduino
  2. STM32F1xx/GD32F1xx boards by stm32duino

Damit erzeugte Sketche enthalten immer die Serial Klasse für den virtuellen COM Port, was etwa 14 kB Flash und 2,8 kB RAM belegt. Die echten seriellen Ports sind über die Klassen Serial1, Serial2 und Serial3 ansprechbar.

Diese Erweiterung basiert nicht auf der CMSIS, daher heißen dort die Konstanten für die Register und Bitmasken etwas anders. Werfe dazu ggf. einen Blick in die Dateien packages/stm32duino/hardware/STM32F1/2018.7.2/system/libmaple/stm32f1/include/series/*.h

Die Pins PA13, PA14, PA15, PB3 and PB4 sind standardmäßig für die ungenutzte Debug Schnittstelle reserviert. Das kann man so ändern:

void setup()
{
    // Disable both SWD and JTAG to free PA13, PA14, PA15, PB3 and PB4
    afio_cfg_debug_ports(AFIO_DEBUG_NONE);
    
    or:      
    
    // Disable JTAG only to free PA15, PB3 and PB4. SWD remains active
    afio_cfg_debug_ports(AFIO_DEBUG_SW_ONLY);
}

STM32duino Bootloader

Für das Blue-Pill Board ist die Datei generic_boot20_pc13.bin die richtige. Man installiert sie wahlweise über den seriellen Port mit einem USB-UART Adapter oder über den SWJ Anschluss mit einem ST-Link Adapter.

Der dazugehörige Windows Treiber befindet sich im Arduino_STM32 Paket. Führe zur Installation die Datei /Arduino_STM32-master/drivers/win/install_driver.bat aus. Für Linux braucht man keinen Treiber.

Der STM32duino Bootloader ist nur eine Sekunde lang nach dem Loslassen des Reset-Knopfes aktiv. Dies zeigt er durch schnelles Blinken der Status-LED an. Innerhalb dieser kurzen Zeit kann man mit der Arduino IDE einen Sketch hochladen.

Im Gerätemanager von Windows erscheint der Bootloader als "libusb-win32 devices/Maple DFU". Nach einer Sekunde verschwindet er wieder, danach erscheint der virtuelle serielle COM-Port des Sketches.

Wegen dem schwierigen Timing finde ich den Bootloader unhandlich und nicht empfehlenswert.

Virtueller COM-Port mit Arduino

void setup() 
{
    // PC13 is connected to the status LED
    pinMode(PC13, OUTPUT);
}

void loop() 
{
    digitalWrite(PC13, LOW);
    Serial.println("Tick");
    delay(500);

    digitalWrite(PC13, HIGH);
    Serial.println("Tack");
    delay(500);
}

Atollic TrueSTUDIO

Im Vergleich zur System Workbench sind mir nur wenige Unterschiede aufgefallen:

• Der J-Link Adapter von Segger (als Alternative zum ST-Link) wird offensichtlich ohne zusätzliches Plugin unterstützt.
• Beim Anlegen neuer Projekte wird immer die veraltete StdPeriph Library eingebunden.
• In dem Einstellungsdialog zum Compiler/Linker werden etwas mehr Optionen grafisch aufbereitet dargestellt.
• Um das Programm mit der IDE in den Mikrocontroller zu übertragen muss man es debuggen. Es gibt keinen "Target/Program Chip..." Dialog.

TrueSTUDIO kann Projekte importieren, die zuvor mit der System Workbench erstellt wurden. Sie werden dabei automatisch konvertiert.