STM32 F103 - Ersteinrichtung

Genau wie der ATmega 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 der STM32 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).


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.


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 abgezpgen 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 }; ...

Technische Daten der Boards im Vergleich

ATmega 328P (Uno / Nano)STM32F103C8 ("Blue Pill")ESP-12F (ESP8266)
  • 8 bit Microcontroller
  • 5V
  • RISC Befehlssatz mit 131 Befehlen
  • 20 Mhz Takt / 1 MIPS per MHz
  • 32 kB Flash Programmspeicher
  • 2 kB SRAM Variablenspeicher
  • 1 kB 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 kB Flash Programmspeicher
  • 20 KB SRAM Variablenspeicher
  • 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