STM32 programieren mit platformio und mbed

[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