Aktelle Lib 2.7.1 und MY_MOTOR_DIFF

[Andun]

Moin

Da ich keinen passenden Thread zur Entwicklung der Lib finden konnte, mach ich mal nen Thread auf:

Mein Problem ist, dass in der Doku noch überhaupt nirgends die Implementierung von MY_MOTOR_DIFF zu finden ist. Ich wollte mir anschauen, wo dieses eigentlich einbezogen wird, aber kann es nicht finden, deswegen geh ich davon aus, das die tatsächlich LIB nicht konsistent zur Doku ist.

Ist dem so, oder bin ich zu blöd zum suchen?

mfg
Andun

[damaltor]

hmm ich glaube die doku ist noch in bearbeitung....

[m.a.r.v.i.n]

Hallo andun,

MY_MOTOR_DIFF ist mehr oder weniger nur eine Hilfskrücke, wenn man die Motoren ohne Odometrie ansteuern will. Der Wert wird deshalb in der Lib Funktionen nirgends verwendet, sondern bei Bedarf in eigenen Programmen.

Dazu muß man erst mal durch probieren herausfinden, welcher Wert hier Sinn macht. D.h. den Wert solange ändern bis der Asuro einigermaßen geradeaus fährt. Natürlich wird das ganze nur für eine bestimmte Geschwindigkeit funktionieren, deshalb ist es auch nur eine Krücke.

Dazu braucht man eine Funktion wie diese hier (ohne Gewähr, ungetested!!):

void myMotorSpeed(unsigned char left, unsigned char right)
{
  int speed_l, speed_r;

  if (MY_MOTOR_DIFF > 0)   /* linker Motor schwaecher */
    speed_l = (left+MY_MOTOR_DIFF) > 255 ? (left+MY_MOTOR_DIFF) : 255;
    speed_r = (right-MY_MOTOR_DIFF) < 0 ?  (right-MY_MOTOR_DIFF) : 0;
  }
  else if (MY_MOTOR_DIFF < 0)  /* rechter Motor schwaecher */
  {
    speed_l = (left+MY_MOTOR_DIFF) <0 ? (left+MY_MOTOR_DIFF) : 0;
    speed_r = (right-MY_MOTOR_DIFF) >255 ?  (right-MY_MOTOR_DIFF) : 255;
  }
  else
  {
    speed_l = left;
    speed_r = right;
  }
  MotorSpeed((unsigned char)speed_l, (unsigned char)speed_r);
}

[Andun]

Hi

Ahhhhha!!! Das ist das Problem! Die Lib liest sich so, als wäre die MY_ASURO_DIFF schon in den Funktionen integriert und arbeitet mit einem Wert von 0, wenn man nichts angibt.

Das sollte auf jeden Fall richtig gestellt werden!

Ich möchte auch die Behauptung aufstellen, dass die Definition der Konstante in der Lib ohne die passende Funktion, die diese nutzt, überflüssig macht.

Naja, ich nutz mal deine Variante.

Danke

Andun

[damaltor]

an sich ist die konstante witzlos, man könnte, da ohnehin nur eine bestimmte gescwindigkeit funktioniert, auch gleich diese als konstante verwenden.

[inka]

war das nicht mal dafür gedacht um unterschiede in der motorleistung zu kompensieren?

[damaltor]

ja, genau. es zeigt einfach nur an, wenn der linke motor mit ### fährt, dann muss der rechte motor mit ###+MY_MOTOR_DIFF fahren.

leider ist diese differenz nicht gleichbleibend bei verschiedenen geschwindigkeiten, deshalb geht es nur bei einer bestimmten.

[Andun]

Naja, im groben ist die Idee ja wirklcih sinnvoll und angebracht.

Aber dass überhaupt nichts passiert wenn man die Konstante mit einem Wert füllt ist halt doch etwas ... - ich komm mir veräppelt vor.

Ich denke mal, dass die Konstante schon sinnvoll ist, wenn man damit erstmal ne grobe Ungleichheit zwischen den Motoren ausgleicht.

Wenns genau werden soll, muss man sowieso die Odometrie benutzen.

mfg
Andun

[Sternthaler]

Hallo Andun,
ja, ich gebe zu, dass eine nicht benutzter Define, zu dem es dann auch schon eine Dokumentation gibt, nicht besonders sinnvoll ist.
Weiter gebe ich zu, das dies alles von mir stammt. Sowohl der Define, als auch die Doku.

Für mich war/ist der Wert in einigen meiner Programme recht sinnvoll. Ein Regler zieht häufig zu viel Speicher weg, und für einige Programme reicht es (mir zumindest), wenn der Asuro so halbwegs geradeaus fährt.

Wenn ich zu Hause bin (ja, immer noch in der Firma) poste ich mal die Codestellen an denen ich diesen Define nutze. Dann werde ich das auch gleich für die nächste LIB-Version dort nachziehen.

Gruß Sternthaler

[Sternthaler]

So, da habe ich es nun geschafft nach Hause zu kommen.

Hier erst einmal der Code für die Funktion MotorSpeed()
Wer es selber einbauen möchte, findet die Funktion je nach LIB-Version in unterschiedlichen Dateien.
- Asuro-Original-CD in asuro.c
- Asuro-LIB bis Version V02.70rc2 in motor.c
- Asuro-LIB ab Version V02.70rc3 in motor_low.c
- In der nächsten Asuro-LIB dann auch vorhanden.

inline void MotorSpeed (
  unsigned char left_speed,
  unsigned char right_speed)
{
           int  l_speed;
           int  r_speed;

  if (MY_MOTOR_DIFF != 0)
  {
    /*
      Das Ganze macht nur Sinn, wenn mindestens ein Motor fahren soll.
    */
    if (left_speed  > 0  ||
        right_speed > 0)
    {
      /*
        Bei positivem MY_MOTOR_DIFF wird der rechte Motor verstaerkt.
        Bei negativem MY_MOTOR_DIFF wird der linke  Motor verstaerkt.
      */
      l_speed = left_speed  - MY_MOTOR_DIFF / 2;
      r_speed = right_speed + MY_MOTOR_DIFF / 2;

      /*
        Wertebereich von 0 bis 255 pruefen.
        Unterscheiden nach positiver, bzw. negativer Vorgabe.
      */
      if (MY_MOTOR_DIFF > 0)
      {
        /*
          Bei positivem MY_MOTOR_DIFF kann nur die rechte Seite > 255 werden.
        */
        if (r_speed > 255)
        {
          /*
            Um die Differenz von MY_MOTOR_DIFF weiterhin zu erhalten, wird nun
            die linke Seite noch weiter reduziert, und die rechte Seite auf
            das zulaessige Maximum gesetzt.
          */
          l_speed -= (r_speed - 255);
          r_speed  = 255;
        }
        if (l_speed < 0)
        {
          /*
            Die linke Seite ist nun unter dem zulaessige Minimum von 0.
            Auch dies muss korrigiert werden.
          */
          l_speed = 0;
        }
      }
      else
      {
        /*
          Bei negativem MY_MOTOR_DIFF kann nur die linke Seite > 255 werden.
        */
        if (l_speed > 255)
        {
          /*
            Um die Differenz von MY_MOTOR_DIFF weiterhin zu erhalten, wird nun
            die rechte Seite noch weiter reduziert, und die linke Seite auf
            das zulaessige Maximum gesetzt.
          */
          r_speed -= (l_speed - 255);
          l_speed  = 255;
        }
        if (r_speed < 0)
        {
          /*
            Die rechte Seite ist nun unter dem zulaessige Minimum von 0.
            Auch dies muss korrigiert werden.
          */
          r_speed = 0;
        }
      }

      left_speed  = l_speed;
      right_speed = r_speed;
    }
  }

  OCR1A = left_speed;
  OCR1B = right_speed;
}

Keine Bange vor der Länge der Funktion.
Ist der Define für MY_MOTOR_DIFF mit 0 angegeben, wird gar kein zusätzlicher Code erzeugt. Sonst werden gerade mal um 45 Byte zusätzlich benötigt.

Gruß Sternthaler

P.S.: Ich habe mal mit verschiedenen Geschwindigkeiten die Wirkung getestet. Natürlich bekommt man keine gerade Fahrt über alle Geschwindigkeiten, allerdings sind die Abweichungen sehr gering.