pthread-Task als Methode einer C++ Klasse?

[HaWe]

vielen Dank, dass ich mehere Einzelfunktionen einsparen will ist kar, das war ja meine Absicht, dennoch sehe ich jetzt schon ein wenig klarer.
Dennoch ist das mit den doppelten Pointern un dem "casting" schon seeehr kompliziert...
Außerdem ist mir nicht klar, wie jetzt genau die Verknüpfung erfolgen muss von der aufrufenden simplen API Funktion bis hin zum Task:

der vereinfachende Wrapper

inline void RotatePIDtoTarget(char port, long Target, float RotatSpeed) {
   RotatePID(port, Target, RotatSpeed, false);
   Wait(1);
}

ruft auf die ein wenig komplexere Interface-Funktion inkl. dem Target-Haltemodus:

RotatePID(port, Target, RotatSpeed, false);

und hier wird nach Setzen der PID Laufzeit-Variablen der PID Task gestartet:

safecall void RotatePID(char port, long Target, float RotatSpeed, char cont) {
  if (port==OUT_A) {

    //...
    //...

    PID_A.runstate=1;                // set runstate: PID active

    // custom init PID_A
    PID_A.target =Target;                   // assign target
    PID_A.tarpwm =RotatSpeed;               // assign rotation speed
    PID_A.cont=cont;                        // cont vs. hit once

    // Reset PID control defaults
    PID_A.outp    =0;                // PID control output value
    PID_A.maxout  =100;              // absolute max possible output (max pwr)
    PID_A.read    =0;                // current reading
    PID_A.err     =0;                // current error
    PID_A.integr  =0;                // integral of errors
    PID_A.speed   =0;                // current speed


    start task_PID_A;
  }

  else
  if (port==OUT_B) {
  //...

statt der if-Schleifen für jeden Motor käme jetzt dein expliziter PID-Aufruf mit Motornummer als Parameter -
wie würde es aber denn heißen müssen, wenn ich den PID pthread task innerhalb deiner neuen Struktur starten will?

[botty]

Na ja,
zuerst must du die PIDinit ergänzen:

void PIDinit(void)  {

  PID_A.tid = 0;
  PID_A.motor_id = OUT_A;
  
  // für alle Variablen und dann natürlich die anderen Elemente der Struktur.

}

Die Signaturen deiner High-Level Funktionen ändern sich nur im ersten Element, die anderen Parameter kannst du 1:1 übernehmen z.B.:

inline void RotatePIDtoTarget(struct PIDstruct *pid, long Target, float RotatSpeed) {
   RotatePID(pid, Target, RotatSpeed, false);
}

wobei du festlegen musst ob evtl. Fehlercodes wieder hochgereicht werden? Hier spar ich mir das mal.

Deine zentrale RotatePID sähe dann so aus:

void RotatePID(struct PIDstruct *pid, long Target, float RotatSpeed, char cont) {
  // Nullzeiger?
  if( ! PID ) {
    fprintf(stderr, "RotatePID Null Zeiger!\n");
    return;
  }

  // Laeuft der PID in einem Thread bereits?
  if( pid->tid != 0 ) {
    fprintf(stderr, "RotatePID - PID schon gestartet!\n");
    return;
  }

  // Koennte weg
  PID_A.runstate=1;                // set runstate: PID active

  // custom init PID
  pid->target =Target;                   // assign target
  pid->tarpwm =RotatSpeed;               // assign rotation speed
  pid->cont=cont;                        // cont vs. hit once

  // Reset PID control defaults
  pid->outp    =0;                // PID control output value
  pid->maxout  =100;              // absolute max possible output (max pwr)
  pid->read    =0;                // current reading
  pid->err     =0;                // current error
  pid->integr  =0;                // integral of errors
  pid->speed   =0;                // current speed

  // Thread starten
  if(pthread_create(&pid->tid, 0, pid_calc, pid)) {
    perror("RotatePID");
    pid->tid = 0;
    return;
  }
}

Stoppen ginge dann so

void StopPIDcontrol (struct PIDstruct *pid, int cancel) {

  if (pid->tid) { // stop PID task if already running
    Off(pid->motor_id);

    if(cancel)
       pthread_cancel(pid->tid);

    pthread_join(pid->tid, 0);
    pid->tid = 0; // wichtig!

    pid->cont=false;
    pid->runstate=0;
  }
}

Die verwendung sähe dann etwa so aus:

struct PIDstruct PID_A;

int main(int argc, char** argv) {
  PIDinit();

  // Wartend
  RotatePIDtoTarget(&PID_A, 25, 0.4); // Sinvolle Werte kennst du besser als ich ;)
  StopPIDcontrol(&PID_A, 0);

  // Abbrechend
  RotatePIDtoTarget(&PID_A, 35, 0.3);

  sleep(2);

  StopPIDcontrol(&PID_A, 1);

  return 0;
}

Ich habe diesen Code nicht durchkompiliert, hoffe aber das er trotzdem deine Fragen klärt.
Noch ein Wort zur pid_calc Funktion: In ihr solltest du alle paar Schritte, insbesondere in Schleifen, pthread_testcancel() aufrufen, damit ein cancel auch wirklich stattfinden kann.

Gruss

botty

[HaWe]

hallo botty,
ganz herzlichen Dank für deine viele Mühe und deine ausführlichen Codebeispiele. Leider verstehe ich im Moment doch noch gar nichts über die ganzen neuen kryptischen Funktionen, Aufrufe und Konstruktionen, insb. noch nicht einmal, warum ich -> statt . verwenden muss.

Tatsächlich möchte ich allerdings im Aufruf auch nur eine Motornummer übergeben (0,1,2,3 oder per
#define OUT_A 0
#define OUT_B 1
etc.
und keine PID-Struktur.
Der Sinn ist, dass meine neue C Syntax an NXC-API Befehle angelehnt sein soll, denn das Ziel ist es auch, Lego Roboter für bisherige Lego NXT und NXC Nutzer mit einer Raspi API zu programmieren und zu betreiben, was bisher nicht möglich ist bei dem völlig fehlkonstruierten neuen Lego EV3-SoC: also quasi als Konkurrenz-Gegenentwurf . Ich habe auch schon mit so einem Gegenprojekt angefangen, PID wäre der nächste Schritt hierfür: http://www.mindstormsforum.de/viewtopic.php?f=78&t=8851
NXC (bzw. Vorgänger NQC) ist den Lego Nutzern seit fast 20 Jahren bekannt, und hier werden ebenfalls Motor Steuerbefehle verwendet wie
motorcommand ( motorNr, rotationDegrees, pwm)

Ich bin für deine neuen Konstrukte aber einfach noch zusehr auf dem absoluten C Anfängerlevel, als dass ich das jetzt wirklich umsetzen könnte. Ich fürchte im Moment, dass meine 3 -10 Einzel Tasks wie bei NXC doch die einzige Möglichkeit sind, das ganze PID Projekt auf dem Raspi für mich zu verwirklichen.

Vlt könntest du mir aber doch quasi als minimal kleinst-möglichen Lernschritt erklären, warum ich hier oft -> statt . verwenden muss?
Bei Arduino und auch sonst nutzt man doch auch den . z.B.
Serial.print()
Serial.available()
Wire.begin()

Und Variablenwerte in Strukturen meine ich auch schon mit Punkt gesehen zu haben

mystruc.fvar=1.234;

[botty]

Wenn du mit Zeigern arbeitest musst du dir im Klaren darüber sein, dass es immer zwei Speicherbereiche zu unterscheiden gibt. Der eine ist der Speicherbereich in dem die eigentlichen Daten stehen, die andere Speicherzelle ist der Zeiger, dessen Wert die Adresse des anderen enthält.
Wenn du jetzt eine Variable von einem einfachen Basistypen wie int, char oder double etc. hast und über den Zeiger den Wert ändern willst, muss der Compiler unterscheiden können ob du den Wert des Zeigers oder den Wert auf den den er zeigt ändern möchtest.

int aval = 5;

int main(void) {
  int *ptr;

  ptr = &aval;

  printf("Der Wert an der Adresse %p ist %d\n", ptr, *ptr);

  *ptr = 7;

  printf("Der Wert an der Adresse %p ist %d\n", ptr, *ptr);

  return 0;
}

Für einfache Typen ist das schlicht. "ptr = &aval" weisst dem Zeiger die Adresse von aval zu, während " *ptr = 7 " den Zeiger dereferenziert und in den Speicher dieser Adresse den Wert 7 hineinschreibt. Zwei gänzlich unterschiedliche Dinge.

Bei Strukturen kommt jetzt hinzu, dass der Compiler Offsets für die Elemente der Struktur berechnen muss, damit er den korrekten Speicherbereich liesst bzw. beschreibt.
Bei einer Variablen weiss der Compiler zum Übersetzungszeitpunkt wo der Start der Variablen ist und kann diese Offsets absolut oder relativ berechnen.

#include <stdio.h>

struct vec2d {
  double x, y;
};

struct vec2d ein_vec;

int main(void) {
  ein_vec.x = 3.0;
  ein_vec.y = 7.0;

  printf("Adressen von ein_vec=%p, ein_vec.x=%p, ein_vec.y%p\n", &ein_vec, &ein_vec.x, &ein_vec.y);

  return 0;

}

Verwende ich einen Zeiger auf eine Variable einer Struktur, dann kennt der Compiler diesen Startpunkt nicht und ich brauche einen Mechanismus ihm diesen mitteilen zu können. Der "->" sagt also aus: in der Zeigervariable findest du die Startadresse, nimm die und berechne von da an. Während bei Variablen der Compiler die Verantwortung für den Start hat, habe ich als Programmierer die Verantwortung bei Zeigern den richtigen Startpunkt dem Compiler mitzuteilen.

#include <stdio.h>

struct vec2d {
  double x, y;
};

struct vec2d ein_vec;

int main(void) {
  struct vec2d *vptr;

  vptr = &ein_vec;

  vptr->x = 3.0;
  vptr->y = 7.0;

  printf("Adressen von vptr=%p, ein_vec=%p\n", vptr, &ein_vec);

  /* Fehler gibt SEGFAULT */
  vptr = 0;
  vptr->x = 3.0;
  vptr->y = 7.0;

  return 0;

}

An die Adresse 0x00000000 darf man nichts schreiben.

Falls dir die Erklärungen nicht so ganz einleuchten, solltest du dann vielleicht doch nochmal in ein gutes C-Buch reinschauen und dort die Erklärungen über Zeiger durchgehen. Mir fehlt im Erklären die Übung. Nichts desto trotzt sind Zeiger ein wichtiges und mächtiges Werkzeug in der C-Programmierung.

Warum ich die überhaupt benutzen wollte hatte einen bestimmten Grund:
Bei Threads muss man immer aufpassen, dass man sich keine Wettbewerbsbedingungen einfängt, sprich ein Thread in Daten eines anderen hineinschreibt. Obwohl ich erstmal globale Variablen als Speicherort gewählt hatte, werden die einzelnen PIDs dadurch isoliert, dass in den Threads immer nur auf eine Variable über den zugehörigen Zeiger zugegriffen wird (das wäre selbst so, wenn ich alle in einem Feld anordnen würde.). Diese Zeiger liegen auf dem Thread lokalem Stack, sind nach Aussen nicht sichtbar.
Das war die Idee.

Gruss
botty

[HaWe]

super, ganz tolle Erklärung, habe jetzt eine Menge Neues kapiert. Ganz herzlichen Dank !

[HaWe]

@botty:
habe mir jetzt die letzten Tage deinen Vorschlag noch ein paar mal genauer angesehen und überdacht, etwas herumprobiert und die bereits in meiner "LegoPi" bestehende Raspi- Motorstuktur durch die PID-Parameter aufgebohrt:

//*************************************************************
// motor API
//*************************************************************

#define  MAXMOTORS          10    // maximum number of motors
#define  MAXMOTORSLOCAL      2    // maximum number of local motors
#define  MAXPWMRANGE       255    // maximum software-pwm range (0-255)

// motor control structure

typedef struct  {   
                // electrical motor pins
      uint8_t   pind1, pind2, pinpwm;    // dir + pwm L293 H-Bridge type
      uint8_t   pinQa, pinQb;            // rotary enc pins Qa,Qb
     
                // pwm and encoder values
      int16_t   dirpwm;     
      int32_t   motenc, oldenc;          // rotary encoder values
      
                // PID    
      pthread_t tid;
      int16_t   motorID;      
                // PID custom target values
      int32_t   target;                  // set target
      int16_t   tarpwm;                  // motor target speed
                // PID custom regulation parameters
      double    P;                       // P: basic propotional to error
      double    I;                       // I: integral: avoid perish
      double    D;                       // D: derivative: avoid oscillating
      double    precis;                  // error precision to target
      int16_t   regtime;                 // PID loop time
      double    damp;                    // damp the integral memory
      int8_t    cont;                    // target: continue or hit once
                // PID internal control variables
      int16_t   runstate;                // monitors runstate
      int16_t   outp;                    // PID control output value
      int16_t   maxout;                  // max output (max motor pwr)
      int32_t   read;                    // current sensor reading
      double    err;                     // current error
      double    integr;                  // integral of errors
      double    speed;                   // current speed
     
} tEncMotor;


tEncMotor motor[MAXMOTORS];

3 Fragen dazu:
1) da ich jetzt alles statisch in einem Array deklariert habe: käme man jetzt überwiegend ohne die Pointerpfeile -> aus ?
2) da jede einzelne Motorstruktur über den Platz im Array definiert ist (motor[0] für motorID=0) : braucht man dann noch die Strukturvariable motorID?
3) kann man eine zusätzliche Variable im pthread-Aufruf übergeben, indem man die Motornummer mit übergibt?
bisher läuft mein pthread Aufruf immer per
pthread_create(&threadID, NULL, threadname, NULL);
wofür man die 2 NULLs braucht, ist mir z.B. auch noch unklar, vlt kann man die ein oder andere verwenden - und würde das die Sache einfacher machen?

- - - Aktualisiert - - -

ps,

der API Aufruf
RotatePID(port, Target, RotatSpeed, false);

würde dann die folgende Funktion aufrufen, die wieder nach Setten der Variablen einen pthread task starten müsste..... (????) :

 void RotatePID(char port, long Target, float RotatSpeed, char cont) {
    motor[port].runstate=1;                // set runstate: PID active
    // custom init PID [port]    
    motor[port].target =Target;                   // assign target
    motor[port].tarpwm =RotatSpeed;               // assign rotation speed
    motor[port].cont=cont;                        // cont vs. hit once
    // Reset PID control defaults
    motor[port].outp    =0;                // PID control output value
    motor[port].maxout  =100;              // absolute max possible output (max pwr)
    motor[port].read    =0;                // current reading
    motor[port].err     =0;                // current error
    motor[port].integr  =0;                // integral of errors
    motor[port].speed   =0;                // current speed

    // <<<<<<  
    // nur wie wäre das hier dann richtig zu implementieren ????
    // threadname ist ja für jeden Motor immer ein anderer ????  
    // wäre hierfür eine tEncMotor Hilfsvariable  char[12]  tEncMotor.thrnamebuf hilfreich ???? 
    // ("PIDthread00"... "PIDthread99", könnte man beim Initialisieren setten  ????) 
    // aber schreiben will ich ja für alle nur 1x ein einziges PID-Funktionstask-Muster ????
    // >>>>>>

    pthread_create(& motor[port].tid, NULL??,  motor[port].thrnamebuf, NULL??); 



}

[botty]

Hi,

die erste Frage hast du dir schon selbst beantwortet. Den Dereferenzierungsoperator "->" brauchst du nicht mehr, wenn du mit dem Array von Strukturen arbeitest. Du musst nur den Index für einen Motor als Parameter in die Thread-Main bekommen, indem deine PID-Kalkulationen sind.

Zu deiner zweiten Frage: das Element kannst du weglassen denn wir werden diese id als index übergeben.

Zu deiner letzten Frage:

schau mal die Signatur der pthread_create genau an (mit "$> man pthread_create" in 'nem Terminal unter Linux gibt's die Erklärungsseite zu sehen):

int pthread_create(pthread_t *thread,
                          const pthread_attr_t *attr,
                          void *(*start_routine) (void *),
                          void *arg);

Parameter eins ist ein Zeiger auf das pthread Handle. So wie in deinem RotatePID-Beispiel passt das schon mal.
Parameter zwei ist ein unveränderlicher Zeiger auf eine Attributstruktur. Es gibt paar, das wichtigste ist das deine Threads mit pthread_cancel sich unterbrechen liessen. Da das ein Default-Wert ist und die anderen Attribute erstmal nicht wichtig sind, kannst du hier eine 0 oder NULL reingeben, was heist, das die Defaults verwendet werden.
Parameter drei ist jetzt der Zeiger auf die Funktion, welche die Thread-Main sein soll. In deinem Fall gibst du da einfach den Namen der PID-Kalkulationsroutine an (die ist ja wohl für alle gleich?).
Parameter vier ist ein Zeiger ohne konkreten Datentypen, also void. Da Zeiger in C immer vorzeichenlose, integrale Datentypen sind können wir hier ausnahmsweise den Wert des Zeigers als unsigned int für den Index in das Array missbrauchen und so sicherstellen, das ein Thread immer nur auf ein bestimmtest Element des Arrays zurgreifen wird.

Der Erzeugungsaufruf in RotatePID sähe also so aus:

pthread_create( &motor[port].tid,  // id speichern in dem dazugehörigen Array-Element
                       0,                    // Default Attribute (threads cancelbar)
                       pid_calc,           // Name der PID-Kalkulationsroutinge
                       (void*)port);     // der Index des Array-Elements für eine PID Struktur, die mit dem Motorindex gleich ist. 
                                             // Der cast ist notwendig, sonst meckert der Compiler.

in der "pid_calc" müssen wir dann den Wert des Zeigers einmal am Anfang in einen "unsigned int" casten und diese Variable verwendest du bei den Arrayzugriffen und in deinen Unterfunktionen als Wert für den port Parameter.
Die Signatur ist bindend!:

void *pid_calc(void *arg) {
  // Was immer du für Variablen brauchst

  // Zeigerwert in Arrayindex wandeln.
  unsigned port = (unsigned)arg;

  // Nur als sinnloses Bsp.
  motor[port].P = 0.4;

  // Was immer du rechnen magst.

  pthread_exit(0);
}

Wenn du einen anderen Namen verwenden willst, musst du nur darauf achten das die Routine "void*" als Rückgabewert hat und es genau einen Parameter gibt mit "void*" als Typ.

void* welcher_name_auch_immer(void *arg) { ... }

Das war's.

Gruss
botty

P.S. leider sind die Formatierungen in den code-Tags verrutscht, hoffe es ist trotzdem lesbar.

[HaWe]

ok, noch immer ein paar Verständnisprobleme:

zu pid_calc....:

bisher verwende ich ja diese Task-Funktion hier (in 3 Varianten, ab jetzt natürlich einheitlich 1x für alle):
(ich HASSE ES, dass hier nie Codetags im Antwort-Editor dabei sind!!! )

task task_PID_A() {
  float aspeed, damp, PWMpwr, readold, errorold, tprop;
  long  readstart, cmax, cmin;                         // for monitoring
  long  starttime, runtime, clock, dtime;              // timer
  char  regloop;

  PID_A.runstate = 0x10;                               // reg state: RAMPUP
  PID_A.read     = (MotorRotationCount(OUT_A));        // get current encoder reading
  PID_A.err      = PID_A.target - PID_A.read;          // error to target

  readstart      = PID_A.read;
  regloop        = 1;



#ifdef debug_PID_A
  //............................................................................
  // init variables for graph output
  ClearScreen();
  DisplayMask();


  int timex, oldtx, oldy=15, pwm0=15;           // values for graphic screen

  float scrXratio, scrYratio;

  scrXratio=abs(PID_A.err)/8;
  if(PID_A.target<50) scrXratio=abs(PID_A.err)/4;

  scrYratio=abs(PID_A.err)/40;
  //............................................................................
#endif

  damp=0;                                 // damp the integral memory

  starttime= CurrentTick();


  // appoach target
  _Astart:
  PID_A.runstate = 0x10;                  // run state: RUNNING

  do {

    dtime    = CurrentTick() - clock;
    clock    = CurrentTick();
    runtime  = clock - starttime;
    tprop    = dtime/20.0;

    if ((PID_A.err==errorold)&& (abs(PID_A.err)>PID_A.precis)) damp=1;    // stalling
    else
    damp=PID_A.damp;

    PID_A.integr = (damp * PID_A.integr) + PID_A.err;

    if((PID_A.integr) > 3*PID_A.maxout) PID_A.integr = 3*PID_A.maxout; // cut away
    else
    if((PID_A.integr) <-3*PID_A.maxout) PID_A.integr =-3*PID_A.maxout;

    PWMpwr= (PID_A.P*PID_A.err) + (PID_A.I*PID_A.integr)*tprop + (PID_A.D*(PID_A.err-errorold))/tprop;


    if(PWMpwr >  PID_A.maxout) PWMpwr=  PID_A.maxout;   // forward maxout
    else
    if(PWMpwr < -PID_A.maxout) PWMpwr= -PID_A.maxout;   // reverse maxout


    PID_A.speed= (PID_A.read-readold)*100/dtime;  // rotat speed [degrees/100ms]

    aspeed = abs(PID_A.speed) ;

    if (aspeed > PID_A.tarpwm)  {
        PWMpwr = sign(PWMpwr)*PID_A.tarpwm;
    }

    PID_A.outp = round(PWMpwr);

#ifdef debug_PID_A
    //..........................................................................
    //  for graph output
    timex= runtime/scrXratio;
    PointOut(timex,(PID_A.read-readstart)/scrYratio);
    LineOut(oldtx, oldy, timex, pwm0+PID_A.speed*0.3);

    oldtx=timex; oldy=pwm0+PID_A.speed*0.3;
    //..........................................................................
#endif


    //**************************************************************************
                                                   // PID regulation !
    OnFwd(OUT_A, (PID_A.outp));                         // action !
    Wait(PID_A.regtime);                                // wait regulation time

    //**************************************************************************

    readold     = PID_A.read;                           // save old sensor
    errorold    = PID_A.err;                            // save old error

    PID_A.read  = (MotorRotationCount(OUT_A));          // get new encoder value
    PID_A.err   = PID_A.target-PID_A.read;              // new error to target

    if (PID_A.read>cmax) cmax=PID_A.read;               // monitor overshooting
    else
    if (PID_A.read<cmin) cmin=PID_A.read;               // monitor overshooting

    if ((PID_A.cont)&& (abs(PID_A.err)<=PID_A.precis)) PID_A.runstate = 0x60;
    else PID_A.runstate = 0x20;

#ifdef debug_PID_A
    //..........................................................................
    printf1(68, 48,"%-5d"   , cmax);
    printf1(68, 40,"%-5d"   , cmin);
    printf1(68, 32,"%-5d"   , PID_A.read);
    //..........................................................................
#endif

    if (PID_A.cont) continue;
    if (abs(PID_A.err)<=PID_A.precis) { regloop +=1 ; PID_A.runstate = 0x40; }

  } while ((abs(PID_A.err)>=PID_A.precis) && (regloop<=5));  // target reached

  Off(OUT_A);                                      // finished - brake motor
  PID_A.runstate = 0x40;                           // run state: RAMPDOWN
  PID_A.outp=0;

  Wait(50);
  PID_A.read = MotorRotationCount(OUT_A);
  regloop=1;

  if (PID_A.read>cmax) cmax=PID_A.read;            // detect overshooting
  if (PID_A.read<cmin) cmin=PID_A.read;            // detect overshooting
  PID_A.err = PID_A.target-PID_A.read;


#ifdef debug_PID_A
  //............................................................................
  printf1(68, 56,"%-5d"    , PID_A.target);
  printf1(68, 48,"%-5d"    , cmax);
  printf1(68, 40,"%-5d"    , cmin);
  printf1(68, 32,"%-5d"    , PID_A.read);
  printf1(56, 24,"P %5.2f" , PID_A.P);
  printf1(56, 16,"I %5.2f" , PID_A.I);
  printf1(56,  8,"D %5.2f" , PID_A.D);
  //............................................................................
#endif


  if ((abs(PID_A.err)>PID_A.precis))  {goto _Astart;}



#ifdef debug_PID_A
  //............................................................................
  PointOut(timex,PID_A.read/scrYratio);
  LineOut(oldtx, oldy, timex, pwm0);
  LineOut(timex+2,PID_A.target/scrYratio, timex+10, PID_A.target/scrYratio);
  LineOut(timex+2, pwm0, timex+10, pwm0);
  //............................................................................
#endif

  PID_A.runstate=0;
  Wait(1);                                //runstate = IDLE

}

//==============================================================================

a) statt
task task_PID_A()
stünde dann hier also
void * pid_calc( void *)


und der Rest bliebe gleich?
(die ..._A am Ende fallen ntl dann auch überall weg)


und b)
auch wenn ich jetzt kurz hinterenander mehrfach diesen Task für mehrere Motoren starte, wobei die Laufzeiten sich mehrfach überlappen
RotatePID(0, 3000, 15, false);
RotatePID(2, -4000, 90, false);
delay(1);
RotatePID(8, 10000, 50, true );
delay(10);
RotatePID(1, -5000, 60, false);
RotatePID(3, -3000, 20, true);

und also in diesem Falle 5 verschiedene Threads parallel asynchron laufen müssten, mit Starten eines neuen Tasks ohne auf die Beendigung des vorherigen warten zu müssen, die sich dann alle auch unabhängig zu verschiedenen Zeiten beenden oder (in 2 Fällen) "unendlich" weiter laufen -
das funktioniert dann

[botty]

zu a)

ja, task_PID_[ABC] wird durch die allgemeine form pid_calc ersetzt.

Sinngemäss wie du auf die Elemente des Arrays zugreifst sähe so aus (ohne das ich jetzt verstehe was dein Algo macht):

void *pid_calc(void *arg) {
  float aspeed, damp, PWMpwr, readold, errorold, tprop;
  long  readstart, cmax, cmin;                         // for monitoring
  long  starttime, runtime, clock, dtime;              // timer
  char  regloop;
  
  // arg nach index casten
  unsigned port = (unsigned)arg;

  motor[port].runstate = 0x10;                               // reg state: RAMPUP
  motor[port].read     = (MotorRotationCount(port));        // get current encoder reading
  motor[port].err      = motor[port].target - motor[port].read;          // error to target

  readstart      = motor[port].read;
  regloop        = 1;

  damp=0;                                 // damp the integral memory

  starttime= CurrentTick();


  // appoach target
  _Astart:
  motor[port].runstate = 0x10;                  // run state: RUNNING

  do {
    pthread_testcancel();

    dtime    = CurrentTick() - clock;
    clock    = CurrentTick();
    runtime  = clock - starttime;
    tprop    = dtime/20.0;

    if ((motor[port].err==errorold)&& (abs(motor[port].err)>motor[port].precis))
      damp=1; // stalling
    else
      damp=motor[port].damp;

    motor[port].integr = (damp * motor[port].integr) + motor[port].err;

    if((motor[port].integr) > 3*motor[port].maxout) 
      motor[port].integr = 3*motor[port].maxout; // cut away
    else if((motor[port].integr) <-3*motor[port].maxout)
      motor[port].integr =-3*motor[port].maxout;

    PWMpwr= (motor[port].P*motor[port].err) + (motor[port].I*motor[port].integr)*tprop + (motor[port].D*(motor[port].err-errorold))/tprop;


    if(PWMpwr >  motor[port].maxout)
      PWMpwr=  motor[port].maxout;   // forward maxout
    else if(PWMpwr < -motor[port].maxout)
      PWMpwr= -motor[port].maxout;   // reverse maxout

    motor[port].speed= (motor[port].read-readold)*100/dtime;  // rotat speed [degrees/100ms]

    aspeed = abs(motor[port].speed) ;

    if (aspeed > motor[port].tarpwm)  {
        PWMpwr = sign(PWMpwr)*motor[port].tarpwm;
    }

    motor[port].outp = round(PWMpwr);

     //**************************************************************************
                                                   // PID regulation !
    OnFwd(port, (motor[port].outp));                         // action !
    Wait(motor[port].regtime);                                // wait regulation time

    //**************************************************************************

    readold     = motor[port].read;                           // save old sensor
    errorold    = motor[port].err;                            // save old error

    motor[port].read  = (MotorRotationCount(port));          // get new encoder value
    motor[port].err   = motor[port].target-motor[port].read;              // new error to target

    if (motor[port].read>cmax) 
      cmax=motor[port].read;               // monitor overshooting
    else if (motor[port].read<cmin)
      cmin=motor[port].read;               // monitor overshooting

    if ((motor[port].cont)&& (abs(motor[port].err)<=motor[port].precis))
      motor[port].runstate = 0x60;
    else 
      motor[port].runstate = 0x20;

    if (motor[port].cont) 
      continue;
    if (abs(motor[port].err)<=motor[port].precis) {
      regloop +=1 ; 
      motor[port].runstate = 0x40;
    }

  } while ((abs(motor[port].err)>=motor[port].precis) && (regloop<=5));  // target reached

  Off(port);                                      // finished - brake motor
  motor[port].runstate = 0x40;                           // run state: RAMPDOWN
  motor[port].outp=0;

  Wait(50);
  motor[port].read = MotorRotationCount(port);
  regloop=1;

  if (motor[port].read>cmax) cmax=motor[port].read;            // detect overshooting
  if (motor[port].read<cmin) cmin=motor[port].read;            // detect overshooting
  motor[port].err = motor[port].target-motor[port].read;

  if ((abs(motor[port].err)>motor[port].precis)) {
    goto _Astart;
  }

  motor[port].runstate=0;
  Wait(1);                                //runstate = IDLE

}

zu b)

klar geht das, in deinem Beispiel legst du einfach fünf Threads an, die vom OS ausgeführt werden.
Was du nicht machen darfst ist zweimal ein RotatePID mit der identischen Portnummer aufzurufen ohne vorher ein StopPIDcontrol aufzurufen. Würdest du das machen hättest du zwei Threads die dann doch wieder auf einem PID rumrechnen.
Ausserdem würde ich statt Nummern für die Ports eine enum erstellen, Namen sind einfacher zu lesen, als mit 0,4,7 einen Motor zu assoziieren.