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

[Ceos]

das entspricht aber ziemlich gut meiner Vermutung, die prints kommen irgendwie durcheinander

zwischen der ersten und 2ten Zahl pro Sleep ist immer sauber 1000 differenz

aber wenn wir mal die letzten paar ausgaben ansehen siehst du dass 2 mal hintereinander "Sleep1" mit jeweils einer Sekunden Abstand ausgegeben wird und "Sleep2" und "Sleep3" immer direkt hintereinander obwohl man eher erwarten würde dass es immer 1 -> 2 -> 1 -> 3 -> 1 -> 2 gehen sollte

Das heißt das der print scheinbar in einer anderen Reihenfolge ausgegeben wird

ich bin nur etwas überrascht dass die millis immer so exakt gleich sind! Ich hatte gehofft dass die Ausgaben da wenigstens minimal um 1ms versetzt sind um die tatsächliche Ausführungszeit zu sehen

----

leider kann ich jetzt auch erstmal nicht weiter mithelfen, ich bin das wochenende offline unterwegs und die reise geht gleich los

[HaWe]

update: der Code jetzt hier scheint besser zu laufen:

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

code:

```

// std::thread for ESP32, Arduino IDE

#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() {
    thread_local uint32_t counter = 0;
    while(true) {
        Serial.print("counter_loop: ");
        Serial.println(counter);
        std::this_thread::sleep_for(one_sec);
        counter++;
    }
}

void blinker_loop() {
    thread_local 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::unique_ptr<std::thread>  counter_loop_thread;
std::unique_ptr<std::thread>  blinker_loop_thread;

void setup() {
  Serial.begin(115200);
  //debug
  delay(2000);
  
  counter_loop_thread.reset(new std::thread(counter_loop));
  blinker_loop_thread.reset(new std::thread(blinker_loop));
}


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

```

- - - Aktualisiert - - -

update2:
gleich gutes Ergebnis bei dieser Code-Implementierung:

std::thread *counter_loop_thread;
std::thread *blinker_loop_thread;


void setup() {
  Serial.begin(115200);
  //debug
  delay(2000);
  counter_loop_thread = new std::thread(counter_loop);
  blinker_loop_thread = new std::thread(blinker_loop);
}

[shedepe]

Was du suchst ist ein std::mutex (in der Hoffnung dass der implementiert wurde). Ein Mutex ist eine Synchronisierungsobjekt zwischen Threads.
D.h. du brauchst in etwas sowas:

std::mutex m_lock;

void myWrite(std::string str)
{
    m_lock.lock();
    Serial.print(str);
    m_lock.unlock();
}

[HaWe]

Was du suchst ist ein std::mutex (in der Hoffnung dass der implementiert wurde). Ein Mutex ist eine Synchronisierungsobjekt zwischen Threads.
D.h. du brauchst in etwas sowas:

std::mutex m_lock;

void myWrite(std::string str)
{
    m_lock.lock();
    Serial.print(str);
    m_lock.unlock();
}

danke für den wertvollen Tipp, das ist sehr hilfreich!
Für den Augenblick geht es ja auch ohne (s. Serial logs), aber wenn es mal zeitkritischer wird: auf jeden Fall dann!
Danke!

Ich gucke später auch mal, ob der tatsächlich implementiert wurde!

PS:
auch für dich fände ich es klasse, wenn du dir mal ne portable IDE installieren könntest!