Über den Beitrag

In diesem und dem folgenden Beitrag widme ich mich den Boards auf Basis von STM32-Mikrocontrollern. In diesem ersten Teil gebe ich zunächst einen kurzen Überblick und zeige dann, wie ihr eure Sketche mit der Arduino IDE auf die STM32-Boards hochladet.

Während der Upload bei den offiziellen STM32-Nucleo-Boards und bei den Arduino-Boards in der Regel sehr einfach ist, haben die inoffiziellen Varianten wie der „Blue Pill“ oder der „Black Pill“ so ihre Eigenheiten. Deswegen bekommen diese Boards in diesem Beitrag auch überproportional viel Aufmerksamkeit. Zwar gibt es dazu schon haufenweise Artikel im Netz, aber wenige davon betrachten die STM32-Boards übergreifend. 

Noch eine Anmerkung vorab: Im Beitrag halte ich mich an die Arduino-Konvention, dass das Flashen eines Mikrocontrollers ein Upload ist. Alles eine Frage der Sichtweise – in der ST-Welt ist das ein Download. 

Folgendes erwartet euch:

• STM32-Boards – Übersicht
• Nomenklatur der STM32-Mikrocontroller
• Vorbereitungen
• BluePill-Board-Varianten
• Sketche auf das BluePill-Board hochladen
  • Upload per USB‑zu‑TTL‑Adapter
  • Upload per SWD (Serial Wire Debug)
  • Am einfachsten: Upload per HID-Bootloader über USB 
  • Upload per Maple-DFU-Bootloader
• BlackPill-Varianten
• Sketche auf das BlackPill-Board hochladen
  • Am einfachsten: Upload per DFU über USB
  • Upload per Serial oder SWD
  • Nicht Arduino-kompatibel: WeAct-HID-Bootloader
• Sketche auf Nucleo-Boards hochladen
• Sketche auf das Arduino GIGA R1 WiFi Bord hochladen
• Anhang 1 – Flash Size prüfen

Darauf gehe ich nicht ein: STM32CubeIDE / STM32CubeMX

STM32CubeMX ist ein grafisches Konfigurationstool für STM32-Mikrocontroller, mit dem sich Pins, Peripherie und Taktsysteme einstellen lassen. Es generiert automatisch Initialisierungscode auf Basis der STM32Cube-HAL-Bibliothek. STM32CubeIDE ist eine kostenlose Entwicklungsumgebung von ST, die auf Eclipse basiert. Sie integriert Editor, Compiler, Debugger und STM32CubeMX in einem einzigen Tool. Damit lassen sich STM32-Projekte von der Konfiguration bis zum Debugging vollständig umsetzen.

Ich gehe auf diese Tools in diesem Beitrag nicht ein. Vielleicht mache ich irgendwann einmal einen separaten Beitrag dazu. 

STM32-Boards – Übersicht

„STM“ steht für den Halbleiter-Elektronikhersteller STMicroelectronics (Kurzbezeichnung: „ST“). ST entwickelt und produziert unter anderem 8- und 32-Bit-Mikrocontroller, die auf hunderten unterschiedlichen Boards Anwendung finden. Ich behandele hier ausschließlich eine Auswahl von 32-Bit-Varianten.  

STM32-Mikrocontroller basieren auf der ARM-Architektur. Die ARM-Architektur wurde von der Fa. ARM Ltd. entwickelt. Mikrocontrollerhersteller wie ST verwenden die Architektur als Lizenznehmer. 

ST selbst verbaut seine Mikrocontroller auf den Nucleo-Entwicklungs-Boards, Discovery Kits und Evaluation Boards. Aber auch Arduino hat einige Boards, die auf STM32-MCUs basieren, wie etwa die Portenta-Serie oder das Arduino GIGA R1 WiFi Board. Überdies gibt es viele weitere Elektroniklieferanten, die eigene STM32-Boards im Programm haben, so z. B. Adafruit mit seinem Adafruit STM32F405 Feather Express. 

Die blaue oder die schwarze Pille?

Und dann gibt es da noch die große Gruppe der BluePill- und BlackPill-Boards. Sie sind ausgesprochen günstig, aber nicht eindeutig definiert, da es sich bei den Bezeichnungen nicht um geschützte Markennamen, sondern um von der STM32-Community vergebene Spitznamen handelt.

Unter den Bezeichnungen „BluePill“ und „BlackPill“ erhaltet ihr Boards in unterschiedlichen Ausführungen und mit unterschiedlichen Mikrocontrollern. Ein ganz großes Problem sind dabei die vielen gefälschten STM32-Mikrocontroller. Diese sind zum einen nicht immer eindeutig als Fälschung erkennbar, zum anderen haben sie gelegentlich vom Original abweichende Eigenschaften. Hinzu kommen fehlerhaft bestückte Boards.

Ein paar Beispiele für STM32-Boards

Die folgende Tabelle listet ausgewählte Eigenschaften einiger STM32-Boards auf. Das soll lediglich einen gewissen Eindruck davon geben, in welcher Liga wir hier spielen. 

Nomenklatur der STM32-Mikrocontroller

Bei der Bezeichnung der STM32-Mikrocontroller gibt es gewisse Regeln, allerdings ist die Nomenklatur über das ganze Portfolio hinweg leider nicht konsistent. Das heißt, dass bestimmte Codierungen in unterschiedlichen Serien eine abweichende Bedeutung haben können. Wie auch immer, folgt die Bezeichnung der Mikrocontroller einem gewissen Muster, hier als Beispiel der STM32F103C8T6:

Der erste große Buchstabe bezeichnet den Typen (Type):

• F = Mainstream / Foundation
• G = General Purpose
• H = High Performance
• L / U = Low Power / Ultra Low Power
• W = Wireless

Die sich anschließende Zahl codiert den verwendeten ARM Cortex:

Dann folgt die Produktlinie (Line). So steht F103 beispielsweise für die Performance Line, F100 ist die Value Line. Diese Zahlen codieren nicht direkt technische Eigenschaften. 

Die Anzahl an Pins (No of Pins) ist in der Regel wie folgt definiert: 

Hier die Größe des Flashs (Flash Size):

Bei der Bauform (Package) werdet ihr auf folgende Codierungen stoßen:

Und für die Einsatztemperaturgrenzen (T-Range) gilt:

• 6: -40 bis +85 °C
• 8: -40 bis +105 °C

Aber wie oben schon erwähnt sind die Bezeichnungen nicht durchgängig konsistent. Schaut in das Datenblatt bzw. die Produktbeschreibungen, bevor ihr etwas bestellt! 

Vorbereitungen

Boardpaket installieren

Das Boardpaket, das ich verwende, ist Arduino_Core_STM32 von stm32duino. Ich habe mich dafür entschieden, da es sowohl einige inoffizielle Boards als auch viele Nucleo-Boards unterstützt. Um das aktuelle Release nutzen zu können, müsst ihr zwingendermaßen die Arduino IDE 2.x verwenden oder auf eine ältere Version des Boardpakets (< 2.8.0) zurückgehen.

Zur Installation tragt ihr zunächst die folgende Boardverwalter-URL unter Datei → Einstellungen → „Zusätzliche Boardverwalter-URLs“ ein:

https://github.com/stm32duino/BoardManagerFiles/raw/main/package_stmicroelectronics_index.json

Dann geht ihr in die Boardverwaltung und gebt als Suchbegriff STM32 ein. Ihr findet das Paket unter der Bezeichnung STM32 MCU based Boards. Klickt auf „Installieren“.

Ist euch diese Installationsbeschreibung zu kurz? Dann findet ihr hier eine Anleitung mit Bildern. 

Alternatives Bordpaket STM32F1XX/GD32F1XX

Mit STM32F1XX/GD32F1XX gibt es ein weiteres, recht verbreitetes Boardpaket, das aber mittlerweile in die Jahre gekommen ist. Ihr findet es hier auf GitHub unter der Bezeichnung Arduino_STM32. Wie es die Bezeichnung STM32F1XX/GD32F1XX schon andeutet, unterstützt das Paket nur einen Teil der STM32-Boards, dafür allerdings einige zusätzliche Boards mit Mikrocontrollern von Giga Device. Des Weiteren zeichnet es sich durch schlanken Code und eine breite Community-Unterstützung aus. 

Optional: STMCubeProgrammer installieren

Das kostenlose Programm STMCubeProgrammer könnt ihr hier herunterladen. Es ermöglicht euch unter anderem:

• einen Bootloader zu flashen.
• Informationen über euren STM32-Chip zu bekommen.
• Flash zu lesen und zu beschreiben.
• Schreibschutz einzurichten.
• Bestimmte Einstellungen vorzunehmen, z. B. zum Watchdog.
• Register auszulesen.

Ihr könnt eure STM32-Boards auch ohne dieses Programm nutzen. Ich empfehle es aber, insbesondere wenn ihr viel mit dem BluePill macht. 

BluePill-Board-Varianten

STMF103C8T6- und STM32F103CB-basierte BluePill-Boards

In den meisten Fällen wird es sich bei euren BluePill-Boards um die Version mit dem STMF103C8T6 handeln, der im Original einen Flash von 64 kB besitzen sollte. Daneben gibt es auch eine Version mit 128 kB RAM (F103CBT6). Allerdings haben viele F103C8T6-Chips tatsächlich 128 kB Flash. Wie ihr herausbekommt, wie viel Flash euer Board hat, erfahrt ihr im Anhang. F103C8T6-Chips mit 128 kB können eine Fälschung sein, müssen es aber nicht, da ST aus logistischen Gründen teilweise auch höherwertige Chips verbaut. 

Überdies gibt es noch Varianten mit Mikrocontrollern von Giga Device, wie beispielsweise der GD32F103xx-Familie.

STM32F103C6T6-basierte BluePill-Boards

Der STM32F103C6T6 ist mit 32 kB Flash, 10 kB RAM und weniger Schnittstellen sozusagen der kleine Bruder des STM32F103C8T6. Abgesehen von dem unterschiedlichen Mikroprozessor haben die so bestückten Boards meistens dasselbe Design.

Was bei mir mit diesen Boards nicht funktionierte, war der Sketch-Upload per HID-Bootloader über USB (mehr dazu weiter unten). Ansonsten taten sie das, was sie sollten. Intensiv habe ich diese Boards allerdings nicht getestet.

Bei zwei von vier Bestellungen in unterschiedlichen Shops habe ich anstelle der STM32F103C6T6-Variante kommentarlos den großen Bruder geliefert bekommen.   

BluePill-Boards mit gefälschten Chips

Wie schon erwähnt, sind BluePill-Boards mit gefälschten Chips, insbesondere mit angeblichen STM32F103C8T6-Mikrocontrollern, weit verbreitet. Die meisten Fälschungen funktionieren im Prinzip, es gibt aber Abweichungen im Detail. Z. B. wird von zu hohen Stromverbräuchen berichtet, da einige Fake-Chips Low Power Funktionen ignorieren. Andere wiederum berichten von allgemeiner Instabilität. Auch funktioniert bei vielen Fake-Chips der HID-Bootloader nicht. Weitere Hinweise auf Fakes sind:

• Eine Chip-Beschriftung, die nur aufgedruckt und nicht eingelasert ist. Es sollten Vertiefungen sichtbar sein.
• Offensichtlich falsches ST-Logo.

Ich selbst habe auch eine BluePill-Version erhalten, die laut (nur gedrucktem) Label mit einem STMF103C8T6 bestückt ist, aber sogar einen Flash von 256 kB besitzt. 

Falsch bestückte BluePill-Boards

Dann gibt es noch BluePill-Boards mit einem falschen Pullup-Widerstand für die D+ Leitung des USB-Anschlusses. Ihr findet den Widerstand auf der Rückseite des Boards, gekennzeichnet als R10. Dieser Widerstand sollte eine Größe von 1.5 kΩ (Label: 152) haben, stattdessen findet man wohl auch R10-Widerstände mit 10 kΩ (Label: 103). Mir ist allerdings keiner zwischen die Finger gekommen. Eine Hardwarelösung für die damit verbundenen Probleme findet ihr hier, eine Softwarelösung findet ihr hier. 

Sketche auf das BluePill-Board hochladen

Das BluePill-Board verfügt zwar über einen USB-Anschluss, ist aber ohne weitere Vorkehrungen über diesen nicht programmierbar. Ich zeige euch mehrere Methoden zum Programm-Upload.

Upload per USB‑zu‑TTL‑Adapter

Anschluss

Für diese Methode braucht ihr einen USB-zu-TTL bzw. FTDI-Adapter. Am besten nehmt ihr ein Modell, das sich auf 3.3 Volt umschalten lässt. Verbindet den Adapter wie folgt mit dem BluePill-Board:

A9 ist TXD1, A10 ist RXD1. 

Da die meisten Pins der BluePill-Boards 5V-tolerant sind (als Eingang!), könntet ihr hier auch mit fünf Volt arbeiten. Aber da das nicht für alle Pins gilt und auch nicht für Pins im ADC-Modus, würde ich dazu raten, generell mit 3.3 Volt zu arbeiten, um es nicht irgendwann einmal zu vergessen. 

Einstellungen in der Arduino IDE

In der Arduino IDE stellt ihr unter „Werkzeuge“ das Board ein: „STM32 MCU based boards“ → „Generic STM32F1 series“. Dann stellt ihr unter „Board part number“ die richtige Version ein:

Wählt den Port, an dem euer USB‑zu‑TTL‑Adapter hängt, und stellt Folgendes als „Upload Method“ ein: 

• Upload method: STM32CubeProgrammer (Serial)

Wenn ihr den seriellen Monitor nutzen wollt, dann gibt es zwei Möglichkeiten: 

1. U(S)ART support: Enabled (generic ‚Serial‘). 
   • Serieller Monitor ist über den USB‑zu‑TTL‑Adapter verbunden.
2. USB support (if available): „CDC (generic ‚Serial‘ supersede U(S)ART)“
   • Serieller Monitor ist über den USB-Anschluss des BluePill-Boards verbunden.
   • Der USB-Anschluss taucht als separater Port auf. 

Wenn ihr 1 und 2 wie oben angegeben einstellt, dann „überstimmt“ Einstellung 2 die Einstellung 1.

Ansonsten lasst ihr die Einstellungen unverändert:

Einstellung auf dem Board

Um Sketche per Serial auf das BluePill-Board zu laden, müsst ihr es in den Programmiermodus versetzen. Dazu setzt ihr den BOOT0-Jumper auf 1 und lasst den BOOT1-Jumper auf 0. Dann drückt die Reset-Taste.

Genauer gesagt führt die o. a. Einstellung in den „System Memory Boot Mode“. Das heißt, dass der Bootvorgang im Systemspeicher startet. Dort hat der STM32F1x-Mikrocontroller einen Hardware-Bootloader.

In der Stellung BOOT0 = 0 befindet sich der STM32F1x im „Main Flash Memory Boot Mode“. Das heißt, dass der Bootvorgang im Flashspeicher startet, wo euer hochgeladenes Programm gespeichert ist. 

Beispielsketch hochladen

Nachdem ihr alle Einstellungen vorgenommen habt, ladet ihr euren ersten Sketch per „Upload-Pfeil“ hoch. Ihr könntet das folgende Beispiel verwenden, um dabei den seriellen Monitor zu testen:

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);                    
  digitalWrite(LED_BUILTIN, LOW); 
  delay(1000);                     
  Serial.println("Hello World");
}

Nach dem Hochladen startet der Sketch direkt. Ein erneuter Reset führt wieder in den Programmiermodus. Um das zu verhindern, setzt ihr den BOOT0-Jumper wieder auf 0.

Upload per SWD (Serial Wire Debug)

Serial Wire Debug ist eine ARM-spezifische Kommunikationsschnittstelle, die auf JTAG (Joint Test Action Group) basiert. Im Gegensatz zu JTAG kommt SWD mit einer Datenleitung (SWDIO) und einer Taktleitung (SW(D)CLK) aus.

Um SWD nutzen zu können, braucht ihr einen ST-LINK oder einen J-Link Programmer (von SEGGER Microcontroller), wobei die J-Link Programmer eher Profigeräte sind. Ansonsten gibt es noch diverse SWD-Programmer, die als „ST_LINK-kompatibel“ beworben werden.

Upload mit ST-LINK/V2 Mini

Der ST-LINK/V2 Mini ist mit einem Preis von < 10 Euro wohl der kostengünstigste SWD-Programmer. Meistens wird das „Mini“ in der Bezeichnung unterschlagen. 

Auf der einen Seite hat der Programmer unter der Schutzkappe einen USB-A-Anschluss, auf der anderen Seite eine 10-polige Buchse. Ihr verbindet den ST-LINK/V2 folgendermaßen mit eurem BluePill-Board:

Passt dabei auf, dass ihr den 3.3V Pin des BluePill-Boards nicht an den 5.0V-Pin des Programmers anschließt. 

Die BOOTx-Jumper auf dem BluePill-Board könnt ihr bei der Programmierung per SWD in Nullstellung belassen. In der Arduino IDE wählt ihr als Upload Methode:

• Upload method: „STM32CubeProgrammer (SWD)“

Über die SWD-Pins könnt ihr (mit dem ST-LINK/V2) keine Verbindung zum seriellen Monitor herstellen. Stattdessen könnt ihr zu diesem Zweck den USB-Anschluss nutzen. Dafür wählt ihr in den Einstellungen:

• USB support (if available): CDC (generic ‚Serial‘ supersede U(S)ART) 

Alternativ könntet ihr auch einen USB‑zu‑TTL‑Adapter verwenden, dann aber ohne den USB‑Support. 

Der „große“ ST-LINK/V2

Der „eigentliche“ ST-LINK/V2 ist größer. Mit dem Computer wird er über einen USB-Mikro-Anschluss verbunden. Die 4-polige Buchse in der Mitte ist eine Schnittstelle für STM8-Mikrocontroller. Die 20-polige Buchse ermöglicht die Verbindung zu STM32-Mikrocontrollern per SWD oder JTAG.

Falls ihr Boards mit 20-poliger Buchse habt oder ihr per JTAG programmieren wollt, dann macht dieser Programmer Sinn. Für die meisten wird die „Mini“-Version reichen.

Schließlich gibt es noch die Version ST-LINK/V2-ISOL, die für eine galvanische Trennung zum Mikrocontroller sorgt. 

Für die SWD-Verbindung werden nur 2 der Pins plus Stromversorgung benötigt. Da muss man ein wenig aufpassen, dass man sich nicht verzählt und die falschen Pins nimmt.  

Am einfachsten: Upload per HID-Bootloader über USB

Die „Herumsteckerei“ beim Flashen per Serial kann nerven. Auch das Verbinden eines STM32-Boards mit einem ST-LINK/V2 (Mini) ist unbequem (wobei man sich immer bewusst sein sollte, wie gut es einem doch geht, wenn man das zu seinen Problemen zählt 😉 ).

Es wäre doch schön, wenn man seine Sketche „einfach so“ per USB hochladen könnte. Tatsächlich ist das möglich, indem man einen geeigneten Bootloader flasht. Wir verwenden einen HID-Bootloader, der so heißt, weil er nach dem HID-Protokoll (Human Interface Device) kommuniziert. Das HID-Protokoll wurde für USB‑Geräte wie beispielsweise Tastaturen und Mäuse entwickelt. Das Schöne ist, dass man keinen Treiber dafür installieren muss.

Vorab sei gesagt, dass das bei mir nicht mit allen BluePill-Boards funktioniert hat, obwohl die nicht funktionierenden optisch identisch mit den funktionierenden Boards waren, einschließlich der Widerstandswerte. Ich habe den Grund „bis Redaktionsschluss“ nicht herausgefunden.

Variante 1: HID-Bootloader per Serial flashen

Es gibt schon eine Reihe von Anleitungen, wie man den Bootloader auf das BluePill-Board hochlädt. Hier findet ihr ein ausführliches Youtube-Video, hier eine Anleitung mit vielen Bildern. Und hier ist meine eigene Kurzanleitung:

1. Ladet das Bootloader-Paket stm32_binaries.zip von hier herunter und entzippt es.
   • Für das BluePill-Board ist hid_generic_pc13.bin die richtige Wahl. „pc13“ steht dabei für den Pin, der mit der Board-LED verbunden ist. Ihr findet den Bootloader unter …\stm32_binaries\stm32_binaries\F103\low_and_medium_density. 
2. Verbindet das BluePill-Board, wie oben gezeigt, über einen USB-zu-TTL-Adapter mit dem PC. 
3. Setzt den Boot0-Jumper auf 1 und resettet das Board.
4. Öffnet STMCubeProgrammer. Auf der rechten Seite wählt ihr UART aus und stellt den Port ein, an dem der USB‑zu‑TTL-Adapter hängt. Dann klickt auf „Connect“. 

5. Auf der linken Seite in STMCubeProgrammer geht ihr auf „Erasing & Programming“. 
6. Bei „File path“ tragt ihr den Pfad zu hid_generic_pc13.bin ein. „Start address“ ist 0x08000000.
7. Klickt auf „Start Programming“.  Die Erfolgsmeldung quittiert ihr mit OK und klickt auf „Disconnect“, aber lasst das Board noch am Strom. 
8. Setzt den Boot0-Jumper auf 0 und resettet das Board. Jetzt könnt ihr den USB-zu-TTL-Adapter vom Board trennen. Er stört aber auch nicht weiter.
9. Verbindet das Board über USB mit dem PC. 
10. In der Arduino IDE stellt ihr ein:
    • Upload Method: „HID Bootloader 2.2“.
    • USB Support (if available): „CDC (generic ‚Serial‘ supersede U(S)ART)“.
    • U(S)ART support: „Enabled (generic ‚Serial‘)“. Ist aber eigentlich nicht relevant.
      • Ihr seht noch keinen Port. Das ist OK.
11. Ladet einen Sketch hoch. Jetzt findet ihr das Board unter „Port“ und könnt auch den seriellen Monitor nutzen. 

Sollten in dieser Anleitung Punkte fehlen oder missverständlich ausgedrückt sein, dann teilt mir das bitte mit. 

Variante 2 – HID-Bootloader per ST-LINK/V2 flashen

Wenn ihr den Bootloader per ST-LINK V2 auf das BluePill Board flashen wollt, dann gibt es in der Prozedur nur geringfügige Unterschiede:

• Verbindet den ST-LINK/V2 mit dem BluePill Board und dem PC.
• In STMCubeProgrammer wählt ihr ST-LINK anstelle UART.
• Die Jumper auf dem BluePill könnt ihr in Nullstellung lassen. 

Löschen des HID-Bootloaders

Wenn ihr Sketche per SWD oder Serial auf euer Board flasht, dann wird der HID-Bootloader überschrieben. Das ist die einfachste Methode, den Bootloader wieder loszuwerden. Oder ihr löscht den Bootloader mithilfe der Funktion „Erase flash memory“ in STMCubeProgrammer. Das aber ging – zumindest bei mir – nur über den ST-LINK/V2, nicht jedoch über Serial.

Upload per Maple-DFU-Bootloader

Diese Methode empfehle ich nicht, weil ihr im Gegensatz zum Upload per HID-Bootloader weitere Treiber installieren müsst. Ich behandle sie hier nur der Vollständigkeit halber. DFU steht übrigens für Device Firmware Upgrade.

Hier die Kurzanweisung:

• Ladet euch von STM32duino-bootloader den richtigen Bootloader herunter. Das dürfte in den meisten Fällen generic_boot20_pc13.bin sein. Ihr findet ihn hier im Verzeichnis binaries. Doppelklickt die Datei, geht auf das Download-Symbol und speichert die Datei, wo ihr sie wiederfindet. 
• Ladet den Bootloader mit STM32CubeProgrammer auf euer BluePill-Board. Das macht ihr wie weiter oben für den HID-Bootloader beschrieben. 
• Ladet euch das Paket Arduino_STM32 hier herunter. Dazu geht ihr auf das grüne Feld „Code“, dann auf „Download ZIP“. Entzippt das Paket (irgendwo). 
• Geht in das Verzeichnis drivers/win und führt install_drivers.bat aus. Das installiert die Maple-Treiber.
• Verbindet das Board über USB mit dem PC. BOOT0 und BOOT1 auf Stellung 0.
• In der Arduino IDE wählt ihr das richtige Board, außerdem:
  • Wählt den richtigen Port (nicht den unter „dfu Ports“, falls dort etwas auftaucht).
  • Uploadmethode: „Maple DFU Bootloader 2.0“.
  • USB support: „CDC (generic ‚Serial‘ supersede U(S)ART)“.
• Ladet euren Sketch hoch. Wahrscheinlich bekommt ihr am Ende eine Fehlermeldung, dass der eingestellte Port nicht verfügbar ist. Wechselt ihn. Ihr könnt dann ohne weitere Einstellungen neue Sketche hochladen.

Wie schon erwähnt, sehe ich keinen Vorteil des Maple-DFU-Bootloaders gegenüber dem HID-Bootloader. Die BluePill-Boards, die sich nicht mit dem HID-Bootloader programmieren ließen, konnte ich genau einmal mithilfe des Maple-DFU-Bootloaders programmieren. Beim nächsten Upload fand die Arduino IDE den Port nicht. Also auch hier keine Besserung. 

BlackPill-Varianten

Der Name „BlackPill“ ist ebenso wenig geschützt wie „BluePill“. Die meisten meinen, wenn sie vom „BlackPill“ sprechen, das Design von WeAct Studio (kurz: WeAct). Über WeAct selbst erfährt man im Internet recht wenig. Links zu der Firma werden von Edge und Firefox als unsicher eingestuft. Der GitHub-Auftritt von WeAct und der WeAct Studio Shop auf AliExpress geben einen Eindruck davon, womit sich WeAct beschäftigt. 

Der „WeAct-BlackPill“ basiert auf dem STM32F401CCU6 oder dem STM32F411CEU6. Neben dem schwarzen Design fallen seine drei Taster „NRST“, „BOOT0“ und „KEY“ auf.

Aber, wie zuvor erwähnt, ist der Name „BlackPill“ nicht geschützt, weswegen ihr auf viele weitere Varianten trefft. Z. B. gibt es hier ein STM32F103C8T6-basiertes Modell. Etwas skurril ist das unten abgebildete Modell auf Basis des STM32F401RCT6. Wegen des unglücklich gewählten Abstands der Pinleisten passt es auf kein Breadboard:

Ansonsten funktionierte das Board (Board part number: „Generic F401RCTx“).

Sketche auf das BlackPill-Board hochladen

Upload per DFU über USB

Ihr könnt den BlackPill sehr bequem per USB programmieren, da ihr keinen zusätzlichen Bootloader flashen müsst. Zunächst stellt ihr in der Arduino IDE das richtige Board ein: STM32 MCU based boards → Generic STM32F4 series. Dann wählt ihr die richtige Variante aus, z. B. BlackPill 411CE. 

Als Upload-Methode stellt ihr „STMCubeProgrammer (DFU)“ ein. Wenn ihr den seriellen Monitor per USB erreichen wollt, dann wählt als USB-Support „CDC (generic ‚Serial‘ supersede U(S)ART)“. 

Um in den „DFU-Modus“ zu kommen, tut ihr Folgendes:

• Haltet die BOOT0-Taste gedrückt.
• Drückt währenddessen kurz die NRST-Taste.
• Nach 1 bis 2 Sekunden lasst ihr die BOOT0-Taste los. 

Bei den Ports sollte ein Eintrag in der Kategorie „dfu Ports“ auftauchen. Wählt den Port aus und ladet euren Sketch hoch. 

Unter Ports sollte der „dfu Port“ verschwunden sein. Sofern ihr euch für den USB-Support entschieden habt, sollte ein neuer Port zu sehen sein. Um weitere Sketche hochzuladen, wiederholt ihr die Prozedur mit der BOOT0- und der NRST-Taste und stellt wieder den DFU-Port ein. 

Leider funktioniert der Wechsel in den DFU-Modus nicht immer. Windows meldet sich dann mit der Nachricht, dass das USB-Gerät nicht erkannt wurde. Wiederholt den Vorgang, bis es geht. Manchmal hilft es, das USB-Kabel kurz abzuziehen. Auch scheinen nach meiner Erfahrung kurze USB-Kabel besser zu funktionieren als lange.   

Upload per Serial oder SWD

Der Upload per Serial mit USB‑zu‑TTL‑Adapter funktioniert wie beim BluePill, nur dass ihr keine Jumper umsetzt, sondern stattdessen wie bei der DFU-Methode die NRST-Taste drückt, während ihr die BOOT0-Taste gedrückt haltet. Als Port wählt ihr den Port des USB‑zu‑TTL‑Adapters und als Upload‑Methode stellt ihr „STM32CubeProgrammer (Serial)“. 

Der Upload per SWD über den ST-LINK/V2 funktioniert genauso wie beim BluePill, sodass ich mir weitere Erklärungen sparen kann.  

Nicht Arduino-kompatibel: WeAct-HID-Bootloader

Wer von der Knopfdrückerei genervt ist, fragt sich vielleicht, ob es auch eine HID-Bootloader-Lösung für das BlackPill-Board gibt. Vorab: es gibt meines Wissens keine wirklich funktionierende Lösung, zumindest nicht für Nutzer der Arduino IDE. Trotzdem möchte ich meine Erfahrungen teilen.

Auf fabrikneuen WeAct-BlackPill-Boards ist der Bootloader WeAct_HID_Bootloader_F4x1 vorinstalliert. Bei Upload von Sketchen per DFU, SWD oder seriell überschreibt ihr ihn. Es gibt ihn aber auch hier auf GitHub. Der Bootloader liegt dort jedoch nicht als fertige bin-Datei vor, stattdessen müsst ihr diese erst erzeugen. Wie das geht, wird in dieser Diskussion erörtert. Einer der Teilnehmer hat die fertige bin-Datei hier zur Verfügung gestellt. 

Nach dem Entzippen lässt sich die Datei WeAct_HID_Bootloader_F4x1.bin mit STM32CubeProgrammer auf das BlackPill-Board laden. Wenn ihr das Board resettet, während ihr die KEY-Taste drückt, kommt ihr in den Bootloader-Modus. Mit der Arduino IDE und der Upload-Option „HID Bootloader 2.2“ funktioniert der Upload jedoch nicht.

Aus Neugier habe ich es nach dieser Anleitung mit dem Kommandozeilen-Tool WeAct_HID_Flash-CLI.exe probiert. Trotz eines verheißungsvollen „Flash done!“ schien der Sketch jedoch nicht auf dem Board angekommen zu sein!?

Falls ihr eine funktionierende Lösung (für die Arduino IDE) kennen solltet, immer her damit!

Die KEY-Taste anderweitig nutzen

Auch ohne WeAct-Bootloader ist die KEY-Taste nicht völlig sinnlos. PA0 ist über die KEY-Taste mit GND verbunden. Damit könnt ihr die KEY-Taste nutzen, um irgendwelche Aktionen auszulösen. Das könnt ihr mit dem folgenden, kleinen Sketch testen. 

void setup() {
  Serial.begin(115200);
  pinMode(PA0, INPUT_PULLUP);
}

void loop() {
  if(!digitalRead(PA0)){ // KEY pressed
    Serial.println("KEY!");
    pinMode(LED_BUILTIN, OUTPUT); // LED on
    delay(1000); 
    pinMode(LED_BUILTIN, INPUT);  // LED off        
  }
}

Hier seht ihr übrigens auch, dass die Board-LED über einen Widerstand mit VCC verbunden ist. Auf ihrer anderen Seite hängt sie an PC13. Deshalb geht die LED an, wenn PC13 OUTPUT/LOW ist. 

Sketche auf Nucleo-Boards hochladen

Die Nucleo-Boards haben einen integrierten ST-LINK/V2-Programmer. Damit ist der Programmupload per USB-Anschluss kinderleicht. Das ist fast schon langweilig nach den Herausforderungen des Blue- und Blackpills!

Ihr wählt zunächst die Board-Familie, also Nucleo-32, -64 oder -144, und dann das richtige Modell („Board part number“). Hier die weiteren Einstellungen:

Besonderheiten des On-Board-ST-LINK/V2

Bei dem auf den Nucleo-Boards verbauten ST-LINK/V2 handelt es sich um eine neuere Version (ST-LINK/V2-1 oder höher). Zwei Features sind dabei von Bedeutung: 

• Die Emulation eines USB-Massenspeichers.
• Ein „Virtual COM Port“, also eine Art integrierter USB‑zu‑TTL‑Adapter.

Ersteres bewirkt, dass sich das Board als USB-Massenspeichergerät am PC anmeldet, also wie ein USB-Stick oder eine USB-Festplatte. Wenn ihr eure Laufwerke am PC anzeigen lasst, dann taucht das Nucleo-Board dort auf, z. B. das Nucleo-L432KC Board als „Node-L432KC“. Bei der Upload-Methode „Mass Storage“ wird euer Sketch dann wie auf ein Laufwerk kopiert. 

Der Virtual COM Port macht sich in der Arduino IDE schon dadurch bemerkbar, dass euch bei Anschluss des Boards immer ein Port angezeigt wird. Das war bei den Blue-und BlackPills anders. Der Virtual COM Port ermöglicht euch, Serial über den USB-Anschluss zu nutzen, ohne dass ihr den USB-Support in den Einstellungen aktivieren müsst (wenn ihr es trotzdem tut, funktioniert die serielle Ausgabe nicht!). Den U(S)ART-Support hingegen müsst ihr aktivieren, falls ihr Serial nutzen wollt. 

Da der On-Board-ST_LINK/V2 auch immer noch SWD beherrscht, könnt ihr als Upload-Methode alternativ „STM32CubeProgrammer (SWD)“ auswählen. Beim Nucleo-L412KB müsst ihr sogar diese Methode wählen, obwohl auch dieses Board als USB-Massenspeicher erkannt wird. Das hängt damit zusammen, dass es nicht „Arm® Mbed Enabled™“ ist. Recht verwirrend!  

Und wozu dient der Jumper auf D2 und GND?

Jeder, der sich ein Nucleo-32-Board kauft, fragt sich wahrscheinlich, wozu der Jumper auf der Pinleiste dient, der den Pin D2 mit GND verbindet. Auf jungfräulichen Nucleo-32-Boards befindet sich ein Demo-Programm, das die grüne LED blinken lässt. Wenn ihr den Jumper entfernt, ändert sich die Blinkfrequenz. Den tieferen Sinn kenne ich nicht. Ihr könnt den Jumper einfach entfernen. 

Sketche auf das Arduino GIGA R1 WiFi Bord hochladen

Wie alle offiziellen Arduino-Boards hat auch der Arduino GIGA R1 WiFi ein Arduino-eigenes Boardpaket, nämlich „Arduino Mbed OS Giga boards“. Ihr installiert es über die Boardverwaltung. Da es ein Arduino-eigenes Paket ist, braucht ihr keine zusätzliche Boardverwalter-URL. Ihr verbindet das Board über den USB-C-Anschluss mit dem PC, wählt das Board und den richtigen Port aus und legt los. So einfach ist das.

Der Upload wird in diesem Fall über einen vorinstallierten Software-Bootloader gesteuert. Solltet ihr den einmal neu installieren müssen, könnt ihr das Board über die BOOT0- und die RST-Taste in den DFU-Modus bringen und den Bootloader flashen. Folgt dieser Anleitung. 

Anhang 1 – Flash Size prüfen

Ihr könnt die Größe des Flash-Speichers mit STMCubeProgrammer prüfen. Wie ihr das Programm installiert und es mit eurem Board verbindet, steht im Beitrag. Im Bereich „Target information“ findet ihr den Eintrag „Flash size“. Allerdings ist die Angabe nicht zuverlässig. So hatte ich ein BluePill-Board, das bei seriellem Anschluss 128 kB anzeigte, bei Anschluss via ST-LINK waren es 64 kB (siehe unten). An diesem Beispiel möchte ich mit zwei kleinen Tests demonstrieren, wie ihr den tatsächlich vorhandenen Flash prüft.

Die einfache Variante ist, dass ihr versucht, den Speicher jenseits der 64 kB zu lesen, also ab Adresse 0x08010000. Dazu geht ihr in den Bereich „Memory & File Editing“, gebt dort 0x08010000 als Adresse ein, setzt die „Size“ auf 0x10000 (= 65536) und klickt dann auf Read. 

Die Erfolgsmeldung zeigt, dass der Speicherbereich zwischen 64 und 128 KB gelesen werden kann. Sollte der Bereich nicht lesbar sein, dann erhaltet ihr die Fehlermeldung „Data read failed“.

Als zweiten Test unternehmen wir einen Schreibversuch (auch wenn das eigentlich nicht mehr notwendig ist). Wenn ihr das nachvollziehen wollt, dann ladet dazu die Datei ascii_repeat_64kb.bin hier herunter (auf die Datei klicken, dann auf das Download-Symbol). Sie ist genau 64 kB groß und enthält 256 Mal die erweiterte ASCII-Tabelle mit 256 Zeichen. Ladet den Dateiinhalt hoch, beginnend an der Startadresse 0x08010000 (also bei 64 KB). Dabei aktiviert ihr „Verify program“. Wenn alles gut geht, dann erhaltet ihr die Meldung „Download verified successfully“. Im Fehlerfall lautet die Meldung: „failed to download the File“.

Über „Memory & File Editing“ könnt ihr euch den Speicherinhalt anschauen. Wenn Ihr als „Data width“ 8-bit auswählt und dann wieder auf Read klickt, sollte es wie folgt aussehen: