What use case(s) do you see for multi-threading?

[aentinger]

• Did you ever write a program/script in which you wanted to have multiple tasks running in parallel?
• If so, what was the purpose of the program? Was it difficult to achieve?
• Is there an example sketch created with Arduino_Threads that you want to share? If so you can upload it here.

[dsyleixa]

I am using std::thread (and pthread) for ESP32-Arduino and for Raspberry Pi (and others) successfully over all since decades for dozens of projects as stated and described here: arduino/language#2 (comment).
Usage e.g. for simultaneous LCD-output, UART, i2c, SPI-communication, GPIO r/w, sensor reading, motor controll, SLAM pathfinding etc...

A practical example for preemptive MT which is non-blocking although some working functions may hold on calculating continuously for long times without releasing by delay or sleep (e.g., Fibonacci calculatings) and about how MT is implemented by ESP32 std::thread see this one (one may make Serial.print() even clean non-overlapping by using std::mutex if one wishes) - I would expect kind of this also for Arduino_Threads:

// std::thread for ESP32, Arduino IDE

// ver 0.0.7 fibonacci, GPIO, blink, sort und main counter
// backup from github


#include <Arduino.h>
#include <thread>
#include <freertos/task.h>
#include <esp_task.h>

#ifndef LED_BUILTIN
#define LED_BUILTIN 13
#endif

using namespace std;

volatile static bool THREADRUN = true;

uint32_t fibonacci(int n) {
   if(n == 0) {
      return 0;
   } else if(n == 1) {
      return 1;
   } else {
      return (fibonacci(n-1) + fibonacci(n-2));
   }
}

void shellsort(int size, int* A)
{
   int i, j, increment;
   int temp;
   increment = size / 2;

   while (increment > 0) {
      for (i = increment; i < size; i++) {
         j = i;
         temp = A[i];
         while ((j >= increment) && (A[j-increment] > temp)) {
            A[j] = A[j - increment];
            j = j - increment;
         }
         A[j] = temp;
      }

      if (increment == 2)
         increment = 1;
      else
         increment = (unsigned int) (increment / 2.2);
   }
}

//--------------------------------------------------------------------
#define tpin1  11  // GPIO test pin digitalWrite
#define tpin2  12  // GPIO test pin digitalWrite
#define tpin3  10  // GPIO test pin digitalRead

int32_t test_GPIO() {   //
   volatile static bool w=false, r;

   uint32_t y;
   for (y=0; y<100000; y++) {
      digitalWrite(tpin1, w);
      w=!w;
      r=digitalRead(tpin3);
      digitalWrite(tpin2, w&!r);
   }   
   return 1;
}


//--------------------------------------------------------------------
void blinker_loop() {
   thread_local uint32_t counter = 0;

   vTaskPrioritySet( NULL, ESP_TASK_MAIN_PRIO ); // set Priority = main prio   
   Serial.println((String)"blinker_loop Current priority :" + uxTaskPriorityGet(NULL)+"\n");

   while(THREADRUN) {
      digitalWrite(LED_BUILTIN, HIGH);
      Serial.println((String)"\nblinker_loop (HIGH) counter: "+ counter+"\n");
      //this_thread::sleep_for(chrono::milliseconds(1000));
      delay(1000);

      digitalWrite(LED_BUILTIN, LOW);
      Serial.println((String)"\nblinker_loop (LOW) counter: "+ counter+"\n");
      //this_thread::sleep_for(chrono::milliseconds(500));
      delay(500);

      counter++;
      if(!THREADRUN) {
         Serial.println((String)"blink_loop terminated by THREADRUN");
      }
   }
}

//--------------------------------------------------------------------
void fibonacci_loop() {
   thread_local uint32_t counter = 0, i=0;

   vTaskPrioritySet( NULL, ESP_TASK_MAIN_PRIO ); // set Priority = main prio   
   Serial.println((String)"fibonacci_loop Current priority :" + uxTaskPriorityGet(NULL)+"\n");

   while(THREADRUN) {
      for(i=25; i<41; i++) {    // limits: test, debug
         if(!THREADRUN) {
            Serial.println((String)"fibonacci_loop terminated by THREADRUN");
            break;
         }
         Serial.println( (String)"\nfibonacci of "+i+"="+fibonacci(i)+"\n");
      }
      counter++;
      Serial.println((String)"\nfibonacci_loop counter: "+counter+"\n");
   }
}

//--------------------------------------------------------------------
void sort_loop() {
   static int array[1000];
   thread_local uint32_t counter = 0, i=0;

   vTaskPrioritySet( NULL, ESP_TASK_MAIN_PRIO ); // set Priority = main prio   
   Serial.println((String)"sort_loop Current priority :" + uxTaskPriorityGet(NULL)+"\n");

   while(THREADRUN) {
      Serial.println((String)"\nsort_loop counter: "+counter+"\n");

      for(i=0; i<1000; i++) {
         array[i]= random(0,65000);
      }
      shellsort(1000, array);
      for(i=0; i<1000; i+=50) { // abgekürzte Ausgabe  da Serial sehr langsam
         Serial.println((String)i + "="+array[i]+"\n");
      }
      counter++;
      if(!THREADRUN) {
         Serial.println((String)"sort_loop terminated by THREADRUN");
      }
   }
}

//--------------------------------------------------------------------
void GPIO_loop() {

   thread_local uint32_t counter = 0, i=0, timerms;
   vTaskPrioritySet( NULL, ESP_TASK_MAIN_PRIO ); // set Priority = main prio
   
   Serial.println((String)"GPIO_loop Current priority :" + uxTaskPriorityGet(NULL)+"\n");
   while(THREADRUN) {
      Serial.println((String)"\nGPIO_loop counter: "+counter);
      timerms = millis();
      test_GPIO();
      timerms = millis() - timerms;
      Serial.println((String)"\nGPIO test timerms=" + (String)timerms + "\n");
      counter++;
      if(!THREADRUN) {
         Serial.println((String)"GPIO_loop terminated by THREADRUN");
      }
   }
}

//--------------------------------------------------------------------

void control_loop() {
   volatile static uint32_t loop_counter = 0;

   vTaskPrioritySet( NULL, ESP_TASK_MAIN_PRIO ); // set Priority = main prio
   
   while(THREADRUN) {      
      Serial.println((String)"\nloop counter: " + loop_counter);
      delay(500);
      loop_counter++;
      if(loop_counter>40) {
         Serial.println("loop counter limit reached!  all threads terminate!");
         THREADRUN=false; // after 20sec
      }
   }
}

//--------------------------------------------------------------------
//--------------------------------------------------------------------
void setup() {
   Serial.begin(115200);
   delay(1000);

   pinMode(LED_BUILTIN, OUTPUT);
   pinMode(tpin1, OUTPUT);
   pinMode(tpin2, OUTPUT);
   pinMode(tpin3, INPUT_PULLUP);


   thread thread_0 (control_loop);
   thread thread_1 (blinker_loop);
   thread thread_2 (fibonacci_loop);
   thread thread_3 (sort_loop);
   thread thread_4 (GPIO_loop);

   Serial.println((String)"\n all threads being started, now waiting for all being terminated and to join main thread \n");  // <<<<<<  

   thread_0.join();
   thread_1.join();
   thread_2.join();
   thread_3.join();
   thread_4.join();

   Serial.println((String)"\nall threads joined, program terminated\n");  // <<<<<<  
}


//--------------------------------------------------------------------
void loop() { // empty placeholder for Arduino compatibility
}