STM32 Core Arduino Framework

Ich habe gerade noch mal einen Blick auf mbed geworfen:
https://www.mbed.com/en/
Das scheint ja auch ziemlich umfangreich. Hat jemand damit Erfahrungen?

Das ärgerliche ist, dass die Cores alle ein bisschen anders sind. Viele 
Libraries laufen daher nur auf einem bestimmten Core. Wie du sicher 
bemerkt hast, gibt es für den STM32F103 mindestens 3 unterschiedliche 
Implementierungen.

Ich frage mich auch, warum ich auf einen anständigen Debugger verzichten 
soll, wo der notwendige ST-Link Adapter doch nur 2 Euro kostet. Das 
grenzt doch schon an selbst-Geißelung.

Ich bin davon* nicht begeistert.

*) STM32 mit Arduino zu programmieren

Marc schrieb:
> Das scheint ja auch ziemlich umfangreich. Hat jemand damit Erfahrungen?

Ja, das ist mein bevorzugtes OS. Um welchen STM geht es?

>Ja, das ist mein bevorzugtes OS. Um welchen STM geht es?

Eigentlich beliebig, ich habe hier verschiedene herum liegen.
Gibt's für das F407 Discovery eine Audio-Lib?

Stefanus schrieb
>das ärgerliche ist, dass die Cores alle ein bisschen anders sind.
Ja, die Arm-Prozessoren sind ein wenig über die Möglichkeiten der AVRs 
hinaus gewachsen. Leider ist es so wie bei vielen Softwarearchitekturen: 
Wenn es keine "Normungskommision" mehr gibt, entsteht Wildwuchs.

Da hat es Embed schon einfacher. Die einigen sich einfach selber. Hier 
ein schönes Architekturbild:
https://os.mbed.com/docs/v5.10/introduction/index.html

>Ich frage mich auch, warum ich auf einen anständigen Debugger verzichten
>soll, wo der notwendige ST-Link Adapter doch nur 2 Euro kostet. Das
>grenzt doch schon an selbst-Geißelung.

Es gibt bestimmt Möglichkeiten zu debuggen. Wir hatten mal ein größeres 
Projekt in AVR-Studio mit Arduino-Unterbau.

Das Disco mit dem F407 ist erstmal nicht direkt ‚mbed enabled‘, dafür 
fehlt die standard Programmierschnittstelle. Aber für diese MCU ist 
schon alles vorhanden und die Anpassungen sind relativ gering.
In mbed sind Klassen für die Standardinterfaces und ein RTOS. 
Spezialitäten wie Audio sind nicht im Core OS und muss man suchen. Für 
STM kann man Code von CubeMX integrieren weil beide den HAL nutzen.
Einfacher für den Anfang sind die Nucleos die schon mbed enabled sind. 
Das alte Disco habe ich glaube ich auch noch, kann dafür etwas zusammen 
bauen. Mit dem STM32F407VE auf einem Chinaboard spiele ich auch gerade.

Das DISCO_F407VG ist doch in der Targetliste drin, nur aus genannten 
Grund nicht in der Boardliste auf der mbed Site.
Dazu erstmal das mbed-cli installieren. Dann mit dem blinky 
https://github.com/ARMmbed/mbed-os-example-blinky/blob/master/README.md
starten. Beim compile den Namen DISCO_F407VG angeben. Im Build 
Verzeichnis liegt das .bin wenn es geklappt hat, das dann mit dem STLink 
Utility auf das Board bringen.
Bei Interesse morgen mehr, ist jetzt zu mühselig am Smartphone.

>Bei Interesse morgen mehr, ist jetzt zu mühselig am Smartphone.

Wenn man auf einfach Weise den I2S Codec am F407 Disco zum laufen 
kriegen kann, würde es mich auf jeden Fall mal interessieren. Für den 
STM32GENERIC Arduino Core gibt es da schon Beispiele.

Hier hat einer die mbed-API in der Arduino-Umgebung nachgebildet:

https://github.com/tkem/mbino

Damit kann man also die mbed Befehle in der Arduino-Umgebung nutzen, 
falls man diese gewohnt ist. Lustig wäre jetzt noch das Ganze in die 
andere Richtung. Da könnte man vielleicht einige Arduino-Treiber unter 
mbed benutzten.

Arduino Code in mbed zu übernehmen ist oft einfach weil das Arduino API 
ja nicht sehr umfangreich ist. Bei großen Apps wie Marlin sieht es 
natürlich anders aus.
Und bei den vielen Libs überwiegt die Quantität, Qualität muss man 
wirklich suchen...

Obwohl der Huaweixx Core bei mir nicht läuft, scheint es bei Ihnen 
selbst zu laufen.

Sie machen Benchmarks und besonders interessant H7 wird wohl 
unterstützt:
https://github.com/huaweiwx/STM32GENERIC/raw/master/STM32/libraries/BoardExamples/examples/all_boards/Benchmarks/Benchmarks-results.xlsx

Das H7 Board läuft 5x schneller als das F407 Disco.

Marc schrieb:
> Hier hat einer die mbed-API in der Arduino-Umgebung nachgebildet:

ok, würde ich mir aber nicht antun. Für meine Haus und Hof Anwendungen 
nehme ich dann lieber kleine Cortex-M0, mehr RAM, schönere Peripherie, 
einfaches Debuggen, gleiche Entwicklungsumgebung wie für die anderen 
Cortex-Mx.

Das Disco F407 habe ich mal ausgepackt, das Blinky wie oben beschrieben 
läuft ad hoc. Für I2S gibt es eine Implementierung von ST (ST_I2S auf 
github), die läuft auch ohne Anpassungen mit dem F407.
Für den Audio DAC CS43L22 findet man Quellcode in den BSP für andere 
Disco Boards. Dieses BSP Gewusel in C von STM gefällt mir nicht, ich 
habe den Code für den DAC in eine Klasse gepackt das er als Komponente 
verwendet werden kann. Auch das funktioniert in einem einfachen 
Testprogramm das einen Sinus aus einer Tabelle auf dem DAC ausgibt.

> Für I2S gibt es eine Implementierung von ST

Meinst Du den Core von STM selber?
>ST_I2S auf github
Hast Du den genauen Link? Github zeigt nämlich viele.

>Audio DAC CS43L22 findet man Quellcode in den BSP

Wenn Du BSP erwähnst meinst Du sicher das Huaweixx Repo?

Der I2S Code von ST war doch nicht auf GitHub sondern auf der mbed Site: 
https://os.mbed.com/teams/ST/code/ST_I2S/

Mit BSP meinte ich auch das vom Disco 407 für mbed. Morgen könnte ich 
meinen Code nach Github schieben, für das Disco 407VG funktioniert das 
relativ einfach.
Habe noch ein Disco 469NI und dachte das läuft da auch einfach, aber 
uiuiui, da ist wieder ein anderes Interface, SAI, drin.

>für das Disco 407VG funktioniert das relativ einfach.

Das wäre super. Wenn Du einen Link auf ein mbed-Beispiel hast, das 
"Out-Of-The-Box" funktioniert werde ich es auf jeden Fall aufprobieren.

Seltsamerweise laufen nicht alle Cores auf meinen PCs ( Ubuntu ).

Hier mal eine List:

STM32-GENERIC-Derivate
###############################################
https://github.com/danieleff/STM32GENERIC
orginal Core, läuft mittlerweile wieder bei mir

https://github.com/ChrisMicro/STM32GENERIC
langsamerer entwickelter Fork. Mehr Beispiele, stable.

https://github.com/huaweiwx/STM32GENERIC
Sehr umfangreiche Beispiele viele Boards. Läuft nicht
################################################

https://github.com/stm32duino/Arduino_Core_STM32
Official Core von ST. Läuft bei mir nicht

https://github.com/stm32duino/STM32Examples
Beispiele zum Offical Core. Ziemlich mager.

https://github.com/GrumpyOldPizza/arduino-STM32L4
Nicht HAL-bassierter Core. Compiliert sehr schnell, effizient.
Für das flashen muss auf Linux ein 32bit Treiber nach installiert 
werden.

https://github.com/rogerclarkmelbourne/Arduino_STM32
Nur für F1 und F4. Habe ich nicht probiert.

https://github.com/platformio/platform-ststm32
platformIO. Die achten vermutlich darauf, dass alles läuft. Noch nicht 
probiert.

was bedeutet für dich läuft/läuft nicht?
Die 'cores' sind ja ein sehr dehnbarer Begriff bei den STM32 Boards. 
Bisher hatte ich das für das gemeinsame Arduino API gehalten, aber das 
ist ja mehr eine Codesammlung für verschiedene Schnittstellen, 
Peripherie und Hilfsfunktionen. Da es für die ganzen Erweiterungen keine 
Richtlinien gibt sieht das sehr chaotisch aus.
Da ist mbed erstmal minimalistischer, der Kern sind wirklich nur die 
Schnittstellenklassen, RTOS (bei mbed-os, vorher mbed 5 genannt), eine 
Softwaretimerklasse und z.B. die Basis für Filesysteme. Jetzt kommen 
weitere Komponenten hinzu, erstmal einiges für IoT weil ARM dafür wohl 
Verbündete hat. Netzwerk und SD Karte mit zwei Dateisystemen gehört auch 
zu den Erweiterungen in mbed-os, USB funktioniert schon für einige 
Targets, da wird aber noch dran gearbeitet.
Für das STM32F407VE_BLACK baue ich mir gerade meine Lib auf. Das ganze 
Zubehör soll aber als Komponenten (C++ Klassen) vorliegen die nicht in 
einen core gehören.
Unter Ubuntu und MacOS laufen die mbed tools auch, ich arbeite aber 
hauptsächlich mit Windows. Wenn du mein Beispiel testen möchtest dann 
installiere mal das mbed-cli.
Dann versuche ich mich gerade mit VSCode anzufreunden. Bisher war 
Ecliopse mit mcuarmeclipse (vormals gnuarmeclipse) PlugIn mein Favorit. 
Das funktioniert auch gut, aber einige Dinge wie Debuugger Anbindung 
sind Blackboxen und der Java Code von Eclipse ist aufgebläht und 
undurchschauber, auch wenn ide Quellen öffentlich sind. Und das 
Persistenzformat ist sehr sehr unpraktisch für den Im/Export von 
Projekteinstellungen. Deshalb ist eclipse nicht gleich eclipse, ein 
Projekt von gnuarmeclipse kann z.b. nicht mit Atollic oder MCUExpresso 
geöffnet werden.
Aber ich schweife ab...

so, habe den Code in ein github repo geschoben:
https://github.com/JojoS62/mbed-os-example-i2s
Die CS43L22 Klasse macht nicht viel, da werden nur für die Kommandos die 
entsprechenden Register per I2C gesetzt. Das kann auch in Arduino 
verwendet werden wenn die I2C Klasse durch die Wire Lib ersetzt wird.

>so, habe den Code in ein github repo geschoben:
Danke dafür. Der Code ist gut reduziert, so dass man ihn einfach 
verstehen kann. Das finde ich gut.

Wie kann man die STM32 Boards debuggen?

Es geht wohl mit Eclipse, aber die Einrichtung scheint etwas aufwändig:
https://github.com/stm32duino/wiki/wiki/How-to-debug
https://www.youtube.com/watch?v=D-MbC9N5U7o

Du verbindest den STM32 Mikrocontroller über einen ST-Link Adapter mit 
dem USB Anschluss deines PC. Viele Boards enthalten diesen Adapter, 
ansonsten kann man sich ab ca 3€ einen kaufen.

http://stefanfrings.de/stm32/index.html#swj

Als Eclipse basierte IDE's kenne ich die "System Workbench for STM32" 
und das "Atollic TrueStudio". Bei beiden IDEs ist die ganze 
Konfiguration der Plugins (außer Arduino) schon vorgegeben.

Du öffnest das Source Projekt mit genau der Software Version, die sich 
auf dem Mikrocontroller befindet und klickst dann auf den grünen Käfer. 
Beim ersten mal legt die IDE eine "Debug Configuration" an. Dann 
verbindet sich der Debugger über den ST-Link Adapter mit der SWD 
Schnittstelle des Mikrocontrollers und lässt das Programm bis zum Beginn 
der main() Funktion laufen. Dort hält es dann an.

Dun kannst nun (rote) Unterbrechungspunkte setzen, indem du links neben 
die gewünschte Zeile doppelklickst, und das Programm mit dem Play Button 
bis dahin laufen lassen. Oder du führst es durch einen anderen Button am 
oberen Bildschirmrand Zeile für Zeile aus.

Außerdem kannst du den Inhalt von Variablen beobachten und sogar 
überwachen lassen (Unterbrechung bei Änderung).

Wichtig ist, dass das Programm nicht zu stark optimiert wurde. Die 
Compiler Optionen -O0 (gar nicht optimiert) und -Og (für Debugging 
optimiert) empfehlen sich dazu. Stark optimierte Programme weichen 
Strukturell so weit vom Quelltext ab, dass der Debugger es stellenweise 
nicht korrekt darstellen kann.

Gerade habe ich eine Anleitung gefunden, wie man Arduino mit Eclipse ( 
nicht Attolic ) benutzt:
http://www.eclipse.org/community/eclipse_newsletter/2018/july/arduino.php

In Eclipse kann man auch die *.ino Files als c++ files definieren:

Preferences => C/C++ => FileTypes => new *.ino mit C++ source file

Der Editor scheint aber trotzdem keine Syntax-Highlightning zu machen.

Ist das CDT Plugin auch installiert? AFAIK gibt es den Eclipse Download 
auch mit dem vorinstallierten cdt.
Oder hier gleich ein Eclipse mit alles für Arduino: 
http://www.baeyens.it/eclipse/

>Oder hier gleich ein Eclipse mit alles für Arduino:
>http://www.baeyens.it/eclipse/

Danke für den Link. Ich habe es gerade probiert:

- Arduino Uno funktioniert super. Compilieren und Download extrem 
schnell
- ESP32 funktioniert
- ESP8266 funktioniert

Beobachtungen:
- Das Serial Monitor Fenster läuft voll und man muss scrollen
- Im Serial Plotter ist nichts zu sehen, alles ist schwarz

STM32 Official Core funktioniert
- Installation funktioniert
- Compilieren funktioniert
- Download funktioniert angeblich:

>Starting upload
>Uploading project "NucleoL476Test" with "STLINK_UPLOAD"
>Starting reset using DTR toggle process
>Continuing to use "/dev/ttyACM0"
>Ending reset

Nur leider: Es blinkt nix.