STM32 Anleitungen

STM32L0 Anleitung

In diesem Tutorial sammle ich Informationen zur Anwendung von STM32 Mikrocontrollern, Serie L0. Also technische Daten, Hinweise und Programmier-Beispiele auf Basis der CMSIS, die beim Einstieg helfen könnten.

Modell Bezeichnungen

Der Hersteller hat sich für die Bezeichnung seiner Mikrocontroller folgendes Schema ausgedacht:

Dokumentationen

Die Pinbelegung und elektrischen Daten stehen im jeweiligen Datenblatt. Für den Programmierer ist das Reference Manual am wichtigsten, da es die I/O Funktionen und Register beschreibt. Im Errata Sheet beschreibt der Hersteller überraschende Einschränkungen und Fehler der Mikrochips, teilweise mit konkreten Workarounds.

*) Für diese neuen Modelle gibt es noch keine Errata (Stand März 2019).

Weiterführende Doku:

Elektrische Daten

Alle STM32L0 Chips kann man mit 1,8 bis 3,6 Volt betreiben. Die USB Schnittstelle läuft nur mit 3,3 V.

Fast alle I/O Pins sind 5 V tolerant, aber nicht: PA0, PA4, PA5, PC15, PH0, PH1
Bei einigen Modellen sind auch PA2 und PC14 nicht 5V tolerant.
Im open-drain Modus dürfen die 5 V toleranten Ausgänge durch externe Widerstände auf 5 V hoch gezogen werden.

Die Ausgänge sind einzeln mit 16 mA und alle zusammen mit 90 mA belastbar. Gültige Logikpegel sind aber nur bis 8 mA garantiert. Die Ausgänge sind nicht Kurzschluss-fest.

Die Eingänge sind sehr hochohmig (da CMOS) und haben einen Schmitt-Trigger. Die ESD Schutzdioden sind teilweise nur sehr bedingt belastbar. Die internen Pull-Up und Pull-Down Widerstände haben ungefähr 45 kΩ. Alle I/O Pins haben ungefähr 5 pF Kapazität. Die ESD Schutzdioden sind teilweise nur sehr bedingt belastbar.

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.

Für die Pins PC13, PC14 und PC15 nennt das Datenblatt (im Gegensatz zu den STM32Fx Serien) keine besonderen Ausnahmen.

Boards

Nucleo-L073RZ

Das Nucleo-L073RZ Board (aus der Nucleo-64 Reihe) ist ein hochwertiges Starter-Set zum günstigen Preis um 15 €.

Der 8 MHz Hauptquarz befindet sich auf dem ST-Link Adapter, er versorgt beide Mikrocontroller. Wenn man den ST-Link abtrennt, muss man den Mikrocontroller mit seinem internen R/C Oszillator betreiben oder einen zusätzlichen Quarz in die verbleibende Platine einlöten.

Das User Manual enthält die vollständige Beschreibung des Boardes.

Nucleo-L031K6

Das Nucleo-L031K6 Board (aus der Nucleo-32 Reihe) ist deutlich kleiner, obwohl es ebenfalls einen ST-Link Adapter enthält. Es kostet ungefährt 10 €.

Der eingebaute ST-Link Adapter kann nicht abgetrennt werden und er kann auch nicht zum Programmieren anderer Mikrocontroller verwendet werden.

Das User Manual enthält die vollständige Beschreibung des Boardes.

Software

Tools

Entwicklungsumgebungen:

Optionale Software für Windows:

Optionale Software für Linux:

1) Die Programm-Version 2.0 habe ich mit Oracle Java 8 und diesem Start-Script ans Laufen gebracht.

ARM Libraries

Die Basis-Library für alle ARM Cortex-M Mikrocontroller heisst CMSIS-Core. Dabei handelt es sich im Grunde genommen um einen Haufen Definitionen für alle Register, damit man sie mit Namen statt über Hexadezimal-Codes ansprechen kann. Außerdem enthält die CMSIS wenige Hilfsfunktionen, die den ARM Kern konfigurieren. Die CMSIS ist von ARM spezifiziert und wird von allen Chip Herstellern in spezifischen Varianten bereit gestellt.

Darauf aufbauend stellt die Firma ST ihre proprietäres Cube HAL Framework bereit, das den Zugriff auf die Hardware-Funktionen durch Abstraktion erleichtern soll. Dazu gehört das Programm CubeMX, womit man Quelltext-Projekte einschließlich Code zur Konfiguration der I/O Funktionen und Taktversorgung erzeugt.

Ich empfehle, die Programmierung zunächst anhand des Referenzhandbuches (ohne HAL) zu lernen.

Beispielprojekt

Beispiel für einen einfachen LED-Blinker an PA5 auf Basis der CMSIS:
// Filename: main.c

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

// delay loop for the default 2.1 MHz CPU clock with optimizer enabled
void delay(uint32_t msec)
{
    for (uint32_t j=0; j<419UL*msec; j++)
    {
        __NOP();
    }
}

int main(void)
{
    // Enable Port A
    SET_BIT(RCC->IOPENR, RCC_IOPENR_GPIOAEN);

    // PA5 = Output
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE5,  GPIO_MODER_MODE5_0);

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

        // LED Pin -> Low
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BR_5);
        delay(500);
    }
}
Ich weiß dass man Delays besser mit einem Timer realisiert. Hier wollte ich jedoch ein möglichst simples Programmbeispiel zeigen.

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 auf Target/Program Chip...

Programmier- und Debug-Schnittstellen

SWJ Schnittstelle

Mit der SWJ Schnittstelle übertragt man das fertige Programm in den Mikrocontroller und kann es im laufenden Betrieb untersuchen. Zum Beispiel kann man das Programm jederzeit anhalten und dann den Inhalt des Speichers anschauen. Wenn es hängt, kann der Debugger anzeigen, wo das passiert. Der Debugger kann sogar melden, wenn ausgewählte Variablen verändert werden.

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 nach dem Reset standardmäßig aktiviert, kann jedoch per Software deaktiviert werden.

Achtung: Die Schnittstelle funktioniert nicht im Stop, Standby und Sleep Modus!

Die SWJ Schnittstelle unterstützt zwei Übertragungsprotokolle: JTAG und SWD. Das neuere SWD Protokoll wird bevorzugt, da es schneller ist und nur drei Leitungen benötigt: GND, SWDIO und SWCLK.

Die passenden Programmieradapter von ST heißen "ST-Link". Billige Nachbauten aus China sehen so aus:

Den ST-Link Adapter vom Nucleo-L073RZ 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:

ST-Link CN4MikrocontrollerBeschreibung
Pin 1VDDMisst die Spannungsversorgung, bei den hier dargestellten ST-Link Adaptern optional
Pin 2SWCLKPA14Serial Wire Clock
Pin 3GNDCommon Ground (Masse)
Pin 4SWDIOPA13Serial Wire Data
Pin 5NRSTReset Signal, optional siehe Verbindungsoptionen
Pin 6SWOReserviert für Serial Wire Output.
Diese Funktion gibt es beim Cortex-M0 Kern nicht. Beim Debuggen von anderen Mikrocontrollern mit Cortex-M3 (oder Nachfolger) kann man den Pin aber nutzen.

DDie Cube Programme verlangen nach einem Firmware-Update, was auf beiden Adaptern problemlos klappt. Die anderen oben genannten Programme sind hingegen auch mit älteren Firmware Versionen zufrieden.

Bei dem chinesischen Stick empfehle ich, die Rückseite der inneren Platine mit Gewebeband abzudecken, damit kein Kurzschluss zum Aluminium-Gehäuse entsteht. Man braucht am Target einen Reset-Taster, weil der Reset-Ausgang des Sticks nur bei STM8 funktioniert.

SWJ Deaktivieren

Nach dem Reset sollten Programme erst eine Sekunde abwarten, bevor sie die Schnittstelle deaktivieren. Dies erleichtert den Verbindungsaufbau des Debuggers zum Übertragen neuer Programme.

Um die betroffenen Pins für normale Ein-/Ausgabe zu verwenden, stellt man im Register GPIOx->MODER einfach den gewünschten Modus ein (Input, Output oder Analog).

Boot Loader

Neben der SWJ Schnittstelle haben alle STM32 auch einen unveränderlichen Bootloader, über den man Programme hochladen kann. Er ermöglicht Zugriff auf den Flash Speicher, das RAM und die Option Bytes, zum Debuggen eignet er sich jedoch nicht.

Der Bootloader unterstüzt folgende Anschlüsse:

ModellUSARTUSARTUSBSPISPII2CI2C
TxD,RxDTxD,RxDD-,D+NSS,SCK,MISO,MOSINSS,SCK,MISO,MOSISCL,SDASCL,SDA
STM32L010x4,x6PA2,3PA4-7
STM32L010x8,xBPA2,3PA4-7PB6,7
STM32L011PA9,10PA2,3PA4-7*
STM32L021PA9,10PA2,3PA4-7*
STM32L031PA9,10PA2,3PA4-7
STM32L041PA9,10PA2,3PA4-7
STM32L051PA9,10PA2,3PA4-7PB12-15
STM32L071PA9,10PA2,3PA4-7PB12-15PB6,7PB10,11
STM32L081PA9,10PA2,3PA4-7PB12-15PB6,7PB10,11
STM32L052PA9,10PA2,3PA4-7PB12-15
STM32L062PA9,10PA2,3PA4-7
STM32L072PA9,10PA2,3PA11,12
STM32L082PA9,10PA2,3PA11,12
STM32L053PA9,10PA2,3PA4-7PB12-15
STM32L063PA9,10PA2,3PA4-7PB12-15
STM32L073PA9,10PA2,3PA11,12
STM32L083PA9,10PA2,3PA11,12
*) Bei TSOP14 Gehäuse: PA4,PA7,PA13,PA14

Zur Konfiguration des Bootloaders dient der Boot0 Pin und das Flag Boot1 in den Option Bytes (die mit der Programmiersoftware einstellbar sind):

Boot0Boot1Starte von
LowegalFlash ab Adresse 0x0800 0000, gemappt auf 0x0000 0000
HighLowBootloader
HighHighRAM ab Adresse 0x2000 0000, gemappt auf 0x0000 0000

Boot0 und Boot1 werden beim Reset und beim Aufwachen aus dem Standby Modus gelesen. Um den Bootloader zu aktivieren, setzt man den Pin Boot0=High und dann drückt man den Reset Knopf.

Weitere Informationen zum Bootloader stehen in der Application Note AN2606.

Serieller Bootloader

Die Verbindung zum PC wird mit einem USB-UART Adapter wie diesem hergestellt:

Folgende Verbindungen sind nötig:

PC USB-UARTSTM32L0 USARTBeschreibung
TxDRxDDaten
RxDTxDDaten
GND GNDGemeinsame Masse

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

USB Bootloader

Der USB Bootloader benötigt keinen Quarz und keinen externen Pull-Up Widerstand. Weitere Anwendungshinweise findest du in der Application Note AN2606.

GCC Optionen

Achtung: Keil MDK verwendet einen anderen Compiler, für den dieses Kapitel nicht passt.

Newlib

Newlib ist die Standard-Bibliothek für Linux, während newlib-nano für Mikrocontroller optimiert wurde. Du kannst eine Menge Speicherplatz sparen, indem du auf die nano Version der Library wechselst. Dazu dient das Linker-Flag -specs=nano.specs.

Wenn das Programm die stdio.h Library benutzt, muss man entweder einige Funktionen zum Zugriff auf die Konsole implementieren oder mittels Linker-Flag -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() von der newlib-nano ohne Fließkomma-Unterstützung benötigen:

FunktionHeapStackCode (Flash)
puts()1468162700 Bytes
printf()1468164284 Bytes

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

Wenn du sehen willst, welchen Assembler-Code der Compiler erzeugt, benutze das Linker-Flag
-Wa,-adhlns="$(@:%.o=%.lst)"
Du findest dann für jede Quell-Datei eine *.lst Datei im Verzeichnis Debug oder Release.

Optimizer

In den Einstellungen des Compilers kann man beeinflussen, mit welcher Strategie der Compiler das Programm optimiert (umstrukturiert).

OptionZielBeschreibung
-O0DebuggingKeine Optimierung. Der Assembler Code entspricht genau dem C-Code, was für den Debugger optimal ist. Aber das Programm läuft viel Langsamer, als mit Optimierung.
-O1CompilierzeitDer Compiler wendet nur einfache Optimierungen an, die er schnell umsetzen kann. Nicht empfehlenswert.
-O2GeschwindigkeitGute Geschwindigkeit, von ARM als Standardeinstellung empfohlen.
-O3GeschwindigkeitBeste Geschwindigkeit, unter Umständen wird der Code aber viel größer.
-OsCode-GrößeGute Geschwindigkeit bei möglichst geringer Code-Größe
-OgDebuggingDas Programm wird so weit wie möglich auf Geschwindigkeit optimiert, ohne den Debugger zu beeinträchtigen.

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 Geschwindigkeit besser wird.

Die vollständige Liste der Optimierungen befindet sich hier.

Startup-Code

Im Gegensatz zu allen mir bekannten Compilern für 8bit Mikrocontroller befindet sich der Startup-Code und die Interrupt-Vektor Tabelle in editierbaren Dateien (sysmem.c und startup_stm32.s). Der Projekt-Assistent in der IDE legt diese Dateien automatisch an. Für erste Versuche kann man sie unverändert benutzen.

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) {}
Bei großen C++ Projekten kann es sich lohnen, die Erhöhung der Taktfrequenz dort unterzubringen, denn dann startet das Programm schneller.

Speicher-Struktur

Obwohl der Prozessor in Harvard Architektur gestaltet ist, benutzt er einen gemeinsamen Adress-Raum für Programm, Daten und I/O Register. Dadurch können alle I/O Register über Zeiger angesprochen werden und der Prozessor kann Code sowohl aus dem RAM als auch aus dem (Flash-) ROM ausführen. Adressen und Zeiger sind 32bit groß.

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 Geschwindigkeit, 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 überwiegend 32bit breit.

Der arm-gcc Compiler legt konstante Zeichenketten (im Gegensatz zum avr-gcc) in den Flash Speicher, ohne dafür RAM zu verbrauchen.

Funktionsaufrufe

Bei Funktionsaufrufen werden bis zu 4 Parameter durch Register übergeben. Dabei ist es vorteilhaft, sie als 32bit Typ zu deklarieren, um Konvertierungen zu vermeiden. Bei mehr als 4 Parametern wird das RAM zur Übergabe benutzt, dann sind 8bit, 16bit und 32bit Typen gleich langsam.

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

Stack

Der Stapel speichert ausschließlich 32bit Werte. Bei jedem PUSH wird der Stapelzeiger (SP) zuerst um 4 verringert und dann wird das Wort an diese Adresse abgelegt. Der Stapelzeiger zeigt also immer auf die zuletzt belegte Adresse im RAM.

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:

Interrupt-Vektoren

Der Flash-Speicher beginnt immer mit der Exception- und Interrupt-Vektor Liste. Jeder Eintrag in der Liste ist eine 32bit Sprungadresse. Diese ist im Referenzhandbuch Kapitel "Interrupt and exception vectors" dokumentiert.

Der Quelltext dazu befindet sich in der Datei startup/startup_stm32.s. Dort findest du die vorgegebenen Namen der C-Funktionen. Die folgende Tabelle gilt für alle STM32L0 Modelle:

AddressARM Exception Nr.CMSIS Interrupt Nr.ISR Handler FunctionDescription
ARM Processor Exceptions
0x0000Initial value for the stack pointer MSP.
0x0004Reset_HandlerInitial value for the program counter, points to assembler startup code.
0x00082-14NMI_Handler()Non maskable interrupt. The RCC Clock Security System (CSS) is linked to the NMI vector.
0x000C3-13HardFault_Handler()Hardware fault.
0x00104-12reserved
0x00145-11
0x00186-10
0x001C7-9
0x00208-8
0x00249-7
0x002810-6
0x002C11-5SVC_Handler()Supervisor Call, triggered by the SVC command (formerly known as SVI). Can be used to call operating system services.
0x003012-4reserved
0x003413-3
0x003814-2PendSV_Handler()Pendable Request for System Service. Triggered by the operating system by writing to the ICSR register, to switch the context.
0x003C15-1SysTick_Handler()Called when the systick timer reaches 0
STM32 Hardware Interrupts
0x00400WWDG_IRQHandler()Window Watchdog
0x00441PVD_IRQHandler()PVD through EXTI Line detection
0x00482RTC_IRQHandler()RTC through EXTI17/19/20 line and LSE CSS through EXTI 19 line
0x004C3FLASH_IRQHandler()Flash memory and data EEPROM
0x00504RCC_IRQHandler()RCC and CRS
0x00545EXTI0_1_IRQHandler()EXTI Line0 and 1
0x00586EXTI2_3_IRQHandler()EXTI Line2 and 3
0x005C7EXTI4_15_IRQHandler()EXTI Line4 to 15
0x00608TSC_IRQHandler()Touch sense controller
0x00649DMA1_Channel1_IRQHandler()DMA1 Channel1
0x006810DMA1_Channel2_3_IRQHandler()DMA1 Channel2 and 3
0x006C11DMA1_Channel4_7_IRQHandler()DMA1 Channel4 to 7
0x007012ADC_COMP_IRQHandler()ADC and comparator through EXTI21 and 2
0x007413LPTIM1_IRQHandler()LPTIMER1 through EXTI2
0x007814USART4_USART5_IRQHandler()USART4/USART5
0x007C15TIM2_IRQHandler()TIMER2
0x008016TIM3_IRQHandler()TIMER3
0x008417TIM6_DAC_IRQHandler()TIMER6 and DAC
0x008818TIM7_IRQHandler()TIMER7
0x008C19reserved
0x009020TIM21_IRQHandler()TIMER21
0x009421I2C3_IRQHandler()I2C3
0x009822TIM22_IRQHandler()TIMER22
0x009C23I2C1_IRQHandler()I2C1 through EXTI23
0x00A024I2C2_IRQHandler()I2C2
0x00A425SPI1_IRQHandler()SPI1
0x00A826SPI2_IRQHandler()SPI2
0x00AC27USART1_IRQHandler()USART1 through EXTI25
0x00B028USART2_IRQHandler()USART2 through EXTI26
0x00B429AES_RNG_LPUART1_IRQHandler()LPUART1 through EXTI28 + AES + RNG
0x00B830LCD_IRQHandler()LCD
0x00BC31USB_IRQHandler()USB event through EXTI18
Über das SCB->VTOR Register kann man den Ort der Liste verändern um sie z.B. ins RAM zu verschieben.

Interrupt Controller

Der Interrupt-Controller NVIC steuert die Verarbeitung von Unterbrechungs-Signalen. Er ist Bestandteil des ARM Kerns.

Solche Signale werden von interner oder externer Hardware ausgelöst, wenn bestimmte Ereignisse auftreten. Sie können dazu genutzt werden, das laufende Programm vorübergehend zu unterbrechen und stattdessen eine besondere Funktion auszuführen, die Interrupt-Handler oder Interrupt-Service-Routine (ISR) genannt wird.

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

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

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);
... do some work ...
__set_PRIMASK(backup);

Normale Unterbrechungen sind durch Pegel gesteuert. Wenn das Signal auf High steht, wird der zugeordnete Handler möglichst bald ausgeführt. Während der Interrupt-Handler läuft, muss das Signal wieder auf Low zurück zurück gehen, sonst wird der Interrupt-Handler nach seinem Ende gleich wieder aufgerufen.

Wenn das Signal zu früh verschwindet, während der Interrupt-Controller nach einer Gelegenheit sucht, den Interrupt-Handler auszuführen, geht es verloren. Der Interrupt-Handler wird dann nicht ausgeführt.

Extended Interrupts

Die externen Interrupt-Signale und auch einige interne durchlaufen einen erweiterten Schaltkreis, der zusätzliche Konfiguration erfordert. Man erkennt sie am Stichwort EXTI.

Externe Interrupt-Signale von I/O Pins werden sehr flexibel durch die Register AFIO->EXTICR[0-3] mit den Kanälen des Interrupt-Controllers verbunden. Die internen Unterbrechungen sind hingegen fest einem Kanal zugeordnet.

Interrupt Flanken

Viele erweiterte Unterbrechungen werden durch Flanken (Signalwechsel) ausgelöst. Man erkennt sie an den Bits im Register EXTI->RTSR oder EXTI->FTSR.

Durch die Verwendung von Flanken ist automatisch sicher gestellt, dass der Handler nicht immer wieder erneut ausgeführt wird, falls ein Interrupt Signal für längere Zeit ansteht.

Flanken gesteuerte Interrupts gehen nicht verloren, wenn das Signal schon wieder verschwindet bevor der Handler aufgerufen wurde. Der Interrupt-Controller merkt sich, dass da mal eine Anforderung vorlag, die noch nicht abgearbeitet wurde.

In diesem Zusammenhang ist das Register EXTI->PR wichtig. Dort merkt sich der Interrupt-Controller den Zustand. Während der Initialisierung muss man das Bit zurück setzen, um sicher zu stellen, dass die erste Flanke zuverlässig erkannt wird. Man schreibt eine 1 in das jeweilige Bit, damit es auf 0 zurück gesetzt wird.

Interrupt Masken

Im Register EXTI->IMR werden Unterbrechungen maskiert. Man muss hier eine 1 in das jeweilige Bit schreiben, damit eine Interrupt-Leitung wirksam wird. Standardmäßig sind die meisten Interrupts maskiert, sind also ohne Wirkung.

Das folgende Beispiel löst einen Interrupt aus, wenn das Signal an PC13 von Low nach High wechselt. Beim Nucleo-Board ist PC13 mit dem blauen Taster verbunden.

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

void EXTI4_15_IRQHandler()
{
    // Clear pending interrupt flag
    SET_BIT(EXTI->PR, EXTI_PR_PR13);

    // Toggle LED
    GPIOA->ODR ^= GPIO_ODR_OD5;
}

int main(void)
{
    // Enable clock of I/O features
    SET_BIT(RCC->IOPENR, RCC_IOPENR_GPIOAEN + RCC_IOPENR_GPIOCEN);
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_SYSCFGEN);

    // PA5 = Output for the LED
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE5, GPIO_MODER_MODE5_0);

    // PC13 = Input
    MODIFY_REG(GPIOC->MODER, GPIO_MODER_MODE13, 0);

    // Assign PC13 to EXTI0 with rising edge
    MODIFY_REG(SYSCFG->EXTICR[3], SYSCFG_EXTICR4_EXTI13, SYSCFG_EXTICR4_EXTI13_PC);
    SET_BIT(EXTI->IMR, EXTI_IMR_IM13);
    SET_BIT(EXTI->RTSR, EXTI_RTSR_TR13);
    
     // Enable the interrupt
    NVIC_EnableIRQ(EXTI4_15_IRQn);

    // Clear pending interrupt flag
    SET_BIT(EXTI->PR, EXTI_PR_PR13);

    // Endless loop
    while (1) {}
}

Event Masken

Neben den Unterbrechungen steuert der NVIC auch Ereignisse. Ereignisse verwendet man üblicherweise, um die CPU aus aus einem Wait- oder Sleep- Zustand aufzuwecken. So hält zum Beispiel der Befehl __WFE() die CPU bis zum nächsten Ereignis an. Siehe Absatz Powermanagement.

Standardmäßig sind alle Ereignisse maskiert. Man muss im Register EXTI->EMR das entsprechende Bit auf 1 setzen, um ein EXTI Signal als Ereignis zu behandeln.

Taktgeber

Ich habe ziemlich oft gelesen, dass das komplexe System zur Takterzeugung für Anfänger ein großes Hindernis sei. Das sehe ich anders, denn nach einem Reset wird der Mikrocontroller automatisch mit seinem internen 2,097 MHz R/C Oszillator getaktet. Damit kann man schon eine Menge sinnvoller Programme schreiben.

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->IOPENR, RCC->APB1ENR, RCC->APB2ENR und RCC->AHBENR erledigt wird.

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

Der MSI Oszillator kann auf folgende Frenquenzen umgestellt werden:

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

Mehrere Vorteiler und ein PLL Multiplikator können kombiniert werden, um unterschiedliche Taktfrequenzen zu erreichen. Am besten schaut man sich das mal in CubeMX an. Dort kann man schön sehen, welche Parameter konfigurierbar sind und wie sie zusammen wirken.

Das folgende Bild zeigt die Standardvorgabe vom STM32L073RZ nach einem Reset:

Wenn man den Systemtakt über 16 MHz erhöht, muss man für den Flash Speicher 1 Wait-State einstellen. Wenn die PLL bereits aktiv ist, muss man sie vor dem Umkonfigurieren zuerst deaktivieren.

Beispiel für den STM32L073RZ, 32 MHz mit dem internen HSI16 Oszillator:

// The current clock frequency
uint32_t SystemCoreClock=2097000;

// Change system clock to 32 MHz using internal 16 MHz R/C oscillator
// Called by Assembler startup code
void SystemInit(void)
{
    // Because the debugger switches PLL on, we may
    // need to switch back to the HSI oscillator without PLL

    // Switch to HSI oscillator
    MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_CFGR_SW_HSI);

    // Wait until the switch is done
    while ((RCC->CFGR & RCC_CFGR_SWS_Msk) != RCC_CFGR_SWS_HSI) {}

    // Disable the PLL, then we can configure it
    CLEAR_BIT(RCC->CR, RCC_CR_PLLON);
    
    // Flash latency 1 wait state
    SET_BIT(FLASH->ACR, FLASH_ACR_LATENCY);

    // Enable HSI oscillator
    SET_BIT(RCC->CR, RCC_CR_HSION);

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

    // 32 MHz using the 16 MHz HSI oscillator multiply by 4 divide by 2
    WRITE_REG(RCC->CFGR, RCC_CFGR_PLLSRC_HSI + RCC_CFGR_PLLMUL4 + RCC_CFGR_PLLDIV2);

    // 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=32000000;

    // Switch the MSI oscillator off
    CLEAR_BIT(RCC->CR, RCC_CR_MSION);
}
Die obige Delay Schleife läuft danach allerdings nicht 16x schneller, sondern nur 10x schneller. Der Grund dafür ist, dass der Flash jetzt mit 1 Waitstate betrieben werden muss und der Prefetch-Buffer (der dies ausgleicht) nur direkt aufeinanderfolgende Befehle optimiert. Bei jeden Rücksprung in der Schleife wird der Prefetch-Buffer geleert.

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

Beispiel für den STM32L073RZ, 32 MHz mit einem 8 MHz Quarz (HSE Oszillator):

// The current clock frequency
uint32_t SystemCoreClock=2097000;

// Change system clock to 32 MHz using 8 MHz crystal
// Called by Assembler startup code
void SystemInit(void)
{
    // Because the debugger switches PLL on, we may
    // need to switch back to the HSI oscillator without PLL

    // Switch to HSI oscillator
    MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_CFGR_SW_HSI);

    // Wait until the switch is done
    while ((RCC->CFGR & RCC_CFGR_SWS_Msk) != RCC_CFGR_SWS_HSI) {}

    // Disable the PLL, then we can configure it
    CLEAR_BIT(RCC->CR, RCC_CR_PLLON);
    
    // Flash latency 1 wait state
    SET_BIT(FLASH->ACR, FLASH_ACR_LATENCY);

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

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

    // 32 MHz using the 8 MHz HSE oscillator multiply by 8 divide by 2
    WRITE_REG(RCC->CFGR, RCC_CFGR_PLLSRC_HSE + RCC_CFGR_PLLMUL8 + RCC_CFGR_PLLDIV2);

    // 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=32000000;

    // Switch the MSI oscillator off
    CLEAR_BIT(RCC->CR, RCC_CR_MSION);
}

SysTick Timer

Alle Cortex-M Prozessoren enthalten einen 24bit Timer, mit dem man die Systemzeit misst. Der Timer zählt die Taktimpulse des Prozessors herunter und löst bei jedem Überlauf einen Interrupt aus. Der Funktionsaufruf SysTick_Config(SystemCoreClock/1000) sorgt dafür, dass jede Millisekunde ein SysTick Interrupt ausgelöst wird.

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

// The current clock frequency
uint32_t SystemCoreClock=2097000;

// Counts milliseconds
volatile uint32_t systick_count=0;

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

// Delay some milliseconds.
// Note that effective time may be up to 1ms shorter than requested.
void delay_ms(int ms)
{
    uint32_t start=systick_count;
    while (systick_count-start<ms);
}

int main(void)
{
    // Initialize the timer for 1 ms intervals
    SysTick_Config(SystemCoreClock/1000);
    
    // Delay 2 seconds
    delay_ms(2000);  
    ...
}
Wenn der Prozessor beim Debuggen angehalten wird, hält auch dieser Timer an. Im WFI und WFE Sleep Modus läuft der SysTick Timer weiter.

Digitale Pins

Generell können alle I/O Pins können erst benutzt werden, nachdem man ihre Taktversorgung im Register RCC->IOPENR eingeschaltet hat. Standardmäßig sind fast alle I/O Pins für analoge Eingabe konfiguriert.

Im Register GPIOx->MODER konfiguriert man einen Pin als Eingang, Ausgang oder für alternativen Funktionen (wie z.B. serieller Port oder PWM Timer). Wenn man einen I/O Pin für alternative Funktionen verwendet, muss man außerdem in GPIOx->AFR[0] oder GPIOx->AFR[1] einstellen, welche alternative Funktion das sein soll.

Um Eingänge abzufragen, liest man das jeweilige GPIOx->IDR Register.

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.

Im Register GPIOx->OSPEEDR kann man die maximale Frequenz der Ausgänge auf 400 kHz, 2 MHz, 10 MHz oder 35 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 elektromagnetischer Verträglichkeit soll man hier immer den niedrigsten Wert einstellen, der zur Anwendung passt.

Im Register GPIOx->OTYPER kann man I/O Pins auf den Open-Drain Modus umkonfigurieren und im Register GPIOx->PUPDR kann man optional interne Pull-Up oder Pull-Down Widerstände einschalten.

Schaue Dir die Beschreibung der GPIO Register im Referenzhandbuch an. Die alternativen Funktionen der GPIO Pins sind im Datenblatt des Mikrocontrollers unter dem Stichwort "alternate functions port" tabellarisch beschrieben.

Analoge Eingänge

Alle I/O Pins sind standardmäßig für analoge Eingabe konfguriert. Wenn man sie zwischenzeitlich digtal verwendet hat, stellt man das so zurück:
// Configure PA4 as analog input
MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODER4, GPIO_MODER_MODER4_0 + GPIO_MODER_MODER4_1);

Initialisierung des ADC1 für einzelne Lesezugriffe:

void init_analog()
{
    // Enable clock for ADC
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_ADCEN);

    // Disable the ADC
    if (READ_BIT(ADC1->ISR, ADC_ISR_ADRDY))
    {
        SET_BIT(ADC1->ISR, ADC_ISR_ADRDY);
    }
    if (READ_BIT(ADC1->CR, ADC_CR_ADEN))
    {
        SET_BIT(ADC1->CR, ADC_CR_ADDIS);
    }

    // Wait until ADC is disabled
    while (READ_BIT(ADC1->CR, ADC_CR_ADEN));

    // Enable ADC voltage regulator
    MODIFY_REG(ADC1->CR, ADC_CR_ADVREGEN, 0);
    MODIFY_REG(ADC1->CR, ADC_CR_ADVREGEN, ADC_CR_ADVREGEN);

    // Delay 1-2 ms
    delay_ms(2);

    // Set low frequency mode (required if ADC clock is < 3,5MHz)
    SET_BIT(ADC->CCR,ADC_CCR_LFMEN);

    // ADC Clock = PCLK/2
    MODIFY_REG(ADC1->CFGR2, ADC_CFGR2_CKMODE, ADC_CFGR2_CKMODE_0);

    // Start calibration
    SET_BIT(ADC1->CR, ADC_CR_ADCAL);

    // Wait until the calibration is finished
    while (READ_BIT(ADC1->CR, ADC_CR_ADCAL));

    // Clear the ready flag
    SET_BIT(ADC1->ISR, ADC_ISR_ADRDY);

    // Enable the ADC and wait until is ready
    SET_BIT(ADC1->CR, ADC_CR_ADEN);
    while (!READ_BIT(ADC1->ISR, ADC_ISR_ADRDY));

    // Select software start trigger
    MODIFY_REG(ADC1->CFGR1, ADC_CFGR1_EXTEN, 0);

    // Select single conversion mode
    CLEAR_BIT(ADC1->CFGR1, ADC_CFGR1_CONT);

    // Set sample time to 19.5 cycles
    MODIFY_REG(ADC1->SMPR, ADC_SMPR_SMP, ADC_SMPR_SMP_2);
}

Lesen eines analogen Eingangs von ADC1:

// Read from an analog input of ADC1
uint32_t read_analog(uint32_t channel)
{   
    // Select the channel
    WRITE_REG(ADC1->CHSELR, 1UL<<channel);

    // Clear the finish flag
    CLEAR_BIT(ADC1->ISR, ADC_ISR_EOC);

    // Start a conversion
    SET_BIT(ADC1->CR, ADC_CR_ADSTART);

    // Wait until the conversion is finished
    while (!READ_BIT(ADC1->ISR, ADC_ISR_EOC));
    while (READ_BIT(ADC1->CR, ADC_CR_ADSTART));

    // 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

Die Timer 2 und 3 können jeweils 4 PWM Signale erzeugen. Damit kann man z.B. die Helligkeit von Lampen oder die Drehzahl von Motoren steuern. Die Timer 21 und 21 haben jeweils zwei PWM Kanäle. Der low-power Timer LPTIM hat nur einen PWM Ausgang.

Alle Timer können mit ihren 16bit die Pulsbreite in maximal 65535 Stufen modulieren.

Die Taktfrequenz der Timer wird vom Systemtakt abgeleitet und kann durch den AHB Prescaler, den ABP2 Prescaler (beide im Register RCC->CFGR), sowie dem Timer Prescaler in TIMx->PSC reduziert werden.

Der low-power timer unterstütz als Taktquelle wahlweise LSI, LSE, HSI, HSE und PCKL1 (das ist der Takt vom APB1 Bus).

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

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 einen Ausgang von Timer 2 (PA5), um eine Leuchtdiode unterschiedlich hell flimmern zu lassen:

#include "stm32l0xx.h"

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

int main(void)
{
    // Enable Port A
    SET_BIT(RCC->IOPENR, RCC_IOPENR_GPIOAEN);

    // PA5 = TIM2_CH1 alternate function 5 (see data sheet)
    MODIFY_REG(GPIOA->AFR[0], GPIO_AFRL_AFSEL5, 5UL<<GPIO_AFRL_AFSEL5_Pos);
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE5, GPIO_MODER_MODE5_1);

    // Enable timer 2
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_TIM2EN);

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

    // Timer 2 enable channel 1 output
    SET_BIT(TIM2->CCER, TIM_CCER_CC1E);

    // Timer 2 inverse polarity for channel 1
    // SET_BIT(TIM2->CCER, TIM_CCER_CC1P);

    // Timer 2 clock prescaler, the PCLK2 clock is divided by this value +1.
    TIM2->PSC = 2; // divide clock by 3

    // Timer 2 auto reload register, defines the maximum value of the counter in PWM mode.
    TIM2->ARR = 32768; // 2097000/3/32768 = 21 pulses per second

    // Timer 2 enable counter and auto-preload
    SET_BIT(TIM2->CR1, TIM_CR1_CEN + TIM_CR1_ARPE);

    // endless loop
    while(1)
    {
        // Change the brightness of the LED (PA5) in 16 steps
        for (int i=0; i<=15; i++)
        {
            // Timer 2 channel 1 set PWM pulse width
            TIM2->CCR1 = (1<<i);

            delay(500);
        }
    }
}

Ich habe hier absichtlich eine sehr niedrige PWM Frequenz gewählt, damit man das Flackern der LED sehen kann. In einer realen Anwendung würde man natürich eine höhere PWM Frequenz über 100 Hz wählen.

Ich möchte darauf hinweisen, dass die Timer noch viele weitere Funktionen haben, die ich hier gar nicht alle zeigen kann. Mehr Informationen dazu gibt es zum Beispiel in der Application Note AN4776.

USART Schnittstelle

Je nach Taktfrequenz der Peripherie sind unterschiedliche Baudraten möglich:

Mit der Oversampling Option (OVER8=1) sind doppelt so hohe Baudraten möglich.

Die serielle Schnittstelle USART1 liegt auf PA9 (TxD) und PA10 (RxD). Das folgende Beispielprogramm sendet regemäßig "Hello World!" aus. Außerdem sendet es alle empfangenen Zeichen als Echo wieder zurück. Das Senden findet direkt statt (ggf. mit Warteschleife) während der Empfang interrupt-gesteuert stattfindet:

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

uint32_t SystemCoreClock=2097000;

// delay loop for the default 2.1 MHz CPU clock with optimizer enabled
void delay(uint32_t msec)
{
    for (uint32_t j=0; j<419UL*msec; j++)
    {
        __NOP();
    }
}

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

// Called after each received character
void USART1_IRQHandler(void)
{
    // read the received character
    char received=USART1->RDR;

    // send echo back
    while(!(USART1->ISR & USART_ISR_TXE));
    USART1->TDR = received;
}

int main(void)
{
    // Enable clock for Port A
    SET_BIT(RCC->IOPENR, RCC_IOPENR_GPIOAEN);

    // PA5 = Output for the LED
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE5, GPIO_MODER_MODE5_0);

    // Use system clock for USART1
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_USART1EN);
    MODIFY_REG(RCC->CCIPR, RCC_CCIPR_USART1SEL, RCC_CCIPR_USART1SEL_0);

    // PA9 (TxD) shall use the alternate function 4 (see data sheet)
    MODIFY_REG(GPIOA->AFR[1], GPIO_AFRH_AFSEL9, 4UL<<GPIO_AFRH_AFSEL9_Pos);
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE9, GPIO_MODER_MODE9_1);

    // PA10 (RxD) shall use the alternate function 4 (see data sheet)
    MODIFY_REG(GPIOA->AFR[1], GPIO_AFRH_AFSEL10, 4UL<<GPIO_AFRH_AFSEL10_Pos);
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE10, GPIO_MODER_MODE10_1);

    // Set baudrate
    USART1->BRR = (SystemCoreClock / 2400);

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

    // Enable interrupt in NVIC
    NVIC_EnableIRQ(USART1_IRQn);

    while (1)
    {
        // LED on
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BS_5);
        delay(500);

        puts("Hello");

        // LED off
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BR_5);
        delay(500);
    }
}
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.

Jetzt kommt ein Beispiel für die zweite serielle Schnittstelle. Beim Nucleo-64 Board ist USART2 mit dem ST-Link Adapter verbunden, der diese wiederum über USB an einen virtuellen COM Port weiter leitet:

ST-Link CN3STM32F1 USART2Beschreibung
TxDRxD (=PA3)Daten
RxDTxD (=PA2)Daten
GND GNDGemeinsame Masse

Der ST-Link v2.1 unterstützt 600 bis 2000000 Baud.

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

uint32_t SystemCoreClock=2097000;

// delay loop for the default 2.1 MHz CPU clock with optimizer enabled
void delay(uint32_t msec)
{
    for (uint32_t j=0; j<419UL*msec; j++)
    {
        __NOP();
    }
}

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

// Called after each received character
void USART2_IRQHandler(void)
{
    // read the received character
    char received=USART2->RDR;

    // send echo back
    while(!(USART2->ISR & USART_ISR_TXE));
    USART2->TDR = received;
}

int main(void)
{
    // Enable clock for Port A
    SET_BIT(RCC->IOPENR, RCC_IOPENR_GPIOAEN);

    // PA5 = Output for the LED
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE5, GPIO_MODER_MODE5_0);

    // Use system clock for USART2
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_USART2EN);
    MODIFY_REG(RCC->CCIPR, RCC_CCIPR_USART2SEL, RCC_CCIPR_USART2SEL_0);

    // PA2 (TxD) shall use the alternate function 4 (see data sheet)
    MODIFY_REG(GPIOA->AFR[0], GPIO_AFRL_AFSEL2, 4UL<<GPIO_AFRL_AFSEL2_Pos);
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE2, GPIO_MODER_MODE2_1);

    // PA3 (RxD) shall use the alternate function 4 (see data sheet)
    MODIFY_REG(GPIOA->AFR[0], GPIO_AFRL_AFSEL3, 4UL<<GPIO_AFRL_AFSEL3_Pos);
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE3, GPIO_MODER_MODE3_1);

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

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

    // Enable interrupt in NVIC
    NVIC_EnableIRQ(USART2_IRQn);

    while (1)
    {
        // LED on
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BS_5);
        delay(500);

        puts("Hello");

        // LED off
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BR_5);
        delay(500);
    }
}

I²C Bus

Der I²C Bus ist eine beliebte Schnittstelle für die Anbindung von Peripherie über kurze Leitungen, wie Port-Erweiterungen, Sensoren und Batterie-Management. Siehe Spezifikation von Philips/NXP.

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 STM32F3 Mikrocontroller haben bis zu drei I²C Busse, alle unterstützen 3,3 V und 5 V Pegel, aber nur wenige Slaves sind so flexibel.

Bevor man einen I²C Anschluss benutzen kann, muss bei den betroffenen Pins (SDA und SCL) die alternative Funktion im GPIOx->AFR und GPIOx->MODER einstellen. Außerdem muss der Pin im GPIOx->OTYPER Register auf Open-Drain Modus eingestellt werden.

Vermutlich wird die Schnittstelle genau wie beim STM32F303 programmiert, mit Ausnahme der Taktversorgung. Ich habe das allerdings noch nicht ausprobiert.

USB Schnittstelle

Die USB Schnittstelle erfordert ein umfangreiches Softwarepaket. Beinahe alle Programmierer binden daher fertige Implementierungen in ihr Programm ein.

Die USB Schnittstelle funktioniert Interrupt-getrieben. Immer wenn die Hardware ein kleines Datenpaket gesendet oder empfangen hat, löst sie einen Interrupt aus. Der Interrupthandler hat die Aufgabe, Anfragen des Host zu beantworten und Nutzdaten mit dem Pufferspeicher auszutauschen. Wenn man den Mikrocontroller beim Debuggen anhält, fällt die USB Schnittstelle sofort aus.

Der Takt für die USB Schnittstelle wird normalerweise vom HSI48 Oszillator bezogen, der sich selbst kalibriert. Es ist kein Quarz nötig. Der APB Bus muss mit mindestens 10 MHz getaktet werden.

Die USB Buchse wird mit PA11 (D-) und PA12 (D+) verbunden. Es ist nicht nötig, den Modus (in, out, alternative) und Typ dieser Pins zu konfigurieren.

Der Chip hat einen internen 1,5k Ω Pull-Up Widerstand an D+, der im Register USB->BCDR Bit 15 (DPPU) eingeschaltet wird. Indem man den Pull-Up Widerstand aus und wieder ein schaltet, kann man den Host Computer dazu bringen, das USB Gerät erneut zu erkennen, ohne das Kabel abstecken zu müssen.

Virtueller COM-Port mit Cube HAL

Auf der Webseite von STM gibt es den "STM32 Virtual COM Port Driver" zum Herunterladen, aber den braucht man gar nicht, da alle aktuellen Betriebssysteme den CDC Standardtreiber bereits enthalten.

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

Probiere das Programm zunächst ohne Änderungen aus. Der PC sollte im Gerätemanager einen neuen virtuellen COM Anschluss mit dem Namen "Serielles USB-Gerät (COMx)" oder "STMicroelectronics Virtual COM Port (COMx)" anzeigen.

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_SET);
        HAL_Delay(500);

        // LED Off
        HAL_GPIO_WritePin(LED_GPIO_Port,LED_Pin,GPIO_PIN_RESET);
        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 (Linux / Windows) und öffne den virtuellen COM-Port. Die Baudrate spielt keine Rolle. Du empfängst jetzt jede Sekunde den Text "Hallo!".

Das Programm belegt etwa 13 kB Flash und 4,5 kB RAM.

Damit die Ausgabefunktionen der Standard C Library (z.B. printf, puts, putchar) 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

Der Benutzer W.S. hat im mikrocontroller.net Forum eine USB CDC Implementierung zur freien Verwendung veröffentlicht, die ebenfalls ohne Treiberinstallation funktioniert. Der Quelltext ist sehr kompakt - nur zwei Dateien ohne weitere Anhängigkeiten. Ich habe diesen Code für das Nucleo-L073RZ Board angepasst und in ein Projekt für die System Workbench eingebaut. Das "Atollic TrueStudio" und die "STM32 Cube IDE" können es importieren.

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

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

// The current clock frequency
uint32_t SystemCoreClock=2097000;

// Counts milliseconds
volatile uint32_t systick_count=0;

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

// Delay some milliseconds
// Note that effective time may be up to 1ms shorter than requested.
void delay_ms(int ms)
{
    uint32_t start=systick_count;
    while (systick_count-start<ms);
}

// Change system clock to 32 MHz using internal 16 MHz R/C oscillator
// Called by Assembler startup code
void SystemInit(void)
{
    // Because the debugger switches PLL on, we may
    // need to switch back to the HSI oscillator without PLL

    // Switch to HSI oscillator
    MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_CFGR_SW_HSI);

    // Wait until the switch is done
    while ((RCC->CFGR & RCC_CFGR_SWS_Msk) != RCC_CFGR_SWS_HSI) {}

    // Disable the PLL, then we can configure it
    CLEAR_BIT(RCC->CR, RCC_CR_PLLON);
    
    // Flash latency 1 wait state
    SET_BIT(FLASH->ACR, FLASH_ACR_LATENCY);

    // Enable HSI oscillator
    SET_BIT(RCC->CR, RCC_CR_HSION);

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

    // 32 MHz using the 16 MHz HSI oscillator multiply by 4 divide by 2
    WRITE_REG(RCC->CFGR, RCC_CFGR_PLLSRC_HSI + RCC_CFGR_PLLMUL4 + RCC_CFGR_PLLDIV2);

    // Switch the PLL on and wait until it is ready
    SET_BIT(RCC->CR, RCC_CR_PLLON);
    while(!READ_BIT(RCC->CR, RCC_CR_PLLRDY)) {}

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

    // Update variable
    SystemCoreClock=32000000;

    // Switch the MSI oscillator off
    CLEAR_BIT(RCC->CR, RCC_CR_MSION);

    // Switch the reference for the HSI48 oscillator on and wait until it is ready
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_SYSCFGEN);
    SET_BIT(SYSCFG->CFGR3, SYSCFG_CFGR3_ENREF_HSI48);
    while(!READ_BIT(SYSCFG->CFGR3, SYSCFG_CFGR3_VREFINT_RDYF)) {}

    // Switch the HSI48 oscillator on and wait until it is ready
    SET_BIT(RCC->CRRCR, RCC_CRRCR_HSI48ON);
    while(!READ_BIT(RCC->CRRCR, RCC_CRRCR_HSI48RDY)) {}

    // Select the HSI48 oscillator as clock source for USB
    SET_BIT(RCC->CCIPR, RCC_CCIPR_HSI48SEL);
}

void init_io()
{
    // Enable Port A
    SET_BIT(RCC->IOPENR, RCC_IOPENR_GPIOAEN);

    // PA5 = Output
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE5, GPIO_MODER_MODE5_0);

    // Enable USB with pull-up
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_USBEN);
    SET_BIT(USB->BCDR, USB_BCDR_DPPU);
}

// 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)
{
    // Initialize system timer
    SysTick_Config(SystemCoreClock/1000);

    init_io();
    UsbSetup();

    while (1)
    {
        // LED On (High)
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BS_5);
        delay_ms(100);

        puts("Hello World!");

        // LED Off (Low)
        WRITE_REG(GPIOA->BSRR, GPIO_BSRR_BR_5);
        delay_ms(1000);
    }
}

Die Ausgabe kann man mit einem Terminal-Programm anzeigen oder unter Linux mit dem Befehl: cat /dev/ttyACM0.

Nach der Initialisierung mittels UsbSetup() wird die Funktion UsbCharOut() benutzt, um einzelne Zeichen zu senden. UsbSetup setzt voraus, dass der Systemtakt bereits korrekt konfiguriert ist. Die entsprechenden Zeilen habe ich oben fett hervorgehoben.

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.

Echtzeituhr

Die RTC besteht aus einem 32 kHz Quarz-Oszillator und einer Reihe verketteter Zähler, um auf Sekunden, Minuten, Stunden, Tage, Monate und Jahre zu kommen. Der Oszillator von der RTC läuft schon ohne Kalibrierung wesentlich geauer, als der Haupt-Quarz.

Zwei Alarm-Zeiten sind programmierbar und die Uhr kann sich den Zeitstempel von einem Ereignis merken.

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 5 so genannte Backup Register (mit je 32bit Breite) wo man an Daten ablegen kann.

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.

Die Application Note AN4759 beschreibt, wie man die RTC benutzt. Wenn der Systemtakt geringer ist als 230 kHz, dann muss man die Verwendung der Schatten-Register deaktivieren. Ich den folgenden Beispielen gehe ich davon aus, dass der Systemtak hoch genug ist.

RTC starten

Nach einem Stromausfall ist die Uhr zunächst gestoppt. Man kann sie per Software so starten:
void initRtc()
{
    // Enable the power interface
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_PWREN);

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

    // Enable LSE oscillator with medium driver power
    MODIFY_REG(RCC->CSR, RCC_CSR_LSEDRV, RCC_CSR_LSEDRV_1);
    SET_BIT(RCC->CSR, RCC_CSR_LSEON);

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

    // Select LSE as clock source for the RTC
    MODIFY_REG(RCC->CSR, RCC_CSR_RTCSEL, RCC_CSR_RTCSEL_LSE);

    // Enable the RTC
    SET_BIT(RCC->CSR, RCC_CSR_RTCEN);
}

Aufwachen

Nachdem die RTC gestartet ist, kann man sie benutzen, um regelmäßige Unterbrechungen zu erzeugen. Diese wiederum können verwendet werden, um den Mikrocontroller aus Sleep, Stop und Standby Zuständen auf zu wecken.

Das folgende ausführbare Beispiel zeigt, wie man damit die LED auf dem Nucleo-L073RZ Board im Sekundentakt blinken lässt:

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

uint32_t SystemCoreClock=2097000;

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

void init_io()
{
    // Enable Port A
    SET_BIT(RCC->IOPENR, RCC_IOPENR_GPIOAEN);

    // PA5 = Output for the LED
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE5,  GPIO_MODER_MODE5_0);

    // PA2 (TxD) shall use the alternate function 4 (see data sheet)
    MODIFY_REG(GPIOA->AFR[0], GPIO_AFRL_AFSEL2, 4U<<GPIO_AFRL_AFSEL2_Pos);
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODE2, GPIO_MODER_MODE2_1);
}

void initSerial()
{
    // Use system clock for USART2
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_USART2EN);
    MODIFY_REG(RCC->CCIPR, RCC_CCIPR_USART2SEL, RCC_CCIPR_USART2SEL_0);

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

    // Enable transmitter of USART2
    USART2->CR1 = USART_CR1_UE + USART_CR1_TE + USART_CR1_RE + USART_CR1_RXNEIE;
}

void initRtc()
{
    // Enable the power interface
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_PWREN);

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

    // Enable LSE oscillator with medium driver power
    MODIFY_REG(RCC->CSR, RCC_CSR_LSEDRV, RCC_CSR_LSEDRV_1);
    SET_BIT(RCC->CSR, RCC_CSR_LSEON);

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

    // Select LSE as clock source for the RTC
    MODIFY_REG(RCC->CSR, RCC_CSR_RTCSEL, RCC_CSR_RTCSEL_LSE);

    // Enable the RTC
    SET_BIT(RCC->CSR, RCC_CSR_RTCEN);
}

void initWakeup()
{
    // Unlock the write protection
    WRITE_REG(RTC->WPR, 0xCA);
    WRITE_REG(RTC->WPR, 0x53);

    // Stop the wakeup timer to allow configuration update
    CLEAR_BIT(RTC->CR, RTC_CR_WUTE);

    // Wait until the wakeup timer is ready for configuration update
    while (!READ_BIT(RTC->ISR, RTC_ISR_WUTWF)) {};

    // Clock source of the wakeup timer is 1 Hz
    MODIFY_REG(RTC->CR, RTC_CR_WUCKSEL, RTC_CR_WUCKSEL_2);

    // The wakeup period is 0+1 clock pulses
    WRITE_REG(RTC->WUTR,0);

    // Enable the wakeup timer with interrupts
    SET_BIT(RTC->CR, RTC_CR_WUTE + RTC_CR_WUTIE);

    // Switch the write protection back on
    WRITE_REG(RTC->WPR, 0xFF);

    // Enable EXTI20 interrupt on rising edge
    SET_BIT(EXTI->IMR, EXTI_IMR_IM20);
    SET_BIT(EXTI->RTSR, EXTI_RTSR_TR20);
    NVIC_EnableIRQ(RTC_IRQn);

    // Clear (old) pending interrupt flag
    CLEAR_BIT(RTC->ISR, RTC_ISR_WUTF);  // Clear in RTC
    SET_BIT(EXTI->PR, EXTI_PR_PR20);    // Clear in NVIC
}

void RTC_IRQHandler(void)
{
    // Clear interrupt flag
    CLEAR_BIT(RTC->ISR, RTC_ISR_WUTF);  // Clear in RTC
    SET_BIT(EXTI->PR, EXTI_PR_PR20);    // Clear in NVIC

    // Toggle LED
    GPIOA->ODR ^= GPIO_ODR_OD5;
}


int main(void)
{
    init_io();
    initRtc();
    initWakeup();
    initSerial();
    while(1)
    {
        puts("Hello");

        // Enter sleep mode
        __WFI(); 
    }
}  

Achtung: Der Name des Interrupt-Handlers und die Kanal Nummer (hier 20) variieren je nach STM32 Modell. Schaue dazu in die Datei startup_stm32.s und in das Referenzhandbuch Tabelle "EXTI lines connections".

Während der Interrupt-Handler die LED blinken lässt, gibt das Hauptprogramm den Text "Hallo" auf dem Seriellen Port aus und legt sich dann schlafen. Das Interrupt-Signal der RTC weckt die CPU im Sekundentakt wieder auf.

RTC Lesen

Man kann die Uhrzeit und das Datum direkt aus den entsprechenden Registern auslesen. Die Hardware verwendet dabei Schatten-Register, die automatisch mit der langsamen RTC synchronisiert werden.

Das folgende Beispiel baut auf dem vorherigen Beispiel auf:

int main(void)
{
    init_io();
    initRtc();
    initWakeup();
    initSerial();
    while(1)
    {
        // Extract digits from the RTC time register
        uint8_t ht=  (RTC->TR & RTC_TR_HT)  >> RTC_TR_HT_Pos;
        uint8_t hu=  (RTC->TR & RTC_TR_HU)  >> RTC_TR_HU_Pos;
        uint8_t mnt= (RTC->TR & RTC_TR_MNT) >> RTC_TR_MNT_Pos;
        uint8_t mnu= (RTC->TR & RTC_TR_MNU) >> RTC_TR_MNU_Pos;
        uint8_t st=  (RTC->TR & RTC_TR_ST)  >> RTC_TR_ST_Pos;
        uint8_t su=  (RTC->TR & RTC_TR_SU)  >> RTC_TR_SU_Pos;

        // Print the time
        printf("Time: %d%d:%d%d:%d%d\n", ht,hu, mnt,mnu, st,su);

        // Extract digits from the RTC date register
        uint8_t yt= (RTC->DR & RTC_DR_YT) >> RTC_DR_YT_Pos;
        uint8_t yu= (RTC->DR & RTC_DR_YU) >> RTC_DR_YU_Pos;
        uint8_t mt= (RTC->DR & RTC_DR_MT) >> RTC_DR_MT_Pos;
        uint8_t mu= (RTC->DR & RTC_DR_MU) >> RTC_DR_MU_Pos;
        uint8_t dt= (RTC->DR & RTC_DR_DT) >> RTC_DR_DT_Pos;
        uint8_t du= (RTC->DR & RTC_DR_DU) >> RTC_DR_DU_Pos;

        // Print the date
        printf("Date: %d%d-%d%d-%d%d\n", yt,yu, mt,mu, dt,du);

        // Enter sleep mode
        __WFI();
    }
}

Im Control Register RTC->CR kann man die Anzeige der Zeit beeinflussen:

RTC Beschreiben

Datum, Uhrzeit und einige Bits im Control Register sind ziemlich gut gegen versehentliche Änderungen geschützt. Sie lassen sich nur im sogenannten Initialisierungs-Modus beschreiben, wenn der Schreibgeschutz aufgehoben wurde.

Man darf die reservierten Bits nicht verändern. Außerdem muss man nach jedem Schreibzugriff eine Synchronisation der Schatten-Register auslösen und abwarten. Deswegen ist es gut alle Bits im RTC->TR bzw. RTC->DR Register gleichzeitig zu setzen.

Die folgende Prozedur ändert Datum und Uhrzeit unter Berücksichtigung der obigen Aspekte:

/**
 * Write digits to the RTC time register in 24h format.
 * @param ht tens of hour
 * @param hu ones of hours
 * @param mnt tens of minutes
 * @param mnu ones of minutes
 * @param st tens of seconds
 * @param su ones of seconds
 */
void RTC_write_time(uint8_t ht, uint8_t hu, uint8_t mnt, uint8_t mnu, uint8_t st, uint8_t su)
{
    // Calculate the new value for the time register
    uint32_t tmp=READ_REG(RTC->TR);
    tmp &= ~(RTC_TR_HT+RTC_TR_HU+RTC_TR_MNT+RTC_TR_MNU+RTC_TR_ST+RTC_TR_SU+RTC_TR_PM); // Keep only the reserved bits
    tmp += (uint32_t) ht << RTC_TR_HT_Pos;
    tmp += (uint32_t) hu << RTC_TR_HU_Pos;
    tmp += (uint32_t) mnt << RTC_TR_MNT_Pos;
    tmp += (uint32_t) mnu << RTC_TR_MNU_Pos;
    tmp += (uint32_t) st << RTC_TR_ST_Pos;
    tmp += (uint32_t) su << RTC_TR_SU_Pos;

    // Unlock the write protection
    WRITE_REG(RTC->WPR, 0xCA);
    WRITE_REG(RTC->WPR, 0x53);

    // Enter initialization mode
    SET_BIT(RTC->ISR, RTC_ISR_INIT);

    // Wait until the initialization mode is active
    while (!READ_BIT(RTC->ISR, RTC_ISR_INITF)) {};

    // The 24h format is already the default
    // CLEAR_BIT(RTC->CR, RTC_CR_FMT);

    // Update the time register
    WRITE_REG(RTC->TR,tmp);

    // Leave the initialization mode
    CLEAR_BIT(RTC->ISR, RTC_ISR_INIT);

    // Trigger a synchronization of the shadow registers
    CLEAR_BIT(RTC->ISR, RTC_ISR_RSF);

    // Wait until the shadow registers are synchronized
    while (!READ_BIT(RTC->ISR, RTC_ISR_RSF)) {};

    // Switch the write protection back on
    WRITE_REG(RTC->WPR, 0xFF);
}

/**
 * Write digits to the RTC date register.
 * @param yt tens of year
 * @param yu ones of year
 * @param mt tens of month
 * @param mu ones of month
 * @param dt tens of day
 * @param du ones of day
 * @param wdu week day (1-7)
 */
void RTC_write_date(uint8_t yt, uint8_t yu, uint8_t mt, uint8_t mu, uint8_t dt, uint8_t du, uint8_t wdu)
{
    // Calculate the new value for the date register
    uint32_t tmp=READ_REG(RTC->DR);
    tmp &= ~(RTC_DR_YT+RTC_DR_YU+RTC_DR_MT+RTC_DR_MU+RTC_DR_DT+RTC_DR_DU+RTC_DR_WDU); // Keep only the reserved bits
    tmp += (uint32_t) yt << RTC_DR_YT_Pos;
    tmp += (uint32_t) yu << RTC_DR_YU_Pos;
    tmp += (uint32_t) mt << RTC_DR_MT_Pos;
    tmp += (uint32_t) mu << RTC_DR_MU_Pos;
    tmp += (uint32_t) dt << RTC_DR_DT_Pos;
    tmp += (uint32_t) du << RTC_DR_DU_Pos;
    tmp += (uint32_t) wdu << RTC_DR_WDU_Pos;

    // Unlock the write protection
    WRITE_REG(RTC->WPR, 0xCA);
    WRITE_REG(RTC->WPR, 0x53);

    // Enter initialization mode
    SET_BIT(RTC->ISR, RTC_ISR_INIT);

    // Wait until the initialization mode is active
    while (!READ_BIT(RTC->ISR, RTC_ISR_INITF)) {};

    // Update the time register
    WRITE_REG(RTC->DR,tmp);

    // Leave the initialization mode
    CLEAR_BIT(RTC->ISR, RTC_ISR_INIT);

    // Trigger a synchronization of the shadow registers
    CLEAR_BIT(RTC->ISR, RTC_ISR_RSF);

    // Wait until the shadow registers are synchronized
    while (!READ_BIT(RTC->ISR, RTC_ISR_RSF)) {};

    // Switch the write protection back on
    WRITE_REG(RTC->WPR, 0xFF);
}


int main(void)
{
    initRtc();
    ...

    // Change the time to 18:33:45
    RTC_write_time(1,8, 3,3, 4,5);

    // Change the date to 19-03-25 (25th March 2019), 1=monday
    RTC_write_date(1,9, 0,3, 2,5, 1);

    ...
}

RTC kalibrieren

Die RTC erreicht normalerweise ohne Kalibrierung eine Abweichung von maximal zwei Sekunden pro Tag. Durch Kalibrierung kann man die Genauigkeit weiter verbessern. Sollte deine Uhr ohne Kalibrierung um mehr als 5 Sekunden pro Tag abweichen, liegt mit Sicherheit ein Hardwarefehler vor.

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.

Das RTC->CALR Register kann erst nach Deaktivierung des Schreibschutzes verändert werden. Wenn die Uhr zu langsam läuft, setzt man das Bit CALP, um die Uhr genau 42,206 Sekunden pro Tag zu beschleunigen. Dann reduziert man ihre Geschwindigkeit durch den Wert in den CALM Bits. Jede Stufe dort entspricht 0,0824 Sekunden pro Tag.

Wenn die Uhr zum Beispiel 4 Sekunden pro Tag zu langsam wäre, ergäbe sich folgende Rechnung:

Abweichung:                  4,000 Sekunden
CALP:                      -42,206 Sekunden    (setze RTC->CALR.CALP auf 1)
CALM:     464 * 0,0824 =   +38,234 Sekunden    (setze RTC->CALR.CALM auf 464)
===========================================
Summe:                      +0,028 Sekunden
Es bleibt eine Ungenauigkeit von +0,028 Sekunden pro Tag übrig.

Power Management

Indem man Taktsignale für I/O Funktionen deaktiviert oder verlangsamt, spart man bereits eine Menge Strom. Darüber hinaus gibt es die folgenden besondere Zustände für den ARM Kern:

ModusEintrittAufwachenBeschreibung
Low-power runLPSDSR=1 and LPRUN=1LPRUN=0Der interne Spannungsregler spart Strom, Taktfrequenz und Peripheriefunktionen sind eingeschränkt
WFI Sleep__WFI()InterruptWarte auf Interrupt. Nur die CPU wird angehalten.
WFE Sleep__WFE()Interrupt oder EreignisWarte auf Ereignis. Nur die CPU wird angehalten.
StopPDDS=1, LPDS=1, SLEEPDEEP=1 + __WFI() oder __WFE()EXTI Leitung, configuriert im EXTI Register. Taktsignale von HSI/HSE sind deaktiviert. Die I/O Pins, Register und RAM bleiben unverändert. Debugging ist nicht möglich.
StandbyPDDS=1, LPDS=0, SLEEPDEEP=1 + __WFI() oder __WFE()Steigende Flanke an WKUP Pin, RTC Alarm, externer Reset am NRST, IWDG Reset. Taktsignale von HSI/HSE sind deaktiviert. RAM Inhalte gehen verloren. Nur die Backup Register bleiben erhalten. Die I/O Pins werden hochohmig, außer TAMPER, WKUP und NRST. Debugging ist nicht möglich. Zum Aufwachen muss der Controller neu starten.

Die beiden Sleep Modi unterstützen eine Low-power Variante wenn LPSDSR=1 gesetzt ist. Der interne Spannungsregler spart dann Strom und der Takt vom Flash Speicher wird zusätzlich angehalten.

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 SCB->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 SCB->SCR Register das Bit 4 (SEVONPEND) gesetzt ist, löst ein anstehender Interrupt zugleich ein Ereignis aus, selbst wenn der Interrupt nicht freigeschaltet ist.