- LiFePO4 Speicher Test         
Seite 3 von 5 ErsteErste 12345 LetzteLetzte
Ergebnis 21 bis 30 von 45

Thema: pthread-Task als Methode einer C++ Klasse?

  1. #21
    HaWe
    Gast
    Anzeige

    LiFePo4 Akku selber bauen - Video
    und wie geht es, wenn die Klasse über
    class PID;
    PID.start()
    selber ihren eigenen privaten pthread Task starten möchte?

    (hat sich überschnitten, ich bezog mich auf mxt's code)

    - - - Aktualisiert - - -

    über botty's Variante muss ich nochmal etwas nachdenken...

    - - - Aktualisiert - - -

    @botty:
    deinen Vorschlag davor
    https://www.roboternetz.de/community...l=1#post631429
    hatte ich völlig überlesen - vielen Dank!
    hat sich auch wohl mit einem anderen zeitlich überschnitten.

    Ich blicke auch dabei noch nicht völlig durch, aber ich versuche gerade, mich da hineinzudenken...

  2. #22
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    04.09.2011
    Ort
    Hessen
    Beiträge
    707
    So hier noch mal ein Beispiel, auf Raspian getestet. Die returns sind doch nötig.

    Code:
    #include <stdio.h>
    #include <pthread.h>
    
    class PID
    {
    private:
    
      pthread_t m_thread;
    
      int m_a;  // Nur Beispielparameter, hier kämen die richtigen Parameter des Reglers hin
      int m_b;
    
      static void* helper(void* instance)
      {
        return ((Pid*) instance)->run();
      }
    
      void* run()
      {
        printf("Die Parameter sind %d %d\n", m_a, m_b);
    	
    	// Hier käme die Regelschleife rein
    
        return 0;
      }
    
    public:
    
      Pid(int a, int b) : m_a(a), m_b(b)
      {}
    
      void start()
      {
        pthread_create(&m_thread, NULL, &helper, this);
      }
    
      void stop()
      {
        pthread_join(m_thread, 0);
      }
    };
    
    int main()
    {
      PID test(10, 42);
    
      test.start();
    
      // ...
    
      test.stop();
    
      return 0;
    }
    Die eigentliche Regelung fände in der Funktion run statt. Man beachte, dass diese und die statische helper Funktion privat sind, also von außen nicht aufgerufen werden dürfen.

    Die Parameter würden im Konstruktor gesetzt. Kann man aber auch über Parameter in start lösen.


    Ich würde aber trotzdem empfehlen, entweder die Lösung von botty oder richtige C++ Threads zu nehmen.
    Geändert von Mxt (20.09.2016 um 18:28 Uhr)

  3. #23
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    08.08.2008
    Ort
    DE
    Beiträge
    523
    Oder nochmal in C++11

    Code:
    #include <iostream>
    #include <thread>
    
    
    
    
    using namespace std;
    
    
    
    
    typedef struct {
        pthread_t tid;
        char* name;
    
    
        float p;
        float i;
        float d;
    } PID_t;
    
    
    
    
    class TestClass
    {
    public:
        TestClass() {}
        ~TestClass() {}
    
    
        void Start(PID_t *p)
        {
            t = new thread(&this->MyTask, p);
        }
    
    
        void Stop()
        {
            t->join();
        }
    
    
    private:
        static void MyTask(PID_t *p)
        {
            cout << "PID: " << p->tid << endl;
            cout << "Name: " << p->name << endl;
    
    
        }
    
    
        thread *t;
    
    
    };
    
    
    
    
    int main()
    {
        cout << "Start" << endl;
    
    
        PID_t pp[3] = {    {0, (char*)"MyName1", 5, 6, 7},
                        {1, (char*)"MyName2", 5, 6, 7},
                        {2, (char*)"MyName3", 5, 6, 7}};
    
    
        TestClass tc1;
        TestClass tc2;
        TestClass tc3;
    
    
        tc1.Start(&pp[0]);
        tc2.Start(&pp[1]);
        tc3.Start(&pp[2]);
    
    
        //...
    
    
        tc1.Stop();
        tc2.Stop();
        tc3.Stop();
    
    
    
    
        return 0;
    }

  4. #24
    HaWe
    Gast
    Danke für alle Tipps!
    bin gerade ein paar Tage außer Haus, daher kann ich es z.Zt nicht testen.
    Für MT kommen keine C++11 tasks in Frage, wie ich bereits schrieb, weil ich mich nicht damit auskenne - sondern nur pthread, das ich auch sonst verwende.
    Bottys Version ganz ohne ++ hatte ich ja zunächst überlesen, das will ich mal als nächstes versuchen umzusetzen, wenn ich hier wieder einen Pi zum programmieren habe. Ich melde mich dann baldmöglichst!
    hier erst einmal - nochmal - vielen Dank!

  5. #25
    HaWe
    Gast
    hallo,
    2 Dinge sind mir mit der Struktur noch unklar:
    warum muss am Anfang immer eine Null stehen

    Code:
    struct PID pids[] = { 
      {0, "Task A", 0.015, 0.2, 0.7 },
      {0, "Task B", 0.3, 0.5, 0.80 }
    };
    und 2., ist es erlaubt, die Struktur statt mit einem String auch mit einem char (0, 1, 2, 3, ...) zu definieren und aufzurufen oder muss es unbedingt ein String sein?

    Code:
    struct PID pids[] = { 
      {0, 0, 0.015, 0.2, 0.7 },
      {0, 1, 0.3, 0.5, 0.80 }
    };

  6. #26
    HaWe
    Gast
    @botty:
    je mehr ich drüber nachdenke, wird mir allerdings klar, dass ich gar nicht recht verstehe, wofür diese Struktur

    https://www.roboternetz.de/community...l=1#post631429
    Code:
    struct PID pids[] = { 
      {0, "Task A", 0.015, 0.2, 0.7 },
      {0, "Task B", 0.3, 0.5, 0.80 }
    };
    überhaupt da ist:

    Das "setten" der Kp, Ki, Kd (kurz: P, I, D) soll ja nicht im Aufruf der PID-Funktion stehen.
    Die PID Funktion wird nur mit der Motornummer und dem RotationTarget aufgerufen plus einem pwm-Wert für die max. Rotationsgeschwindigkeit


    Code:
    void RotatePIDtoTarget (char port, long Target, float RotatSpeed); // approach absolute target once
    void RotatePIDdegrees  (char port, long Target, float RotatSpeed); // turn relative degrees
    void RotatePIDcontinue (char port, long Target, float RotatSpeed); // approach target continuously
    void StopPIDcontrol    (char port);                                // stop PID
    Das Setten der PID-Konstanten geschieht automatisch bei der Initialisiering und kann dann auf Wunsch auch optional durch extra Funktionen geschehen:

    // first Initialization:
    void PIDinit(); // P=0.4, I=0.4, D=10.0
    //
    // b) simple customized PID setting:
    void SetPIDparam(char port, float P,float I,float D);
    //
    // c) extended customized parameter setting:
    void SetPIDparamEx(char port, float P,float I,float D, float prec,int rtime, float damp);

    wozu also deine
    Code:
    struct PID pids[]
    Geändert von HaWe (24.09.2016 um 09:28 Uhr)

  7. #27
    Benutzer Stammmitglied
    Registriert seit
    19.05.2015
    Beiträge
    69
    Hallo HaWe,
    sorry das ich mich jetzt erst melde aber bei dem schönen Wetter konnte mich am WE nichts vor den Bildschirm locken.

    Zu Deinen Fragen:

    Meine "struct pid" sollte nur ein Auszug aus Deiner "struct PIDstruct" sein. Worauf es mir ankommt ist, dass du diese um zwei Felder erweiterst:
    einmal um ein Element pthread_t und
    zweitens, um ein Element worüber du deine Motoren identifizieren kannst.

    Dadurch kannst du deinen Code wesentlich verkürzen, schau mal deine
    Code:
    safecall void StopPIDcontrol (char port) {
    
      if (port==OUT_A) {
    
        if (PID_A.runstate!=0) { // stop PID task if already running
          stop task_PID_A;
          PlayTone(TONE_C7,100);
          Off(OUT_A);
          Wait(50);
          PID_A.cont=false;
          PID_A.runstate=0;
          Wait(1);
          return;
        }
    
      }
      else
      if (port==OUT_B) {
    
        if (PID_B.runstate!=0) { // stop PID task if already running
          stop task_PID_B;
          PlayTone(TONE_C7,100);
          Off(OUT_B);
          Wait(50);
          PID_B.cont=false;
          PID_B.runstate=0;
          Wait(1);
          return;
        }
    
      }
      else
      if (port==OUT_C) {
    
        if (PID_C.runstate!=0) { // stop PID task if already running
          stop task_PID_C;
          PlayTone(TONE_C7,100);
          Off(OUT_C);
          Wait(50);
          PID_C.cont=false;
          PID_C.runstate=0;
          Wait(1);
          return;
        }
    
      }
    
    
    }
    an.

    Da steht dreimal quasi das Gleiche.
    Wenn du jetzt deine Struktur erweiterst und statt dem Port einen Zeiger auf die Variable übergibst, läßt sich der Code um 2/3 kürzen.
    Code:
    struct PIDstruct {
      /* Erweiterung */
      pthread_t tid;
      unsigned short motor_id;
    
                     // custom target values
      long  target;                  // set target
      int   tarpwm;                  // motor target speed
                     // custom regulation parameters
      float P;                       // P: basic propotional to error
      float I;                       // I: integral: avoid perish
      float D;                       // D: derivative: avoid oscillating
      float precis;                  // error precision to target
      int   regtime;                 // PID loop time
      float damp;                    // damp the integral memory
      char  cont;                    // target: continue or hit once
                     // internal control variables
      char  runstate;                // monitors runstate
      int   outp;                    // PID control output value
      int   maxout;                  // max output (max motor pwr)
      long  read;                    // current sensor reading
      float err;                     // current error
      float integr;                  // integral of errors
      float speed;                   // current speed
    
    
    } ;
    
    void StopPIDcontrol (struct PIDstruct *pid) {
    
      if (pid->tid) { // stop PID task if already running
        pid_stop(pid, 1); // siehe botties zweites Beispiel
        Off(pid->motor_id);
        pid->cont=false;
        pid->runstate=0;
        return;
      }
    
    }
    Wenn du jetzt eine Variable PID_A definierst, würde der Aufruf so aussehen:
    Code:
    struct PIDstruct PID_A;
    
    void eine_stop_funktion(void) {
      StopPIDcontrol( &PID_A );
    }
    Du wählst somit nicht mehr über eine port/switch Kombination deinen PID Controler aus, sondern beim Aufruf der Funktionen über den Zeiger auf die Variable, welche alle Daten für einen Controler enthält.
    D.h. bei allen Funktionen ersetzt du "char port" durch "struct PIDstruct* pid" und dereferenzierst die Elemente der Struktur nicht mehr über den "." Operator sondern über den "->" Operator.

    Auch bei der Erezugung der Threads können wir jetzt den Zeiger auf die Variable als Parameter in die Thread-Funktion hineingeben, denn die Signatur dieser Funktion lautet:
    Code:
    void *(*function)(void *arg);
    Zwar ist arg vom Typ "void *" nur da wir immer nur Zeiger vom Typ "struct PIDcontrol *" hineingeben können wir am Anfang der Routine diesen Zeiger sicher auf den richtigen Typ casten:
    Code:
    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;
    
      /* das ist ein ziemlich sicherer cast */
      struct PIDcontrol *pid = (struct PIDcontrol *) arg;
    
      pid->runstate = 0x10;                               // reg state: RAMPUP
      pid->read      = (MotorRotationCount(pid->motor_id));        // get current encoder reading
      pid->err        = pid->target - pid->read;          // error to target
    
      readstart      = pid->read;
    
    /* ... */
    
    }
    so brauchst du auch diese Routine nur einmal, denn bei der Thread Erzeugung übergibst du den Zeiger auf die Variable z.B.:
    Code:
    pthread_create(&PID_A.tid, 0, pid_calc, &PID_A);
    ich hoffe das es jetzt klarer ist, warum ich Zeiger verwenden würde?


    Noch ein Wort zu den Variablen für die einzelnen PID Controler, du definierst die so:
    Code:
    struct PIDcontrol PID_A;
    struct PIDcontrol PID_B;
    struct PIDcontrol PID_C;
    bei sowas sehe ich sofort eine Aufzählung und wenn ich dann auch noch Operationen über diese machen muss, wie z.B. ein warten auf das Beenden eines Threads, dann ordne ich sowas in einem Array an:
    Code:
    enum motoren {
      MOT_SCHULTER = 0,
      MOT_ELLE,
      MOT_HAND,
      MOT_MAX
    };
    
    struct PIDcontrol pids [MOT_MAX];
    
    /* Verwendung */
    
    void ein_stop(void) {
       StopPIDcontrol( &pids[MOT_SCHULTER );
    }
    
    void mehrere_stops(void) {
      int idx;
    
      for(idx = MOT_SCHULTER; idx < MOT_MAX; idx++)
        StopPIDcontrol( &pids[idx] );
    }
    find ich bequemer, ist aber Geschmackssache.

    Gruss

    botty

  8. #28
    HaWe
    Gast
    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
    Code:
    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:
    Code:
    RotatePID(port, Target, RotatSpeed, false);

    und hier wird nach Setzen der PID Laufzeit-Variablen der PID Task gestartet:
    Code:
    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?
    Geändert von HaWe (26.09.2016 um 18:44 Uhr)

  9. #29
    Benutzer Stammmitglied
    Registriert seit
    19.05.2015
    Beiträge
    69
    Na ja,
    zuerst must du die PIDinit ergänzen:
    Code:
    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.:
    Code:
    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:
    Code:
    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
    Code:
    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:
    Code:
    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

  10. #30
    HaWe
    Gast
    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;

Seite 3 von 5 ErsteErste 12345 LetzteLetzte

Ähnliche Themen

  1. Abgeleitete Klasse = konkrete Klasse?
    Von vixo im Forum Software, Algorithmen und KI
    Antworten: 4
    Letzter Beitrag: 15.09.2016, 17:02
  2. Antworten: 4
    Letzter Beitrag: 02.04.2016, 15:23
  3. Task motionControl() mit der M32
    Von inka im Forum Robby RP6
    Antworten: 8
    Letzter Beitrag: 10.04.2013, 07:40
  4. Gegen-EMK-Methode
    Von MatlStg im Forum Motoren
    Antworten: 7
    Letzter Beitrag: 11.02.2008, 18:07
  5. Was ist die besser Methode? (ADC auswerten)
    Von quantum im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 3
    Letzter Beitrag: 28.01.2007, 13:57

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •  

LiTime Speicher und Akkus