STM32 programieren mit platformio und mbed

[alexander_ro]

Hi Mädels ... Jungs ... :)

Ich versuche gerade das Platinchen: https://www.st.com/en/evaluation-tools/b-l475e-iot01a.html mit dem mbed Framework und platformio zu Programmieren. Ein einfaches LED Beispiel habe ich auch zum laufen bekommen. Ein für Wlan gefundenes Beistpiel will sich aber nicht übersetzen lassen. Das Beispiel stammt von hier: https://github.com/ARMmbed/mbed-os-example-wifi

Mein Problem sind solche Fehlermeldungen:


Compiling .pioenvs/disco_l475vg_iot01a/lib0d2/FEATURE_LWIP/lwip-interface/LWIPInterface.o
Compiling .pioenvs/disco_l475vg_iot01a/lib0d2/FEATURE_LWIP/lwip-interface/LWIPInterfaceEMAC.o
Compiling .pioenvs/disco_l475vg_iot01a/lib0d2/FEATURE_LWIP/lwip-interface/LWIPMemoryManager.o
In file included from /root/.platformio/packages/framework-mbed/features/FEATURE_LWIP/lwip-interface/lwip/src/include/lwip/opt.h:51:0,
from /root/.platformio/packages/framework-mbed/features/FEATURE_LWIP/lwip-interface/lwip/src/include/lwip/tcpip.h:40,
from /root/.platformio/packages/framework-mbed/features/FEATURE_LWIP/lwip-interface/LWIPInterfaceEMAC.cpp:17:
/root/.platformio/packages/framework-mbed/features/FEATURE_LWIP/lwip-interface/lwipopts.h:42:2: error: #error "Either IPv4 or IPv6 must be enabled."
#error "Either IPv4 or IPv6 must be enabled."


Schaut man sich das in der entsprechenden Datei an sieht es aus als fehlte mir da irgendwas als config Datei. Wenn ich das richtig sehe machen das bei den mbed Tools die *.json Dateien. Aber wie das mit platformio funktioniert habe ich nicht gefunden?
Klar man könnte die fehlenden Makros irgendwo von Hand definieren aber vermutlich ist das nicht so gedacht.

Meine platformio.ini sieht so aus:


[env:disco_l475vg_iot01a]
platform = ststm32
board = disco_l475vg_iot01a
framework = mbed
upload_protocol = stlink
build_flags = -D PIO_FRAMEWORK_MBED_RTOS_PRESENT


Viele Grüße
Alexander

[Moppi]

Either IPv4 or IPv6 must be enabled.

Er versucht LWIPInterface, LWIPInterfaceEMAC und LWIPMemoryManager zu kompilieren.
Da wird Netzwerk benötigt. Du möchtest bitte entweder IPv4 oder IPv6 aktivieren/einschalten.
Es fehlen irgendwo Angaben zum Netzwerk oder es ist, auch irgendwo, einfach "disabled" oder nicht "enabled".


MfG

[alexander_ro]

Stimmt schon das man das einschalten muss soweit hatte ich das auch schon angenommen. Aber wie man das macht ist mir nicht klar. Das mbed hat so einen eigenen config Prozess aber wie wurde der für Platformio umgesetzt.

[Moppi]

Ich kenne das nicht.

Mal ein Link zu der platformio.ini: https://docs.platformio.org/en/latest/projectconf.html

Es gibt aber eine Platformio Community, dort vielleicht mal melden und nachfragen?
Ich habe jetzt eine Weile gesucht, aber nichts brauchbares gefunden, was Dein Problem beschreibt oder erklärt. :(

MfG

[alexander_ro]

Versucht habe ich jetzt mal in der platformio.ini die nötigen Makros zu definieren


build_flags = -DPIO_FRAMEWORK_MBED_RTOS_PRESENT -DMBED_CONF_LWIP_IPV4_ENABLED -DMBED_CONF_LWIP_IP_VER_PREF=4


Dann kommt es nicht mehr zu der oben genannten Fehlermeldung. Leider geht es deshalb immer noch nicht. Er möchte dann im Beispiel Programm die Werte für SSID und Passwort gesetzt haben. Das habe ich mal so versucht.


-DMBED_CONF_APP_WIFI_SSID="ssid" -DMBED_CONF_APP_WIFI_PASSWORD="passwort"

Da bin ich mir aber nicht sicher das diese -D Optionen für den gcc so funktionieren.

Fehlermeldungen:


src/NoTimeForRevolution.cpp: In function 'int main()':
<command-line>:0:25: error: 'ssid' was not declared in this scope
src/NoTimeForRevolution.cpp:149:39: note: in expansion of macro 'MBED_CONF_APP_WIFI_SSID'
printf("\nConnecting to %s...\n", MBED_CONF_APP_WIFI_SSID);
^~~~~~~~~~~~~~~~~~~~~~~
<command-line>:0:29: error: 'passwort' was not declared in this scope
src/NoTimeForRevolution.cpp:150:54: note: in expansion of macro 'MBED_CONF_APP_WIFI_PASSWORD'
int ret = wifi->connect(MBED_CONF_APP_WIFI_SSID, MBED_CONF_APP_WIFI_PASSWORD, NSAPI_SECURITY_WPA_WPA2);


ssid und passwort sind Platzhalter für meine echten Werte.

Kennt ihr vielleicht irgendeine Alternative die leichter zu benutzen ist als das mbed auf diesem oben genannten STM32 Platinchen?

[HaWe]

Kennt ihr vielleicht irgendeine Alternative die leichter zu benutzen ist als das mbed auf diesem oben genannten STM32 Platinchen?

wenn er Arduino-kompatibel ist: Arduino IDE.

Wenn nicht: es ist ja auch "nur" ein ARM Cortex M4...
dann alternativ ein anderer STM 32, für den es Arduino board cores gibt
NUCLEO-F334R8 soll angeblich mit Arduino funktionieren, bin mir aber nicht sicher,
evt auch andere möglich wie https://www.amazon.de/STM32F4-DISCOVERY-STM32F411-Cortex-M4-Development/dp/B00NYBD9NW

Oder Adafruit M4, die funktionieren sicher mit der Arduino IDE:
ein Adafruit Feather M4
oder ein Adafruit Itsybitsy M4
oder ein Adafruit Metro M4

[alexander_ro]

Das war jetzt wohl nicht so ganz eindeutig was ich oben geschrieben hatte. Ich meinte mehr eine Alternative für das mbed die Hardware wollte ich eigentlich weiter benutzen. Stimmt schon das es nur ein Cortex-M4 ist aber wenn man immer alles an Software von Grund auf neu schreiben muss ist es Mühsam voran zu kommen. Arduino kompatibel ist er glaube ich nicht. Zumindest bekam ich von platformio die Fehlermeldung das er es nicht ist. Das war bei dem Versuch eine zwar für STM32 aber Arduino WLAN Bibliothek zu benutzen.

[HaWe]

Das war jetzt wohl nicht so ganz eindeutig was ich oben geschrieben hatte. Ich meinte mehr eine Alternative für das mbed die Hardware wollte ich eigentlich weiter benutzen. Stimmt schon das es nur ein Cortex-M4 ist aber wenn man immer alles an Software von Grund auf neu schreiben muss ist es Mühsam voran zu kommen. Arduino kompatibel ist er glaube ich nicht. Zumindest bekam ich von platformio die Fehlermeldung das er es nicht ist. Das war bei dem Versuch eine zwar für STM32 aber Arduino WLAN Bibliothek zu benutzen.
da habe ich deine "Alternativen-Suche" tatsächlich etwas zu weitgreifend verstanden ;)
Was deine Versuche mit einer Arduino-Lib angeht (WLAN):
Das ist nicht das Entscheidende, denn die funktionieren von sich aus nicht unbedingt aus dem Stand mit anderen Frameworks (wegen Serial(), Wire() u.a. Basis-Libs) - sondern ob du einen core findest, den du über den Arduino-Boardmanager laden kannst. M4 cores gibt es ja etliche, nicht nur zu Adafruit M4, sondern auch Teensy mit M4 u.v.a., von daher halte ich es für nicht ausgeschlossen, welche für deinen STM32L4 zu finden und zu laden.
Aber ohne mich jetzt darauf versteifen zu wollen:
wenn es sich heraus stellt, dass es weder cores für den STM32L4 gibt noch dass du mit deinem mbed Framework u.ä. weiterkommst, dann wäre IMO ein Wechsel zu einem anderen M4 Board kein Weltuntergang wegen der nötigen 20 EUR (oder weniger) Investition für kompatible Adafruits oder Teensys oder STM32s.
Das Arduino IDE/API ist aber ja auch auf C++11 aufgebaut, von daher wirst du auch nicht so viel Code neu schreiben müssen, und es ist zukunftssicher, da die Libs und Codes auch künftig für andere, noch neuere und noch leistungsfähigere Boards passen werden.
Aber wie auch immer: viel Erfolg bei deiner Suche und für deine entsprechende Entscheidung! 8)

[alexander_ro]

Also was Du mit dem Core meinst kann ich mir zwar etwa vorstellen. Genau weiß ich das aber nicht. Ich würde mal vermuten das sind dann die Definitionen mit den Registern, Portnamen und vielleicht Memorymapping oder so ähnlich. Vielleicht auch ein paar Grundlegende Programmteile.

Ich finde das ganze egal ob nun mit Arduino oder mbed sehr unübersichtlich es gibt alle möglichen Programmmodule die dann wieder nur mit bestimmten anderen zusammen funktionieren. Aber es wird nicht wirklich angegeben welche das genau sind und es gibt auch oft mehrere die den gleichen Namen haben. Auch bei Header Files habe ich oft das Problem das es nicht gefunden wird. Eine Suche zeigt dann es gibt 5 verschiedene Programmbibliotheken mit dem Filenamen ... welcher ist dann der richtige?

Das Platinchen habe ich im Rahmen dieser "Elektor Board Games" bekommen deshalb muss ich das da verwenden. Es heißt ja eigentlich das man da auch Support dazu bekommt aber bei der genannten Mailadresse und bei der Elektor bekommt man keine Antwort auf Fragen :( ... aber bis Ende des Monats soll man fertig sein :( ... die Platine ist vor einer Woche bei mir angekommen.

Das Beispiel oben geht nach dem was ich gefunden habe nicht mit diesem Platinchen. Das liegt daran das die von ST gemachte Unterstützung scheinbar für das verwendete WLAN Module die (was auch immer) WiFiInterface nicht implementiert. Nach längerem suchen habe ich ein Beispiel für einen WebServer gefunden: https://os.mbed.com/teams/ST/code/DISCO_L475VG_IOT01-wifi_http_server/
(https://os.mbed.com/teams/ST/code/DISCO_L475VG_IOT01-wifi_http_server/)
Irgendwie fehlt beiden Projekten ... Arduino und mbed ... eine Instanz die die Entwicklung koordiniert und dafür sorgt das die Dinge kompatibel sind. Würde man den Linux Kernel genauso Planlos entwickeln gäbe es einen Kernel der zwar viele schöne Teile hat aber nichts passt wirklich zum anderen.

[HaWe]

ja, mit cores hast du Recht, es ist all das, was unter packages\company\hardware\cpu\version\cores\ zu finden ist, eigentlich meinte ich aber sogar auch alles übrige in den speziellen cpu packages, mit Dateien zu Bootloaders, drivers, cpu-spez. libraries, tools, variants...
Wenn es dich interessiert, installiere mal Arduino IDE und dann ein ARM-Zusatz-package, dann siehst du, was alles dabei ist.

Wenn du bei deiner cpu-Platine bleiben musst und da keine Wahl hast, hat sich ntl alles zu anderen M4s erledigt.

was du aber mit "Instanz die die Entwicklung koordiniert und dafür sorgt das die Dinge kompatibel sind" meinst, verstehe ich nicht:
Die übergreifende Kompatibilität aller Boards und cpus (AVR, ARM, ESP, Intel) innerhalb des hierarchischen Arduino APIs stellt die Arduino IDE her, auf der Basis von "Processing", das vorher bereits entwickelt wurde (Ben Fry,Casey Reas) und des Java-basierten "Wiring" Konzepts, das von Hernando Barragán / AG von Massimo Banzi entwickelt und zur eigentlichen Grundlage von "Arduino" wurde - aber das führt hier zu weit.
Immerhin sorgen alle Arduino Entwickler dafür, dass die neueren Erweiterungen immer rückwärts-kompatibel zu allen anderen cpu-Plattformen bleiben, was auch manchmal etwas hinderlich, und teilweise auch recht bizarr und lähmend gegen grundlegende Verbesserungen ist (z.B. dass die Funktion für pwm-write auf digitalen Pins "analogWrite" heißt) .
Oder welche "kompatiblen Dinge" meintest du?

Wie auch immer, wenn du mit deinem STM32L4 bleiben musst und die Arduino IDE benutzen willst, dann kannst du nur hoffen, ein passendes package samt cores dafür zu finden, das sich per Boardmanager einbinden und installieren lässt.

Arduino nimmt einem jedenfalls sehr schön alle hässlichen low-level-Details ab, man muss sich nicht um fuses, Monster-IDEs oder -Frameworks, makefile, Pfadverwaltung, linker u.v.a. kümmern: wäre es anders, hätte ich nie mit diesen cpus jemals angefangen, und so kann man sich von Anfang an um seine Projekte kümmern, ohne sich mit der Hardware herumkloppen zu müssen (so wie du in deinem TOP-Post zu mbed und platformio beispielsweise).
Arduino hat dazu gewissermaßen ebenso ein internes und externes Regelwerk wie Linux mit seinem kernel und seinem devtree, nur kann man das nicht recht vergleichen, weil ja ein multiuser-multithreading-multitasking-OS dahinter steckt.
Bei MCUs für Arduino und avrstudio gibt es aber ja noch nicht mal ein File System und daher auch kein C/C++ nach Posix Definitionen mit einem Datentyp FILE* und z.B. einer stdio.h Lib mit fopen und fclose usw.

[alexander_ro]

was du aber mit "Instanz die die Entwicklung koordiniert und dafür sorgt das die Dinge kompatibel sind" meinst, verstehe ich nicht:
Beim Linux Kernel gibt es immer Betreuer für ein Subsystem das die Entwicklung koordiniert und dafür sorgt das z.B. Schnittstellen zum Netzwerk (WLAN, I2C, SPI, USB, Display) oder Speicherverwaltung definiert und eingehalten werden. Bei Arduino und mbed gibt es zahlreiche nicht kompatible Bibliotheken die immer wieder das gleiche tun auf andere Art meist schwer zu erkennen welche man braucht. In einem älterem Thread hier habe ich schon mal für den Arduino Due was gesucht für parallel Verarbeitung und Timer. Da war das ganze Arduino Zeug aber auch nur Mäßig hilfreich. So lange man nur das machen will was Presse und Buchautoren in dem Endlosen Gelaber für Einsteiger verbreitet ist alles gut. Sicher das ist wichtig aber man sollte nicht vergessen das die ganze Technik erst Nützlich wird wenn man mehr tut als am Terminal "Hello World" ausgeben und eine LED blinkt. Es gibt nicht nur Einsteiger aber vermutlich kann man mit denen leichter Geschäfte machen weil ihnen noch das wissen fehlt Müll von gutem zu trennen.

C/C++ Code ist ja an sich bereits recht Plattform unabhängig. Man darf nicht die stdc++ mit C++ verwechseln. In der Standardbibliothek gibt es selbstverständlich Dinge die nicht auf beliebig kleiner CPU oder MCU laufen können. Die ARM Cortex M4 sind ja untereinander sehr ähnlich nur die darum gebaute Hardware unterscheidet sich stärker. Was dann für die Entwicklung für verschiedene Vertreter ihrer Klasse eine deutlich Vereinfachung ist. Nur kann ich das noch nicht erkennen das man das auch in der Praxis über blink und serial hinaus anwendet. Ein bisschen Low Level nehmen einem die schon ab aber nur solange man dem Mainstream folgt. Eigene Vorstellungen sind in der Welt noch nicht erwünscht.

[HaWe]

Beim Linux Kernel gibt es immer Betreuer für ein Subsystem das die Entwicklung koordiniert und dafür sorgt das z.B. Schnittstellen zum Netzwerk (WLAN, I2C, SPI, USB, Display) oder Speicherverwaltung definiert und eingehalten werden. Bei Arduino und mbed gibt es zahlreiche nicht kompatible Bibliotheken die immer wieder das gleiche tun auf andere Art meist schwer zu erkennen welche man braucht. In einem älterem Thread hier habe ich schon mal für den Arduino Due was gesucht für parallel Verarbeitung und Timer. Da war das ganze Arduino Zeug aber auch nur Mäßig hilfreich. So lange man nur das machen will was Presse und Buchautoren in dem Endlosen Gelaber für Einsteiger verbreitet ist alles gut. Sicher das ist wichtig aber man sollte nicht vergessen das die ganze Technik erst Nützlich wird wenn man mehr tut als am Terminal "Hello World" ausgeben und eine LED blinkt. Es gibt nicht nur Einsteiger aber vermutlich kann man mit denen leichter Geschäfte machen weil ihnen noch das wissen fehlt Müll von gutem zu trennen.

C/C++ Code ist ja an sich bereits recht Plattform unabhängig. Man darf nicht die stdc++ mit C++ verwechseln. In der Standardbibliothek gibt es selbstverständlich Dinge die nicht auf beliebig kleiner CPU oder MCU laufen können. Die ARM Cortex M4 sind ja untereinander sehr ähnlich nur die darum gebaute Hardware unterscheidet sich stärker. Was dann für die Entwicklung für verschiedene Vertreter ihrer Klasse eine deutlich Vereinfachung ist. Nur kann ich das noch nicht erkennen das man das auch in der Praxis über blink und serial hinaus anwendet. Ein bisschen Low Level nehmen einem die schon ab aber nur solange man dem Mainstream folgt. Eigene Vorstellungen sind in der Welt noch nicht erwünscht.

nun, ich kann und will jetzt hier nicht für Arduino und seine Kompatibilität die Lanze brechen, aber doch:
Jeder kann seine eigenen Libs und Codes entwickeln, und/aber es macht niemand jemand Vorschriften, zu welchen anderen 3rd Party Libs sie kompatibel sein müssen oder nicht.
Das ist für C/C++ für den Raspi nicht anders, auch hier gibt es welche, die zusammenpassen, und andere, die es nicht tun, das ist nunmal in C/C++ so, auf jeder Plattform: erlaubt ist alles, was der Programmierer will, es gibt fast nichts was die Programmiersprache vorschreibt.
Die Grundfunktionen bei Arduino sind nun mal neben digital und analog Read/Write noch Serial() und Wire(), der Rest ist ziemlich frei verfügbar.
Und wir sprechen ja hier nicht über RaspberryPi.org, was die für devtrees und GPIO- und kernel-Funktionen vereinbaren, und nicht über die Organisation, die C/C++ Standards allgemein erarbeitet. Obwohl alles legaler C/C++ Code ist, heißt das ja auch nicht, dass Code vom Raspi auf dem Bananapi laufen muss und umgekehrt, selbst wenn alle gcc 5.x oder 6.x oder 7.x oder 8.x verwenden.
EDIT: Ich erinnere mich beim Raspi auch an ein paar Beispiele, wo i2c-Libs für TFTs, die bcm-Funktionen verwendet haben, nicht mit wiringI2c kompatibel waren.
Der Due ist bei Arduino nun gerade ein schlechtes Beispiel für crossover-Plattform-Kompatibilität, das stimmt, er wurde auch in der Vergangenheit sehr vernachlässigt und seine Libs wenig weiterentwickelt.
Teensy macht das angeblich deutlich besser, was ich hier bereits las, und Adafruit auch, mit nur wenigen Einschränkungen. Für alles andere gibt es die Helpdesks der Hersteller und die github-Repo "issues".
Im Großen und Ganzen kann man aber schon sagen: was mit Arduino-Sketch-Code auf Arduino AVRs läuft, läuft auch auf supporteten ARM Cortex M0, M3, M4, Intel Galileo, ESP8266 und ESP32: Du wirst kein Framework finden, dass mehr fertige Libs zur Verfügung stellt als Arduino für verschiedensete cpu-Boards, und zu 99,9% alles kompatibel zueinander - und alles mit legalem, frei mit eigenem Code erweiterbarem C++ .

[alexander_ro]

Du vermischst da jetzt etwas die Bereiche Hardware und Anwendung beides braucht Software. Bei Linux kann jeder beliebiges an Libs Programmieren für seine Anwendungen. Er kann auch beliebiges im Kernel umbauen oder neu machen. Er kann aber nicht "wichtig" seine Kernel Änderungen nach belieben auf kernel.org und in den offiziellen Kernel Sourcecode verbreiten. Bei Arduino und mbed ist das anders dort wird alles in einem unübersichtlichem Wust auf der Projektseite angeboten. Mein aktuelles Beispiel mit dem oben genanntem Platinchen ist: der Compiler Meckert ein WiFi.h an aber der sagt nicht die Lib heißt DISOCO_STM32.xyz. Eine Suche nach der Datei liefert 5 Libs die diese enthalten. Welche ist es jetzt? ... Antwort gar keine weil der Hersteller sein eigenes Süppchen kocht und diese Beispiel auf dem Platinchen alle nicht gehen. Es gibt ein eigenes Beispiel dafür das geht. Aber erkennen kann man das nur als Insider der Entwicklungsabteilungen nicht als Programmierer der für eine Lib ja der Anwender ist.

Was mir fehlt ist eine klarere Linie zwischen Hardware, Anwendung bzw. Softwareschnittstellen die z.B. Timer oder ähnl. immer gleich zur Verfügung stellen. Auch die Trennung zwischen offiziellem von Arduino oder mbed und dem was von dritten Programmiert ist muss leichter zu erkennen sein.

Wenn Du mit dem Raspi Programm unter Linux nichts tust was der Bananapi wegen Hardware die ihm fehlt nicht kann läuft es auf beiden. Kann wegen verschiedener Linux und Lib Versionen sein das es neu übersetzt werden muss. Das es läuft stellt der Kernel und seine Schnittstellen bzw. die der glibc sicher.

Soll ja nicht heißen das die da was schlechtes machen ... nur das man vielleicht noch ein bisschen Ordnung rein bringen muss :)

[HaWe]

Du vermischst da jetzt etwas die Bereiche Hardware und Anwendung beides braucht Software. Bei Linux kann jeder beliebiges an Libs Programmieren für seine Anwendungen. Er kann auch beliebiges im Kernel umbauen oder neu machen. Er kann aber nicht "wichtig" seine Kernel Änderungen nach belieben auf kernel.org und in den offiziellen Kernel Sourcecode verbreiten. Bei Arduino und mbed ist das anders dort wird alles in einem unübersichtlichem Wust auf der Projektseite angeboten. Mein aktuelles Beispiel mit dem oben genanntem Platinchen ist: der Compiler Meckert ein WiFi.h an aber der sagt nicht die Lib heißt DISOCO_STM32.xyz. Eine Suche nach der Datei liefert 5 Libs die diese enthalten. Welche ist es jetzt? ... Antwort gar keine weil der Hersteller sein eigenes Süppchen kocht und diese Beispiel auf dem Platinchen alle nicht gehen. Es gibt ein eigenes Beispiel dafür das geht. Aber erkennen kann man das nur als Insider der Entwicklungsabteilungen nicht als Programmierer der für eine Lib ja der Anwender ist.

Was mir fehlt ist eine klarere Linie zwischen Hardware, Anwendung bzw. Softwareschnittstellen die z.B. Timer oder ähnl. immer gleich zur Verfügung stellen. Auch die Trennung zwischen offiziellem von Arduino oder mbed und dem was von dritten Programmiert ist muss leichter zu erkennen sein.

Wenn Du mit dem Raspi Programm unter Linux nichts tust was der Bananapi wegen Hardware die ihm fehlt nicht kann läuft es auf beiden. Kann wegen verschiedener Linux und Lib Versionen sein das es neu übersetzt werden muss. Das es läuft stellt der Kernel und seine Schnittstellen bzw. die der glibc sicher.

Soll ja nicht heißen das die da was schlechtes machen ... nur das man vielleicht noch ein bisschen Ordnung rein bringen muss :)

sagen wir mal so:
bei Arduino funktioniert alles sicher, was von Arduino bei der Standard-Installation dabei ist - für alles andere keine Garantie, funktioniert aber meist doch.
bei Banana und Raspi aber stimmt es oft nicht, denn beide haben verschiedene devtrees und auch andere kernel, selbst wenn beide unter Debian laufen (Raspbian ist ja zwar Debian, aber eben auf Raspi angepasst und nicht für Bananapi).
Es stimmt noch nicht mal für ausschließlich Raspis untereinander, einmal mit Raspbian und einmal mit Debian ev3dev distri, ebenfalls wegen unterschiedlichem devtree - - und das obwohl alle legalen C/C++ Code verwenden.
Und wie gesagt, noch nichtmal i2c-Code, einmal per bcm und einmal per wiringI2c sind miteinander (gleichzeitig) kompatibel, selbst wenn beide Raspis das gleiche Jessie oder Stretch verwenden.

Dass also immer C(++) Code auf allen Plattformen läuft, ist eine oft gelesene Mär... ;)

[alexander_ro]

Vielleicht funktioniert das was Arduino bei der Standard Installation dabei hat. Das ist aber selbst bei deren eigenen Platinchen nur ein Bruchteil dessen was deren Hardware kann. Schon kurz nach überschreiten der Komplexität einer seriellen oder Blink Anwendung ist man dann wieder Hardware naher Programmierer der in Registern gräbt und Bits verschiebt. Ob das den Aufwand dann wirklich so stark verringert wie die Fachpresse gerne glauben macht? Entspricht zumindest nicht meiner Erfahrung.

Das C/C++ immer läuft habe ich nie behauptet. Devtree und das sonstige von Dir genannte ist jetzt aber Hardware. Hardware Zugriffe die hatte ich ja eingeschränkt. Hardware muss vorhanden sein ... es muss einen Kerneltreiber geben ... die lib die Du benutzt darf nicht am Kernel vorbei auf die Hardware zugreifen. Device Namen können abweichen weil das die Hersteller der Platinchen unterschiedlich realisieren. Aber der Device Name ist kein C/C++ Code. Neu übersetzen muss man den so meistens weil Versionen unterschiedlich sind oder gleich die ganze CPU anderen Code ausführt (siehe Intel und ARM). Meine Programme konnten das zumindest immer wechseln zwischen Intel und ARM. Ich habe in meinem Git Repo auf meiner Internetseite ein Programm das ohne Desktop auf dem Raspi (ARM) und meinem Alien (Intel) läuft und OpenGL Grafik auf das Orginale Raspi Display oder den Notebook Bildschirm aus gibt. In dem Sourcecode wird nicht mit irgendwelchen gruseligen ifdef Plattform hingebogen. Der Compiler übersetzt immer den gleichen Sourcecode.

[HaWe]

Vielleicht funktioniert das was Arduino bei der Standard Installation dabei hat. Das ist aber selbst bei deren eigenen Platinchen nur ein Bruchteil dessen was deren Hardware kann. Schon kurz nach überschreiten der Komplexität einer seriellen oder Blink Anwendung ist man dann wieder Hardware naher Programmierer der in Registern gräbt und Bits verschiebt. Ob das den Aufwand dann wirklich so stark verringert wie die Fachpresse gerne glauben macht? Entspricht zumindest nicht meiner Erfahrung.

Das C/C++ immer läuft habe ich nie behauptet. Devtree und das sonstige von Dir genannte ist jetzt aber Hardware. Hardware Zugriffe die hatte ich ja eingeschränkt. Hardware muss vorhanden sein ... es muss einen Kerneltreiber geben ... die lib die Du benutzt darf nicht am Kernel vorbei auf die Hardware zugreifen. Device Namen können abweichen weil das die Hersteller der Platinchen unterschiedlich realisieren. Aber der Device Name ist kein C/C++ Code. Neu übersetzen muss man den so meistens weil Versionen unterschiedlich sind oder gleich die ganze CPU anderen Code ausführt (siehe Intel und ARM). Meine Programme konnten das zumindest immer wechseln zwischen Intel und ARM. Ich habe in meinem Git Repo auf meiner Internetseite ein Programm das ohne Desktop auf dem Raspi (ARM) und meinem Alien (Intel) läuft und OpenGL Grafik auf das Orginale Raspi Display oder den Notebook Bildschirm aus gibt. In dem Sourcecode wird nicht mit irgendwelchen gruseligen ifdef Plattform hingebogen. Der Compiler übersetzt immer den gleichen Sourcecode.

ja, das glaube ich dir unbesehen - ich hatte ja nicht behauptet, dass es NIE Plattform-übergreifend funktioniert, sondern dass es viele Fälle gibt, wo es das nicht tut, noch nichtmal auf derselben Hardware, und zur Programmierung gehört eben auch die Software zur GPIO-Steuerung, und dazu sind eben auch die vorhandenen kernels und devtrees ganz entscheidend.
Ich habe aber ebenfalls Code, der sowohl auf meinen Arduinos als auch meinem Raspi läuft, nur mit unterschiedlicher print Ausgabe.
Und dass Arduinos mehr können als nur Blink.ino, habe ich oft genug erwähnt, z.B. mein autonomes Schachprogramm, oder 6/7DOF Robotarmsteuerung mit inverser Kinematik, die gerade jemand anderes entwickelt, und mehrschichtige, opt. rückgekoppelte neuronale Netze. Mich in die Hardware hineingraben, wie du es im TOP geschildert hast, ist aber jenseits meiner Ambitionen, deshalb verwende ich ja Arduinos, die alles in der IDE User-freundlich erledigen.
Gerade an solchen Boards wie deinem und platformio und mbed vs. Arduino API scheiden sich eben die Geister - manche wollen oder müssen sich erst haarklein durch die Hardware und das Framework und die Libs wühlen, während andere mit der Arduino IDE schon längst Programme schreiben - und ich wüsste ernsthaft nichts, was ich an den Möglichkeiten von Arduinos (AVR, M0, M3, M4, ESPs) mit ihren abstrahierten und universellen Highlevel-API Funktionen vermisse.
Bin aber absolut gespannt, wie du mit deinem STM32 zurecht kommst.

[alexander_ro]

Dann programmierst Du am Kernel bzw. der glibc vorbei sonst würde es meistens gehen und nur selten nicht. Da kann aber der Kernel nicht dafür und das es zwischen AVR und Linux Probleme gibt liegt in der Tatsache das auf AVR normal kein Linux läuft. Man kann immer so programmieren das es nicht geht. Das Programm war nur ein Beispiel bei mir laufen abgesehen von den Device Namen die Programme immer unter Linux egal wo. Deine Programme haben mit dem Devicetree ja eigentlich nichts zu schaffen. Auf der selben Hardware läuft es nur dann nicht wenn Verschiedene Versionen installiert sind. Was nun logisch ist. Ich hatte oben aber geschrieben das neu compilieren dann nötig ist. Der Sourcecode ist kompatibel eine binäre Version ist es nur unter bestimmten Bedingungen.

Ja Arduinos können mehr aber die Software dazu kann kaum mehr. Die Hardware wird von der Arduino Bibliothek nur Mäßig unterstützt. Zumindest alles was ich machen wollte ging nicht, Timer, Multitasking muss man alles selber machen.

Ich habe oben nichts geschrieben von wegen in die Hardware eingraben. Oder ist das benutzen eines WLAN und des http Protokolls für Dich in die Hardware eingraben. Ich bin auf der suche nach einem Beispiel das auf dem Platinchen funktioniert und WLAN und einen http Cleint zeigt. Ich dachte so was würden diese Projekte schon verfügbar machen weil alles Standard ist. Weit gefehlt entweder verwendet man mit den genannten Problemen irgendwelche meist nicht gut funktionierenden Libs von dritt Anbietern oder macht es selber.

Zeig mir ein Beispiel das mit dem Platinchen funktioniert für WLAN und einen HTTP-Client dann benutze ich den sehr gerne. Nur funktioniert der Mist nicht das ist es doch was ich die ganze Zeit bemängle. Das es keine Unterstützung dafür gibt. Das zweite Beispiel das ich gefunden habe Programmiert WLAN und HTTP am mbed vorbei und stürzt alles paar abgearbeiteten HTTP Requests ab. Funktioniert alles Klasse ich bin begeistert ... :(

[HaWe]

nee, das war vlt missverständlich ausgedrückt -
die Sache mit kernel und devtrees bezog sich nur auf den Raspi. Und beim Raspi verwende ich auch kein makefile, sondern ausschließlich die Geany IDE und wiringPi mit an Arduino angelehnten Libs.

Was dein Thema mit M4 angeht, da gibt es ntl keinen kernel, aber die Arduino IDE ist so hoch abstrahiert, dass die Basis-Libs für die "Essentials" digitalRead/Write, analogRead/Write, Serial, Wire und SPI eben universell auf allen cores und boards funktionieren, und die Zusatzlibs von wem auch immer zu 99,9% ebenfalls.
Klar gibt es immer wieder Fälle, wo alte AVR-Libs nicht ARM-kompatibel sind und ARM-Code nicht auf AVRs läuft - das ist im Einzelfall manchmal ärgerlich, aber - zum Glück - wirklich extrem selten.
Auf Prozessor-naher Register- oder Interrupt-Ebene programmiere ich grundsätzlich nie (ausgenommen mal für Benchmark-Tests zum Vergleich), dazu nutze ich asschließlich die High-Level Arduino-Funktionen, und ich kenne keinen einzigen Fall, wo ich da gegenüber hardwarenahen Programmierrn irgendwelche Nachteile hätte und/oder etwas an Funktionalität fehlen würde.

Wo Arduino dann grundsätzlich überfordert ist, wechsle ich zum Raspi, und das betrifft vor allem auch alles, was sich um preemptives Multithreading (wie bei POSIX pthread) dreht: hier ist Arduino wirklich extrem schlecht aufgestellt, und leider wird das wohl auch so bleiben (ein ganz entscheidender Grund für mich, nicht so sehr in die M4-Technologie Zeit und Energie zu investieren, preemptives MT halte ich für eigentlich unverzichtbar). Da kommen dann ggf. nur noch Arduinos als Huckepack-Platinen per UART, I2C oder SPI oben auf den Raspi drauf.

Edit:
Zum Thema WiFi und Web:
Für WLAN und http verwende ich nur meine ESP8266, ebenfalls per Arduino IDE, denn da gibt es sehr mächtige WiFi-/Web-Server- und -Client Libs, sicher geht aber der ESP32 noch viel besser und leistungsfähiger - einen M4 würde ich dafür niemals nehmen. Auch der ESP8266 arbeitet übrigens gut als Huckepakplatine auf dem Raspi.

[alexander_ro]

Ich habe dann scheinbar das Talent immer die Libs zu finden die nicht gehen oder die Funktionen von denen zu verwenden die nicht richtig gehen.

So was funktioniert aber zumindest auf dem STM32L475:


#include "mbed.h"

#include <thread>
#include <atomic>
#include <chrono>
#include <iostream>
#include <string>

int main (int argC, char *argV[])
{
// Serielles Terminal initialisieren.
Serial pc(SERIAL_TX, SERIAL_RX);
pc.baud(115200);

auto func1 = [] { std::cout << "Hi Alexander" << std::endl; };
func1 ();

std::string strText1 = "Wie gehts Dir?";
auto func2 = [&] () { std::cout << strText1 << std::endl; };
func2 ();

// Das geht noch nicht "this_thread" kennt er nicht: std::this_thread::sleep_for (std::chrono::microseconds (100000));

std::string strText2 = "Gut danke ...";
auto func3 = [] (std::string& strText) { std::cout << strText << std::endl; };
func3 (strText2);

return 0;
}


Platformio.ini:


[env:disco_l475vg_iot01a]
platform = ststm32
board = disco_l475vg_iot01a
framework = mbed
upload_protocol = stlink

build_flags = -std=c++17


picoterm Ausgabe:


picocom v2.2

port is : /dev/ttyACM0
flowcontrol : none
baudrate is : 115200
parity is : none
databits are : 8
stopbits are : 1
escape is : C-a
local echo is : no
noinit is : no
noreset is : no
nolock is : no
send_cmd is : sz -vv
receive_cmd is : rz -vv -E
imap is :
omap is :
emap is : crcrlf,delbs,

Type [C-a] [C-h] to see available commands

Terminal ready
Hi Alexander
Wie gehts Dir?
Gut danke ...


Wenn ich das richtig sehe kümmert sich hier mbed nur um die Ausgabe auf das serielle Terminal. Leider tun die bei mbed wieder so als wenn die Welt nur Windows hätte und macht zwar den Linefeed aber nicht den Carriage Return. Deshalb sind die Zeilen dann eingerückt. Habe aber leider keine Ahnung was man da bei picocom umstellen muss damit es tut wie Windows bei Zeilenumbruch.

<Edit>
Das hat mir gerade jemand geflüstert: picocom /dev/ttyACM0 --imap lfcrlf -b 115200
So werden die Zeilen richtig untereinander ausgegeben.
</Edit>

[alexander_ro]

So gehts mit Wlan und Http Client:


#include <iostream>

#include "mbed.h"
#include "wifi.h"
/*------------------------------------------------------------------------------
Hyperterminal settings: 115200 bauds, 8-bit data, no parity

This example
- connects to a wifi network (SSID & PWD)
- displays the IP address and get webpage html code

This example uses SPI3 ( PE_0 PC_10 PC_12 PC_11), wifi_wakeup pin (PB_13),
wifi_dataready pin (PE_1), wifi reset pin (PE_8)
------------------------------------------------------------------------------*/

#define MBED_CONF_APP_WIFI_SSID "xyz"
#define MBED_CONF_APP_WIFI_PASSWORD "geheim"

Serial pc (SERIAL_TX, SERIAL_RX);

DigitalOut led(LED2);
AnalogIn adc_temp(ADC_TEMP);

//
// WLAN mit dem Hotspot verbinden.
//
int wifi_sample_run(void)
{
uint8_t IP_Addr[4];
uint8_t MAC_Addr[6];

// WLAN initialisieren
if (WIFI_Init() == WIFI_STATUS_OK)
{
std::cout << "WiFi initialisieren." << std::endl;

if (WIFI_GetMAC_Address(MAC_Addr) == WIFI_STATUS_OK)
{
std::cout << "Wifi Modul MAC Address: ";
std::cout << unsigned (MAC_Addr[0]) << ":";
std::cout << unsigned (MAC_Addr[1]) << ":";
std::cout << unsigned (MAC_Addr[2]) << ":";
std::cout << unsigned (MAC_Addr[3]) << ":";
std::cout << unsigned (MAC_Addr[4]) << ":";
std::cout << unsigned (MAC_Addr[5]) << std::endl;
}
else
{
std::cout << "ERROR: MAC-Adresse konnte nicht gelesen werden." << std::endl;
}

if (WIFI_Connect (MBED_CONF_APP_WIFI_SSID, MBED_CONF_APP_WIFI_PASSWORD, WIFI_ECN_WPA2_PSK) == WIFI_STATUS_OK)
{
std::cout << "WiFi Modul mit Hotspot verbunden." << std::endl;

if(WIFI_GetIP_Address(IP_Addr) == WIFI_STATUS_OK)
{
std::cout << "WiFi Modul IP-Adresse: ";
std::cout << unsigned (IP_Addr[0]) << ".";
std::cout << unsigned (IP_Addr[1]) << ".";
std::cout << unsigned (IP_Addr[2]) << ".";
std::cout << unsigned (IP_Addr[3]) << std::endl;
}
else
{
std::cout << "ERROR: WiFi Modul IP-Adresse konnte nicht gelesen werden." << std::endl;
return -1;
}
}
else
{
std::cout << "ERROR: WiFi Modul konnte nicht verbunden werden." << std::endl;
return -1;
}
}
else
{
std::cout << "ERROR: WiFi Modul konnte nicht initialisiert werden" << std::endl;
return -1;
}
return 0;
}

//
// Sende einen HTTP Get an den Server und lese die Server Antwort.
//
void WebClient (void)
{
// Parameter zu welchem Server verbunden werden soll.
uint16_t iPort = 80;
uint16_t iLocalPort = 3000;
uint8_t ipAddr[4] = { 10, 0, 0, 3 }; // Muss man mit der Server IP ersetzen.

// Mit dem Serve verbinden.
WIFI_Status_t wifiRc;
int32_t Socket = 0;
wifiRc = WIFI_OpenClientConnection (Socket, WIFI_TCP_PROTOCOL, "Name", ipAddr, iPort, iLocalPort);

if (wifiRc != WIFI_STATUS_OK)
{
if (wifiRc == ES_WIFI_STATUS_ERROR)
std::cout << "Connect zum HTTP-Server Fehler: ES_WIFI_STATUS_ERROR" << std::endl;

std::cout << "Conntect zum HTTP-Server fehlgeschlagen" << std::endl;
exit (0);
}
else
std::cout << "HTTP-Client Connect erfolgreich ..." << std::endl;

// Sende HTTP Request
static uint8_t http[1024];
strcpy ((char *) http, (char *) "GET / HTTP/1.1\r\n");
strcat ((char *) http, (char *) "Host: domain.de\r\n");
strcat ((char *) http, (char *) "\r\n");

uint16_t SentDataLength;
const int wifiWriteTimeout = 10000;
wifiRc = WIFI_SendData(0, (uint8_t *)http, strlen((char *)http), &SentDataLength, wifiWriteTimeout);

if ((wifiRc == WIFI_STATUS_OK) && (SentDataLength != strlen((char *)http)))
{
std::cout << "HTTP Request senden fehlgeschlagen" << std::endl;
wifiRc = WIFI_STATUS_ERROR;
exit (0);
}
else
std::cout << "HTTP Request '" << http << "' gesendet: " << SentDataLength << std::endl;

// Empfange Server Antwort
static uint8_t resp[1024];
uint16_t respLen;
const int wifiReadTimeout = 10000;
WIFI_ReceiveData (Socket, resp, 1200, &respLen, wifiReadTimeout);

if( respLen > 0)
{
std::cout << "HTTP-Client Server Antwort: " << resp << std::endl;
}
else
{
std::cout << "HTTP-Client: Server Antwort konnte nicht Empfangen werden." << std::endl;
}
}


int main()
{
int ret = 0;
led = 0;
pc.baud(115200);

std::cout << "Programm gestartet ..." << std::endl;

// Verbindung zum WLAN Hotspot herstellem
std::cout << "WLAN: connect" << std::endl;
ret = wifi_sample_run();

if (ret != 0)
{
std::cout << "WLAN: connect fehlgeschlagen" << std::endl;
return -1;
}

WebClient ();
}


Die platformio Ini ist wie oben angegeben.
Ich habe dazu das Paket benutzt:


# Lib: DISCO_L475VG_IOT01A_wifi installieren
# ID : 3438
pio lib install 3438