std::thread für ESP32 unter Arduino IDE zum Laufen zu kriegen...?

[HaWe]

hahahaha, ich lach mich tot.....

JA!!!

sogar ohne static und ohne thread_local:

#include <Arduino.h>
#include <thread>
#include <chrono>

#ifndef LED_BUILTIN
#define LED_BUILTIN 13
#endif

const auto one_sec = std::chrono::seconds
{
    1
};

void counter_loop() {
    uint32_t counter = 0;
    while(true) {
        Serial.print("counter_loop: ");
        Serial.println(counter);
        std::this_thread::sleep_for(one_sec);
        counter++;
    }
}

void blinker_loop() {
    uint32_t counter = 0;
    while(true) {
        digitalWrite(LED_BUILTIN, HIGH);
        Serial.print("blinker_loop (HIGH) counter: ");
        Serial.println(counter);
        std::this_thread::sleep_for(one_sec);
        
        digitalWrite(LED_BUILTIN, LOW);
        Serial.print("blinker_loop (LOW) counter: ");
        Serial.println(counter);
        std::this_thread::sleep_for(one_sec);
        counter++;
    }
}

std::thread counter_loop_thread(counter_loop);
std::thread blinker_loop_thread(blinker_loop);
    
void setup() {
    Serial.begin(115200);
    pinMode(LED_BUILTIN, OUTPUT);
    
}

uint32_t main_loop_counter = 0;
void loop() {
    main_loop_counter++;
    Serial.print("main loop: ");
    Serial.println(main_loop_counter);
    delay(10000);
}

main loop: 1
counter_loop: 1
blinker_loop (LOW) counter: 0
blinker_loop (HIGH) counter: 1
counter_loop: 2
counter_loop: 3
blinker_loop (LOW) counter: 1
blinker_loop (HIGH) counter: 2
counter_loop: 4
counter_loop: 5
blinker_loop (LOW) counter: 2
blinker_loop (HIGH) counter: 3
counter_loop: 6
counter_loop: 7
blinker_loop (LOW) counter: 3
blinker_loop (HIGH) counter: 4
counter_loop: 8
counter_loop: 9
blinker_loop (LOW) counter: 4
blinker_loop (HIGH) counter: 5
counter_loop: 10
main loop: 2
counter_loop: 11
blinker_loop (LOW) counter: 5
blinker_loop (HIGH) counter: 6
counter_loop: 12
counter_loop: 13
blinker_loop (LOW) counter: 6
blinker_loop (HIGH) counter: 7
counter_loop: 14
counter_loop: 15
blinker_loop (LOW) counter: 7
blinker_loop (HIGH) counter: 8
counter_loop: 16
counter_loop: 17
blinker_loop (LOW) counter: 8
blinker_loop (HIGH) counter: 9
counter_loop: 18
counter_loop: 19
blinker_loop (LOW) counter: 9
blinker_loop (HIGH) counter: 10
counter_loop: 20
main loop: 3
counter_loop: 21

vielen Dank an euch beide, das ist jetzt echt ne super Basis um weiterzumachen!
Ein Riesen-Schritt für die Menschheit!
großartig, danke!

[Ceos]

sogar ohne static und ohne thread_local:

wie gesagt, thread_local ist garnicht falsch, erspart dir später womöglich kuriose bugs ... ich würde es immer drin lassen!

[HaWe]

okidoki, danke!

- - - Aktualisiert - - -

PS,
interessanter Effekt, gerade bemerkt:
in der blinker_loop zählt der counter zwischen den sleeps und dem LED ON/OFF-Paar weiter, obwohl ich hier denselben counterwert für ON und OFF erwartet hätte, bis zum nächsten loop-Durchlauf für das nächste ON/OFF-Paar

[Ceos]

hast du dazu einen aktualisierten code ?

[HaWe]

ist immer noch der von #7 !

- - - Aktualisiert - - -

gerade getestet:
thread_local uint32_t counter = 0;
macht hier auch keinen Unterschied

[Ceos]

ja ... sorry ... hab ich nicht gesehen

interessante ausgabe, gebe ich zu ... es wäre mal interessant zu erfahren wie der zeitliche ablauf bei der ausgabe aussieht! ich vermute hier das problem!

benutze mal irgend einen timer mit einer auflösung im wenigstens 100tel Sekunden bereich und speichere vor und nach jedem sleep jeweils einmal die zeit und gib die zeiten plus die aktuelle zeit auch als print aus

also quasi print("Jetzt: %d Vorher: %d Nachher %d",timer.now(), beforesleep, aftersleep)

so kann man erstmal prüfen ob der sleep vernünftig funktioniert und dann ob der print hier irgendwelche delays verursacht

ich denke dass die ausgaben bei dir nicht chronologisch korrekt ausgegeben werden

[HaWe]

hmmm... könnte vlt...
andererseits wird in den blinker_thread zwischen dem ON/OFF-Paar gar nicht inkrementiert, also egal, wann das ausgegeben wird, es müsste 1 ON/OFF-Paar IMO erwartungsgemäß IMMER mit demselben gemeinsamen counter-Wert erscheinen...
...oder?

[HaWe]

update:
mutex ist doch drin, braucht nur zusätzlich

#include <mutex>

was ich nicht wusste,
dann klappt jetzt auch

std::mutex print_mutex;

void myPrint(String str) // String: Arduino API  // C++: std::string
{
    print_mutex.lock();
    Serial.println(str);
    print_mutex.unlock();
}

[HaWe]

es gibt hier noch einen Bug oder Issue, wie man thread prios richtig setzt - bisher brachten alle Vorschläge noch keine Lösung.
Man muss nämlich die thread prios der main loop prio angleichen, wenn beide ohne delays parallel laufen sollen
(std::threads laufen nämlich per prio=5 per default, main loop nur bei default prio=1!!):

esp_pthread_cfg_t cfg;
  esp_pthread_get_cfg(&cfg);
  cfg.prio=1;
  esp_pthread_set_cfg(&cfg);

funktioniert nicht, weil anfangs cfg noch keine Werte enthält und daher einen Fehler zurückgibt,

und

  esp_pthread_cfg_t cfg;
  if (esp_pthread_get_cfg(&cfg) != ESP_OK) {
      cfg = esp_pthread_get_default_config();
  }
  cfg.prio=1;
  if (esp_pthread_set_cfg(&cfg) != ESP_OK) {
      printf("esp_pthread_set_cfg failed\n");
      abort();
  };

funktioniert auch nicht, weil die hier verwendete Funktion
esp_pthread_get_default_config();
nicht gefunden wird.

siehe Topic-Posts u.a.
https://github.com/espressif/ESP8266...SDK/issues/609
https://github.com/espressif/esp-idf...ment-496157019
und folgende...

betroffene libs am ehesten wohl
https://github.com/espressif/ESP8266...ts/pthread/src


Hat jemand eine idee, wie es richtig geht?

[HaWe]

update:
der ESP32 scheduler arbeitet tatsächlich nur eingeschränkt preemptiv, u.a. da er vom FreeRTOS und seinem Watchdog abhängig ist, der nur begrenzt ausgeblendet/resetted werden kann,sobad ein Thread "stalled", und dann das gesamte System sich aufhängt.
Außerdem scheint es dann auch Probleme mit threads zu geben, die auf den 2 cores laufen und dann (IIUC) ebenfalls zu Konflikten führen.

update:
trotz hoffnungsvoller Nachrichten in ESP32 github repo: noch immer nicht gelöst