DIY Servo

[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....

[Der Einsteiger]

So, nach ein paar Stunden frustrierender Tests, bin ich nun zu dem Entschluss gekommen, dass ich einfach mit dem RB-35 nicht weiterkommen werde, da dieser eine sehr große Massenträgheit besitzt und deshalb nicht genau anzusteuern ist (jedenfalls für mich)...

Da ich jedoch dieses Thema sehr spannend finde gebe ich so schnell nicht auf.
Deshalb habe ich mir jetzt ein billiges Servo aus der Bastelkiste geschnappt und das Poti entfernt. Dann habe ich mir eine Adapterwelle gedreht, welche auf der einen Seite eine Abflachung besitzt, sodass die Welle genau in das Abtriebszahnrad passt, in dem vorher das Poti steckte. Auf der anderen Seite ragt nun ein Wellenstummel mit einem Magneten an der Spitze hinaus ( Dieser Aufbau soll nur zu Testzwecken dienen...).
Nun konnte ich bereits mit einem abgewandelten Programm akzeptable Ergebnisse erzielen.

Doch stellt sich für mich jetzt eine andere Frage. Wie kann ich verhindern, dass mein Servo spinnt, sobald es über Null fährt (denn es bekommt ja dann einen ungewollten Sprung...) ?

Hier ist noch mal mein neuer Code (wieder mit float, da es für mich keinen Unterschied gemacht hat)

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;
int esum;
int ealt;
int yaus;
int y_max = 45;
int y_min = 0;
int esum_max = 700;

float y;
float i;
float d;
float Kp = 2.0;  //P
float Ki = 3.0;  //I
float Kd = 0.5;  //D
float Ta = 0.02;  //Abtast

void regler()  {
  
  if(soll_wert >= 10)  {
    if(soll_wert <= 350)  {
      e = soll_wert - ist_wert;
      e = abs(e);            
      esum = esum + e;
      if(esum > esum_max)  {
        esum = esum_max;
      }
      
      i = float(esum) * Ta;
      i = i * Ki;
      
      d = float(e) - float(ealt);
      d = d / Ta;
      d = d * Kd;      
      
      y = Kp * e;
      y = y + i;
      y = y + d;
      
      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;
        ealt = 0;
      }
      
    }
  }
  
  
  
}

Ich hoffe ihr versteht meine Frage und kennt eine Lösung
Der Einsteiger

[Rabenauge]

Weiss ehrlich gesagt nicht, wer da auf das Servo springt. Hat es was mit deinem Magneten zu tun?
Mit den Dingern hab ich noch nix gemacht (auch sowas, dass ich schon lange vor hab).
Du zählst doch da Impulse, oder?
Dann musst du doch wissen, wenn ne volle Umdrehung um ist, und fängst dann halt einfach von vorn an zu zählen (ggf. kannst du ja _dieses_ Ereignis auch noch speichern, dann weisst du später auch, wieviele Umdrehungen es waren).

[Der Einsteiger]

Weiss ehrlich gesagt nicht, wer da auf das Servo springt. Hat es was mit deinem Magneten zu tun?
Mit den Dingern hab ich noch nix gemacht (auch sowas, dass ich schon lange vor hab).
Du zählst doch da Impulse, oder?
Dann musst du doch wissen, wenn ne volle Umdrehung um ist, und fängst dann halt einfach von vorn an zu zählen (ggf. kannst du ja _dieses_ Ereignis auch noch speichern, dann weisst du später auch, wieviele Umdrehungen es waren).

Ne, es ist ein bisschen anders... Also der AS5040 wird über den ssi Bus (glaube, der heißt so) ausgewertet. Diesen Programmteil habe ich nur von Google übernommen...
Also am Ende werden mir auf jeden Fall 0-360° ausgegeben (das funktioniert ja auch prima). Wenn ich also weiter drehe fängt er wieder mit Null an und so weiter...

Und genau das ist das spinnen, was ich meinte. Nehmen wir als Beispiel an ich möchte von 150° auf 1° positionieren. Dann kann es durch Schwingung und so weiter dazu kommen, dass meine Achse nun ein bisschen weiter dreht und dann 355° anzeigt wird. In diesem Fall dreht dann nämlich mein Servo nicht ein kleines Stück zurück, sondern macht fast eine ganze Umdrehung...
Wie kann ich das nun beheben (im Programmcode) ??

[Geistesblitz]

Hehe, damit plag ich mich auch gerade herum. Ich versuch das so zu lösen, dass ich nebenher in einer weiteren Variable die Umdrehungen zähle. Dazu berechne ich die Differenz zwischen dem aktuellen und dem vorherigen Winkel und wenn dieser über 180° ist, wird eine Umdrehung raufgezählt und bei kleiner -180° einen runter. Dann kommt alles in eine neue Variable, meinetwegen
Winkel=360*Umdrehungen+gemessener Winkel
Du dürftest allerdings nicht wirklich ° herausbekommen, sondern Werte von 0 bis 4096, oder? Weiß gerade nicht, ob der AS5040 12-Bit Auflösung hatte. Ich hab jedenfalls bei mir einen AS5048A drin, der hat 14 Bit, also muss ich da mit 16384 pro Umdrehung rechnen. Allerdings haut das bei mir mit den ganzen Datentypen noch nicht so ganz hin.

Und dein Getriebemotor hat ein zu hohes Trägheitsmoment? Ich hab bei mir auch einen Motor im RB-35-Format drin (angegeben mit 76 U/min im Leerlauf bei 12V) und jetzt, wo ich den PID-Regler ganz gut abgestimmt bekommen hab, ist zumindest mit dem Auge kaum noch irgendwelches Schwingen zu erkennen und die Bewegung ist auch ziemlich fix. Beim PID-Regler muss man übrigens auch teilweise ganz schön auf die Wertebereiche der Variablen achten, gerade der Integratoranteil macht gerne mal Mist.