DIY Servo

[Der Einsteiger]

Hallo, ich bin es mal wieder...
Nachdem ich hier im Wiki auf der Seite Sensorarten auf den AS5040 Winkelsensor gestoßen bin, wollte ich mir damit ein großes Servo selber bauen.
Also habe ich mir einen RB-35 Getriebemotor geschnappt und diesen über zwei Zahnräder mit der Welle (mit Magnet) des AS5040 verbunden.
Nun kann ich schon Werte des Sensors auf dem PC ausgeben. (Das war ja mal ne Arbeit den So16 per hand zu löten )

Jetzt folgt jedoch erst der schwierige Teil mit der Regelung !

Dazu habe ich mich im Wiki auf der Seite Regelungstechnik belesen und habe danach erstmal mit einem PD-Regler angefangen. Dieser funktioniert jetzt auch schon ganz ok (ohne Schwingung um die Nulllage) doch überschreitet mein Motor die Nulllage dank Massenträgheit (glaube ich) noch um etwa 10° und bleibt dann da wegen nur geringer PWM stehen.

Dann habe ich den PID-Regler ausprobiert und musste feststellen, dass dieser zwar versucht, die Nullposition anzusteuern, jedoch endlos um diese schwingt.

Meine Frage ist nun, wie ich es schaffen kann, dass mein PID-Regler doch funktioniert (also die Massenträgheit berücksichtigt) ?
Außerdem : wie macht ihr das mit der Regelung, wenn ihr große Motoren benutzt ?

Ich hoffe ihr Profis könnt mir helfen

Hier ist mein Code (Arduino) (nur der Teil mit dem Regler):

int pwm_pin = 3;  //Motor pwm
int in_1 = 4;   //Motor Richtung
int in_2 = 5;   //Motor Richtung
String msg;
char a;
int soll_wert;
int ist_wert;
int e;
float esum;
int ealt;
float y;
float r;
float s;
int yaus;
int y_max = 255;
int y_min = 0;
int s_max = 50;
float Kp = 1.0;  //P
float Ki = 0.5;  //I0,001
float Kd = 1.05;  //D0,01
float Ta = 1.0;  //Abtast
int esum_max = 150;


void regler()  {
  
  if(soll_wert >= 10)  {
    if(soll_wert <= 350)  {
      e = soll_wert - ist_wert;
      e = abs(e);            
      esum = esum + e;
      s = float(esum) * Ta;
      s = s * Ki;
      if(int(s) > s_max)  {
        s = float(s_max);
      }
      r = float(e) - float(ealt);
      r = r / Ta;
      r = r * Kd;
      if(esum > esum_max)  {
        esum = esum_max;
      }
      
      y = Kp * float(e);
      y = y + s;
      y = y + r;
      
      yaus = int(y);
      Serial.println(y);
      ealt = e;
      
      if(yaus > y_max)  {
        yaus = y_max;
      }
      
      if(yaus < y_min)  {
        yaus = y_min;
      }
      
      if(ist_wert > soll_wert)  {
        digitalWrite(in_1, HIGH);  
        digitalWrite(in_2, LOW);
        analogWrite(pwm_pin, yaus);
      }
      
      if(ist_wert < soll_wert)  {
        digitalWrite(in_1, LOW);  
        digitalWrite(in_2, HIGH);
        analogWrite(pwm_pin, yaus);
      }
      
      if(ist_wert == soll_wert)  {
        digitalWrite(in_1, LOW);  
        digitalWrite(in_2, LOW);
        analogWrite(pwm_pin, 0);
        esum = 0;
      }
      
    }
  }
  
  
  
}

[Geistesblitz]

Hmm, also es gibt zwei nichtlineare Effekte, die bei DC-Getriebemotoren zum Schwingen führen können. Das ist einmal die Anlaufspannung, die der Motor braucht, um sich zu bewegen und sonst das Getriebespiel. Beides lässt sich nur schwierig durch die Regelung ausgleichen. Bei der Anlaufspannung geht es eigentlch noch, ich mach das so, dass die PWM für den Motor nicht bei 0 losgeht, sondern schon bei einem gewissen Wert. Wenn du ein Labornetzteil hast, kannst du die Anlaufspannung ganz gut ermitteln, ansonsten musst du eben ein wenig herumprobieren. Das Getriebespiel ist allerdings kaum zu bändigen, daher ist in Präzisionsanwendungen auch eine Spielfreiheit auch so wichtig, selbst wenn direkt gemessen wird.

Ansonsten, nach welchem Verfahren hast du den PID-Regler ausgelegt?

[Der Einsteiger]

daher ist in Präzisionsanwendungen auch eine Spielfreiheit auch so wichtig, selbst wenn direkt gemessen wird.

Und wie wird das dann in Modellbauservos gelöst ? Die haben ja auch ein Spiel...

Ansonsten, nach welchem Verfahren hast du den PID-Regler ausgelegt?

probieren Also ich habe alles auf Null und dann Kp und Kd probiert bis die ganz gut gingen. Dann habe ich Ki hinzugefügt.
Bevor ich Ki eingestellt hatte ging es ja auch ganz gut. Der Motor kam nur eben nicht auf die Position.

Wie muss man denn Ta ca. dimensionieren ?

[oberallgeier]

Das Schwingen um den Sollwert kann durch ein Band mit wenig Abstand um die Sollposition vermieden werden, innerhalb dem der I-Anteil nicht aktiviert wird.

... Wie muss man denn Ta ca. dimensionieren ?

Kurz. Für 8bittige Controller sind 10 ms ein guter Wert, aber mit Deinem

... float Kp = 1.0; //P ... float Ki = 0.5; //I0,001 ... float Kd = 1.05; //D0,01 ...

Floatingpointtiming wird das eher nix. Wie lange dauert denn bei Dir ein Durchgang zum Rechnen eines Regelungswertes?

Ich betreibe meine Regelung(en), meist zwei getrennte Rechnungen für zwei getrennte Motoren, mit 100 Hz, rechne aber nie FP. Mit meiner Integerrechnung bekomme ich dabei recht gute Resultate.

Im Übrigen sind die Ratschläge von waste z.B. hier ziemlich gut; danach hatte ich fast alles ausgelegt.

Viel Erfolg.

[Der Einsteiger]

Das Schwingen um den Sollwert kann durch ein Band mit wenig Abstand um die Sollposition vermieden werden, innerhalb dem der I-Anteil nicht aktiviert wird.

Dann würde doch meine Ungenauigkeit bleiben, oder ?

Wie lange dauert denn bei Dir ein Durchgang zum Rechnen eines Regelungswertes?

Wie soll ich das denn bestimmen ?

Im Übrigen sind die Ratschläge von waste z.B. hier ziemlich gut; danach hatte ich fast alles ausgelegt.

Wie soll man denn die Sprungantwort aufzeichnen ?

[oberallgeier]

Dann würde doch meine Ungenauigkeit bleiben, oder ...

Was ist Dir denn lieber? Dauerndes Schwingen um den Sollwert oder eine minimale, bleibende Abweichung? Die Regelungs tech nik überlässt DIR die Wahl.

... Wie soll ich das denn bestimmen ? ...

Ein 1000er-Loop der nur die Regelschleife enthält (evtl. gaaanz knappe Variationen der Werte), eine Stoppuhr . . . das ist die Warmduschervariante. In der Hoffnung, dass die arduinoumgebung neben dem *hex-File auch eine *.lls erzeugt: die enthält den kompletten Maschinencode. Da braucht man nur die Maschinenzyklen der einzelnen Befehle zusammenzuzählen . . .

... Wie soll man denn die Sprungantwort aufzeichnen ?

Starte Aufzeichnung der aktuellen Motorposition in schnellem Takt (ich hatte das im Takt von 1 bis 2,irgendwas Millisekunden gemacht - jeweils gleiche Abstände). Starte Motor mit einem mittleren oder hohen PWM-Wert. Beende Aufzeichnung - der Motor sollte dann annähernd oder vollständig seine Enddrehzahl erreicht haben. Daten ausgeben - z.B. über Terminal und auswerten. Auswertung hatte ich üblicherweise mit einer Tabellenkalkulation gemacht. Resultat sind dann Motorzeitkonstante und Anhaltswerte zur Reglereinstellung. Sinn macht das, auch bei einem Servo, aber nicht nur im Leerlauf, bei meinen Antrieben hatte ich die Sprungantwort für die endgültige Reglerauslegung immer im Endausbau bestimmt.

[Geistesblitz]

Wegen der Rechenzeit: ich hatte mir da mal geholfen, indem ich ganz zu Anfang der Schleife einen Timer auf 0 gesetzt habe und am Ende der Schleife dann den Timerwert auf einem Display ausgeben lassen. Dabei muss man darauf achten, dass der Timer so eingestellt ist, dass er nicht während der Schleife schon überläuft, sonst bekommt man unbrauchbare Werte. Über Taktfrequenz und Prescaler kann man dann auf die tatsächliche Zeit schließen. Natürlich kannst du auch etwas reinbauen, was dir gleich den Timerwert in die Rechenzeit umrechnet, zwecks Anschaulichkeit. Ich würd dir aber auch empfehlen, auf Integer-Rechnung umzusteigen, da das sehr viel schneller ist. Dafür brauchst nur die Zahlen, mit denen gerechnet wird, in einen brauchbaren Bereich transformieren. Der gemessene Winkel und die PWM sind ja meist eh Integer-Werte. Musst nur aufpassen bei zB. Multiplikation, da 8bit*8bit einen 16bit-Wert ergibt.

[Rabenauge]

Beim Arduino ist die Zeitmessung ganz einfach:
http://arduino.cc/en/pmwiki.php?n=Reference/Micros

Damit kann man sich den, von Geistesblitz beschriebenen Zeit-Zähler ganz leicht basteln, indem man
-vor dem interessanten Teil die aktuellen Microsekunden speichert
-direkt nach dem interessierenden Codeteil die Microsekunden ausliest
und beides voneinander abzieht.

unsigned long startmicros=micros();                  // StartZeit
//hier Dinge tun, deren Dauer wir wissen möchten


unsigned long endmicros=micros();                              // EndZeit
//und dann bei passender Gelegenheit das Ergebnis ausspucken:

Serial.println(endmicros-startmicros,DEC);                // Zeitspanne ausgeben

Was den PID angeht: richtig. Ohne I-anteil wirst du nie wirklich auf Null landen.
Der Trick dürfte es sein, den Bereich, indem kein I mehr verwendet wird, so knapp zu bemessen, dass das Ergebnis noch zufriedenstellend ist (also: so knapp wie möglich, aber eben so dass es läuft).
Auch Modellbauservos fahren nicht _auf den Punkt_, die Abweichung ist lediglich so klein, dass man sie nicht bemerkt (bei den besseren jedenfalls, die Billigdinger machen wegen ein, zwei Grad keinen Wirbel).

Wenn du das Problem hast, dauernd über den Sollbereich drüber zu rauschen, dann benutz doch mal in der Gegend um den Sollbereich zahmere Regelparameter.
So wie das hier empfohlen wird: http://playground.arduino.cc/Code/PI...TuningsExample
Das lässt sich auch mit beliebig vielen Stufen aufbauen, und es können jeweils alle drei Grössen einzeln angepasst werden.

Auch empirisch geht sowas: ich hab mir seinerzeit kurzerhand ein paar Potis temporär hinzugefügt, um P,I und D "live" verstellen zu können, so erreicht man schnell erst mal "brauchbare" Wertebereiche.

[Der Einsteiger]

ok, danke für die Antworten
Rabenauge, das mit den Micros war ein guter Vorschlag.
Also, ich habe jetzt mal gemessen: Für einen Reglerdurchlauf brauche ich rund 60micros und für einen kompletten Loop (mit Sensorauswertung) rund 11064micros (nein, ich habe mich nicht verschrieben ! )......
Dazu muss ich sagen, dass ich die Berechnung wieder auf integer zurückgestellt habe.

Zu dem Motor muss ich sagen, dass dieser, wenn ich ihn direkt mit Spannung versorge und dann abtrenne, noch mindestens 1,5 sec ohne Strom weiterdreht. Auch läuft er überhaupt erst bei 1/4 PWM an

[Rabenauge]

Sind doch gar keine so üblen Werte. Dann dauert eine Schleife 11 ms- das finde ich durchaus ok.
Bedenke auch, dass der Motor ja erst mal reagieren muss, rein mechanisch. In 11 Millisekunden wird da so viel nicht passieren.
Die Arduino-PID-Lib arbeitet standardmässig, so glaub ich, mit 200ms Zykluszeiten....