STM32 F103 - Ersteinrichtung

Genau wie der ATmega 328P des Arduino ist der STM32F103 (ganz genau STM32F103C8T6) ein Mikrocontroller. Nur kann er mehr, ist schneller und kostet dabei auch noch weniger.

Allerdings verfügt er nicht über einen seriellen UART Chip wie den CH304, sondern muss zum Programmieren über einen extra seriellen Adapter (auch FTDI-Adapter) angeschlossen werden. Der ist aber nicht teuer und man braucht nur einen FTDI-Adapter für alle seine Blue Pills, wie unser STM32-Entwicklungsboard auch genannt wird. Und das nur zum Programmieren, zum Ausführen wird der Adapter dann nicht mehr benötigt (es sei denn für Ausgaben über die serielle Schnittstelle zur Arduino-IDE).

Außer mittels einem seriellen FTDI-Adapter gibt es noch zwei weitere Möglichkeiten, eine Blue Pill zu programmieren, doch dazu an einer späteren Stelle mehr.


Die Blue Pill läuft mit 3.3V statt 5V wie beim Arduino, verträgt aber dennoch an vielen Pins auch 5V. Auch der Formfaktor ist ein anderer als beim Arduino Uno und eher vergleichbar mit einem Arduino Nano. Die Vorteile gegenüber dem Ardunio Uno / Nano sind:

Anschluss an den PC zur Programmierung


Wie bereits erwähnt, ist kein UART-Chip auf der Blue Pill vorhanden. Darum ist für das Hochladen von Programmen und die serielle Kommunikation ein zusätzliches kleines Board nötig, ein sogenannter UART-USB-to-TTL-Adapter.

Am besten baut man den STM32 auf einem großen Breadboard mit 830 Kontakten auf und benutzt ein wenig Klebeknete, um den Adapter daneben zu befestigen. Dann kann man Adapter und Blue Pill mit ein paar Jumper Kabeln female/male miteinander verbinden.



Es wird folgendermaßen angeschlossen: FTDI-Adapter Blue Pill GND GND VCC 3.3 RX A9 TX A10 den FTDI-Adapter auf 3.3V jumpern!
In den Ser.-Adapter wird ein Mini-USB-Kabel eingesteckt und so mit Strom versorgt. Die Blue Pill wird über GND / VCC gleich mitversorgt. Später, wenn die Programmierung abgeschlossen ist, können wir Blue Pill und Adapter wieder trennen und den STM32 über seine eigene USB-Buchse betreiben. Oder auch an einem 3.6V Akku betreiben.

Ich sollte vielleicht noch erwähnen, dass man einen ST-Link statt eines Serial-Adapter zum Flashen des STM32 benutzen kann. Das habe ich in dem verlinkten Artikel beschrieben. Mit einem ST Link geht das Flashen schneller und mit einfacherer Verkabelung.

Der Supertrick allerdings ist, den STM32dunio-Bootloader auf die Blue Pill zu flashen, um den STM32 direkt per USB zu programmieren. Wie man das anstellt, habe ich ebenfalls (im verlinkten Artikel) beschrieben. Dabei wird die Firmware des STM32 so überschrieben, dass er über seinen USB-Port einen seriellen Adapter emuliert. Ergebnis: Die BluePill lässt sich am USB-Port flashen wie ein Arduino Uno. Um den Bootloader zu flashen, braucht man allerdings einen FTDI-Adapter oder einen ST-Link.

STM32 in die Arduino IDE integrieren


Mit der Arduino IDE haben wir inzwischen Arduino UNO, Nano und Mini Pro, ESP8266 und Digispark Boards programmiert. Es ist unsere Schalt- und Waltzentrale rund um die Mikrocontrollerprogrammierung geworden. Da wäre es doch schön, wenn wir unsere lieb gewonnene Entwicklungsumgebung auch für das neue STM32-Board benutzen könnten.

Und das geht tatsächlich, sogar mit wenig Aufwand. Zuerst müssen wir in der Arduino IDE unter Voreinstellungen die neue Boardverwalter-URL http://dan.drown.org/stm32duino/package_STM32duino_index.json eintragen.


Im Boardverwalter finden wir nun auch einen Eintrag STM32F1xx / GD32F1xx boards by stm32duino. Diese wählen wir uns und installieren ihn.

Danach finden wir unter Werkzeuge / Board unser Board, das Generic STM32F103C series. Wir wählen die Version mit 64 kB Flash (die der STM32F103C8 normalerweise hat), 72 MHz und als Upload Methode serial.


Sketch hochladen

Die Blue Pill kennt zwei Modi: einen Programmiermodus und einen Run-Modus. Diese werden durch den oberen gelben Jumper auf dem Blue-Pill-Board umgeschaltet. Der untere gelbe Jumper bleibt unverändert. Diesen kann man für eigenen Projekte benutzen. Ob der obere Jumper nun links steht oder ganz abgezogen ist, bleibt sich gleich. Es empfiehlt sich, ihn links hinzustecken, damit er nicht verloren geht.

Zum Programmieren wird der obere Jumper nach rechts auf 1 gesetzt. Danach wird ein Reset ausgeführt mit dem kleinen Taster unter dem gelben Jumper-Block.

Dann können wir unseren Sketch über die Arduino IDE hochladen. Ich habe hier einen ganz simplen Blink-Sketch genommen. Als Upload Methode habe ich Serial gewählt.

Hochladen abgeschlossen. Build-Optionen wurden verändert, alles wird neu kompiliert Archiving built core (caching) in: C:\Users\xxx\AppData\Local\Temp\arduino_cache_527380\core\core_stm32duino_STM32F1_genericSTM32F103C_device_variant_STM32F103C8, upload_method_serialMethod,cpu_speed_speed_72mhz,opt_osstd_38ccba3fbc4fc91e6d8ed755348a1d80.a Der Sketch verwendet 12668 Bytes (19%) des Programmspeicherplatzes. Das Maximum sind 65536 Bytes. Globale Variablen verwenden 2456 Bytes (11%) des dynamischen Speichers, 18024 Bytes für lokale Variablen verbleiben. Das Maximum sind 20480 Bytes. stm32flash 0.4 http://stm32flash.googlecode.com/ Using Parser : Raw BINARY Interface serial_w32: 115200 8E1 Version : 0x22 Option 1 : 0x00 Option 2 : 0x00 Device ID : 0x0410 (Medium-density) - RAM : 20KiB (512b reserved by bootloader) - Flash : 128KiB (sector size: 4x1024) - Option RAM : 16b - System RAM : 2KiB Write to memory Erasing memory Wrote address 0x08000100 (2.02%) Wrote address 0x08000200 (4.04%) Wrote address 0x08000300 (6.06%) ... Wrote address 0x08003000 (97.00%) Wrote address 0x08003100 (99.02%) Wrote address 0x0800317c (100.00%) Done. Starting execution at address 0x08000000... done. Der Uploader zeigt mir an, dass meine Blue Pill sogar 128 kB Flashspeicher hat. Das stelle ich gleich in meiner IDE bei den Boardparametern ein und freue mich, auch richtige große Programme benutzen zu können, sollte das mal nötig sein.

Nach dem Hochladen springt unsere blaue Pille direkt wieder in den Ausführungs-Modus (Starting execution at address 0x08000000). Das ist praktisch beim Debugging, denn wenn man den Boot0-Jumper auf 1 beibehält, reicht ein Druck auf den Reset-Taster, um die Pille neu zu programmieren. Solange man testet, spart man sich also das ewige Unstecken des Jumpers.

Wenn man die Blue Pill aber normal laufen lassen will und das Programm auch nach einem Reset ausführen will, muss man den oberen Jumper wieder links auf 0 setzen oder entfernen.

Die Blue Pill kann fast genauso programmiert werden wie ein Arduino. Die Sprache und die Funktionen sind im Wesentlich die Gleichen. Dennoch kann es sein, dass die eine oder andere Arduino-Library nicht 100%ig kompatibel ist.

Sollte es mal spezieller werden und haken ist das Wiki und das Forum von stm32duino.com (englisch) gute, erste Anlaufpunkte.

Die umfangreiche Dokumentation zum STM32F1xx in englisch findet sich auf den Seiten von ST.com. Das über 1000 Seiten fassende PDF-Dokument lässt dabei keine Fragen offen.

GPIO / Pinout-Diagramm des STM32




Die Bezeichnung der GPIO-Pins lautet für den STM32 auch etwas anders - aber eigentlich steht auf dem Board schon die richtige Bezeichnung dran. Den weiteren Einsatzzweck bestimmter Pins lässt sich durch einen Blick in die board.h in Erfahrung bringen: #define BOARD_NR_USARTS 3 #define BOARD_USART1_TX_PIN PA9 #define BOARD_USART1_RX_PIN PA10 #define BOARD_USART2_TX_PIN PA2 #define BOARD_USART2_RX_PIN PA3 #define BOARD_USART3_TX_PIN PB10 #define BOARD_USART3_RX_PIN PB11 #define BOARD_NR_SPI 2 #define BOARD_SPI1_NSS_PIN PA4 #define BOARD_SPI1_MOSI_PIN PA7 #define BOARD_SPI1_MISO_PIN PA6 #define BOARD_SPI1_SCK_PIN PA5 #define BOARD_SPI2_NSS_PIN PB12 #define BOARD_SPI2_MOSI_PIN PB15 #define BOARD_SPI2_MISO_PIN PB14 #define BOARD_SPI2_SCK_PIN PB13 #define BOARD_NR_GPIO_PINS 35 #define BOARD_NR_PWM_PINS 12 #define BOARD_NR_ADC_PINS 9 #define BOARD_NR_USED_PINS 4 #define BOARD_JTMS_SWDIO_PIN 22 #define BOARD_JTCK_SWCLK_PIN 21 #define BOARD_JTDI_PIN 20 #define BOARD_JTDO_PIN 19 #define BOARD_NJTRST_PIN 18 #define BOARD_USB_DISC_DEV GPIOB #define BOARD_USB_DISC_BIT 10 // Note this needs to match with the PIN_MAP array in board.cpp enum { PA0, PA1, PA2, PA3, PA4, PA5, PA6, PA7, PA8, PA9, PA10, PA11, PA12, PA13,PA14,PA15, PB0, PB1, PB2, PB3, PB4, PB5, PB6, PB7, PB8, PB9, PB10, PB11, PB12, PB13,PB14,PB15, PC13, PC14,PC15 }; ... Der Pin PB2, der auf manchen Blue Pills herausgeführt ist, ist mit der einen Seite des Reset-Tasters verbunden. Die andere Seite des Reset-Tasters ist mit GND verbunden. Das heißt, wenn der obere gelbe Jumper auf 0 (links) steht, kann man einen Reset durchführen, wenn man PB2 mit GND verbindet. Man kann hier also einen externen Resettaster anschließen zwischen PB2 und GND. Das heißt aber auch, dass man PB2 nicht als GPIO-Pin für Daten benutzen sollte.

Technische Daten der Boards im Vergleich

ATmega 328P (Arduino Uno / Nano)STM32F103C8T6 ("Blue Pill")ESP-12F (ESP8266)
  • 8 bit Microcontroller
  • 5V
  • RISC Befehlssatz mit 131 Befehlen
  • 20 Mhz Takt / 1 MIPS per MHz
  • 32 KiB Flash Programmspeicher
  • 2 KiB SRAM Variablenspeicher
  • 1 KiB EEPROM
  • 10K-100K Flash-Zyklen, Datenerhalt 100 Jahre bei 25°C (20 Jahre bei 85°C)
  • 6 Kanäle analog (A0-A5), 10 Bit AD-Wandler
  • 13 digitale GPIO-Kanäle
  • 2 interruptfähige GPIOs (2 und 3)
  • 7 PWM-fähige GPIOs (Pin 2, 3, 5, 6, 9, 10, 11) 8 Bit
  • unterstützt I2C, SPI, UART, PWM, GPIO
  • Stromverbrauch: 0.1 bis 0.75 µA im Power- Down/Save-Mode, 0.2 mA im Active-Mode
  • 32 bit ARM Cortex M3 µC
  • 3.3V / 5V fest
  • RISC Befehlssatz
  • 72 Mhz Takt
  • 64 | 128 KiB Flash Programmspeicher
  • 20 KiB SRAM Variablenspeicher
  • kein EEPROM, aber Emulation über Flash (2 Bytes pro Byte Verbrauch)
  • 10 analog Pins, 12 Bit AD-Wandler
  • 22 digitale GPIO-Kanäle
  • fast alle GPIOs interruptfähig, 7 Timer, 3 davon 16 Bit
  • 15 PWM-fähige GPIOs (16 Bit)
  • unterstützt I2C, SPI, CAN, PWM, GPIO, USB 2.0
  • Echtzeituhr (RTC) schon on board
  • Stromverbrauch: typ. 2 bis 3.4 µA im Standby, 14 bis 24 µA im Stop-Mode, 14.4 mA im Sleep Mode, 36 mA im Run-Mode; max. 3 bis 30 mA im Sleep Mode, max. 6.8 bis 50 mA im Run-Mode
  • Debug mode: Serial wire debug (SWD) & JTAG interfaces
  • 32 bit Microcontroller
  • 3.3V
  • RISC Befehlssatz
  • 80-160 Mhz Takt
  • 1 MB Flash Programmspeicher
  • 81 KB RAM Variablenspeicher (lt. Arduino IDE)
  • 1 Kanal analog (A0), 10 Bit AD-Wandler
  • 11 digitale GPIO-Kanäle
  • alle GPIOs interruptfähig (bis auf ein paar Ausnahmen)
  • 4 PWM-fähige GPIOs (IO12, IO15, IO14, IO4)
  • unterstützt I2C, SPI, UART, SDIO, IRDA, PWM, GPIO, TCP/IP
  • Stromverbrauch: 0.01/0.9/15 mA im Deep/Light/Modem Sleep Power-Mode, < 1 mW im Standy-Mode, WLAN: 56/140 mA (RX/TX) bei 802.11g
  • WLAN 802.11 b/g/n 2.4 GHz WPA/WPA2 mit SmartLink Android/IOS, FCC zertifiziert