-         

Seite 1 von 5 123 ... LetzteLetzte
Ergebnis 1 bis 10 von 47

Thema: Probleme mit Go(...)

  1. #1
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    14.04.2007
    Ort
    Einhausen
    Alter
    61
    Beiträge
    674

    Probleme mit Go(...)

    Anzeige

    Mein ASURO macht Probleme beim Geradeausfahren. Mit diesem Code geht es halbwegs, hierbei gibt es eher Probleme mit der Präzision der Turns.

    Code:
    #include "asuro.h"
    
    int main()
    {
      Init();
      EncoderInit(); 
     
      StatusLED (RED);
      
      const int POWER=130;
     
      int i,j;
     
      for (i=0; i<5; ++i)
      {
        for (j=0; j<3; ++j) //Dreieck
        {
            Go(-500,POWER);
            Turn(120,POWER);
        }
      }
     
      StatusLED (GREEN); 
     
      for (i=0; i<5; ++i)
      {
        for (j=0; j<4; ++j) //Quadrat
        {
            Go(-500,POWER);
            Turn(90,POWER);
        }
      }
     
      StatusLED (RED);
     
      while (1);
      return 0;
    }
    Lasse ich ihn allerdings vorwärts fahren, also Go(500,POWER), dann bricht er nach wenigen cm stark nach links aus, teilweise dreht er nur noch auf dem Fleck.

    Was könnte hier der Grund sein? Rückwärts o.k., vorwärts ganz mies. Kommt da die Odometrie in Frage?

    Verwende aktuelle Lib Version 2.70

  2. #2
    Moderator Robotik Einstein Avatar von damaltor
    Registriert seit
    28.09.2006
    Ort
    Jena
    Alter
    31
    Beiträge
    3.912
    könnte es sein dass eine odo-scheibe nicht ganz fest auf dem zahnrad klebt? das problem hatte ich mal. ansonsten: lass ihn einfach mal fahren mit

    MotorDir(FWD,FWD);
    MotorSpeed(180,180);

    dann wird er zwar krumm fahren, aber interessant wäre ob bei dieser gelegenheit ebenfalls plötzlich wegknickt.

    ausserdem solltest du probieren, den POWER wert zu erhöhen in der go-funktion. die gescshwindigkeit der räder wird ja geregelt, und wenn der wert eines rades zu stark nach unten geregelt wird, könnte es sein dass die reibung zu groß ist um es noch zu bewegen -> ein rad bleibt stehen.
    kleinschreibung ist cool!

  3. #3
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    14.04.2007
    Ort
    Einhausen
    Alter
    61
    Beiträge
    674
    1) odo-Scheibe sitzt fest.

    2) Folgendes Programm
    Code:
    #include "asuro.h"
    int main()
    {
      Init();
      MotorDir   (FWD,FWD);
      MotorSpeed (180,180); 
      while (1);
     return (0);
    }
    ergibt kein Abknicken, sondern eine fast-Geradeaus-Fahrt mit leichtem Trend nach rechts. Das liegt logischerweise an den Unterschieden im Antriebssystem trotz gleicher PWM. Also liegt es am Odometer-System.
    Jetzt stellt sich die Frage: Wie findet man den genauen Fehler bei Go(...)?

  4. #4
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    29.05.2005
    Beiträge
    1.018
    @ehenkes
    Hallo, du solltest keinesfalls POWER-Werte > 255 benutzen.
    Die Variable speed in Go() und Turn() ist zwar als int angegeben, aber dies wird nur gemacht, damit ein Vorzeichen übergeben werden kann.
    Wäre die Variable vom Typ 'signed char', dann ginge das zwar auch, aber du könntest halt nur Geschwindigkeiten von +127 bis -128 angeben.
    Die speed-Variable wird in beiden Funktionen immer positiv an MotorSpeed() weitergegeben. Das Vorzeichen setzt nur die Motordrehrichtung.

    Grundsätzlich ist es aber trotzdem verwunderlich.
    Jetzt muss ich aber erst mal von der Firma nach Hause.
    Lieber Asuro programieren als arbeiten gehen.

  5. #5
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    14.04.2007
    Ort
    Einhausen
    Alter
    61
    Beiträge
    674
    @Sternthaler: jetzt hast Du mich verwirrt. Ich habe doch nirgends POWER > 255 verwendet.

    Welchen Wertebereich hat int? Ist das ein 8bit oder 16bit int.

    Nehmen wir zum Verständnis ein konkretes Beispiel: Go(500,150);

    #define MY_GO_ENC_COUNT_VALUE 19363L (findet sich in myasuro.h)

    enc_count = abs(distance)*10000L; // enc_count = 500 * 10000 ==> 5000000

    Diese 5 Mio. passen ja nicht in ein int, daher nimmt man ja wohl diesen Typ uint32_t.

    enc_count /= MY_GO_ENC_COUNT_VALUE; // enc_count = 5000000 / 19363 ==> 258



    Das ist die zu erreichende Zielmarke an Zählern über die Odometrie. Es wird nun solange vorwärts gefahren bis diese Zielzahl erreicht ist.

    while (tot_count<enc_count){...}

    Stimmt hier alles? tot_count ist doch int, 8bit oder 16bit? Wie wird hier umgewandelt für den Vergleich?

    Dabei wird das linke Rad zum Zählen verwendet. Hier könnte man doch auch das rechte nehmen? Geht bei mir minimal besser, aber ebenfalls abschwenken nach links, bis das linke Rad überhaupt nicht mehr dreht.

    tot_count += encoder[LEFT];

    Zum Vergleich werden die Zähler rechts und links verglichen.

    diff = encoder[LEFT] - encoder[RIGHT];

    Nehmen wir an, links sind mehr Zähler als rechts, diff also positiv, dann wird je nach Geschwindigkeit entweder links um 10 Power-Einheiten reduziert oder rechts um 10 Power-Einheiten erhöht.

    if ( (l_speed > speed) || (r_speed > 244) )
    {
    l_speed -= 10;
    }
    else
    {
    r_speed += 10;
    }

    Ein transparentes Verfahren, das analog in Turn(...) eingesetzt wird. Voraussetzung für das Gelingen ist, dass die Odometrie verlässliche Daten liefert und die gesamte Antriebselektrik und -mechanik funktioniert. Über die Konstanten in myasuro.h kann man sein individuelles Exemplar softwareseitig so kalibrieren, dass die gefahrerene Distanz und der gedrehte Winkel möglichst genau passen.

    Wie kann ich die Odometrie testen, ob Diode/Fototransistor auf beiden Seiten überhaupt richtig arbeiten?

  6. #6
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    12.06.2005
    Ort
    Südwestdeutschland
    Beiträge
    1.062
    Blog-Einträge
    2
    Wie kann ich die Odometrie testen, ob Diode/Fototransistor auf beiden Seiten überhaupt richtig arbeiten?
    Du könntest die Wert Helligkeitswert der Odometrietransistoren mit PrintInt( ... ) ausgeben. Nicht vergessen: Odometriebeleuchtung vorher einschalten!

    Gruss,
    stochri

  7. #7
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    14.04.2007
    Ort
    Einhausen
    Alter
    61
    Beiträge
    674
    Code:
    #include <stdlib.h>
    #include "asuro.h"
    #include "myasuro.h"
    
    void MyGo (  int distance,  int speed)
    {
      uint32_t enc_count;
      int tot_count = 0;
      int diff = 0;
      int l_speed = speed, r_speed = speed;
      unsigned char text[8];
    
      // calculation tics/mm
      enc_count=abs(distance)*10000L;
      enc_count/=MY_GO_ENC_COUNT_VALUE;
      EncoderSet(0,0); // reset encoder
    
      MotorSpeed(l_speed,r_speed);
      if (distance<0) MotorDir(RWD,RWD);
      else MotorDir(FWD,FWD);
    
      while (tot_count<enc_count)
      {
        tot_count += encoder[RIGHT]; //im Original LEFT ehenkes
        diff = encoder[LEFT] - encoder[RIGHT];
        if (diff > 0)
        { //Left faster than right
          if ((l_speed > speed) || (r_speed > 244)) l_speed -= 10;
          else r_speed += 10;
        }
        if (diff < 0)
        { //Right faster than left
          if ((r_speed > speed) || (l_speed > 244)) r_speed -= 10;
          else l_speed += 10;
        }
        EncoderSet(0,0); // reset encoder
        MotorSpeed(l_speed,r_speed);
    	itoa(diff, text, 10);     
        SerPrint(text);
        SerPrint("    "); 
    	itoa(l_speed, text, 10);     
        SerPrint(text);
        SerPrint("    "); 
    	itoa(r_speed, text, 10);     
        SerPrint(text);
        SerPrint("\r\n"); /* Zeilenvorschub */
        Msleep(1);
      }
      MotorDir(BREAK,BREAK);
      Msleep(200);
    }
    
    
    
    int main(void)
    {
      
      
      Init();
      EncoderInit();
        
      SerPrint("\r\nMYGo Test\r\n");
      while (1)
      {
        int i;
        for(i=0;i<10;++i)
        {
    	  MyGo(150,150);
    	  
    	  StatusLED(RED);
    	  Msleep(1000);
    	  
    	  StatusLED(GREEN);
        }
        StatusLED(YELLOW);
      }
      
    }
    Werte aus dem Hyperterminal für diff speed_l speed_r

    9 150 230
    8 150 240
    9 150 250
    8 140 250
    8 130 250
    8 120 250
    8 110 250
    8 100 250
    6 90 250
    6 80 250
    4 70 250
    4 60 250
    4 50 250
    3 40 250
    1 30 250
    1 20 250
    0 20 250
    0 20 250
    0 20 250
    0 20 250
    0 20 250
    0 20 250
    0 20 250
    0 20 250

    Was kann man daraus schließen?

    Den Hinweis von stochri habe ich leider noch nicht verstanden.

  8. #8
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    14.04.2007
    Ort
    Einhausen
    Alter
    61
    Beiträge
    674
    "Odometriebeleuchtung vorher einschalten"

    Wie geht das genau ? Ist das "EncoderInit()" ?

  9. #9
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    29.05.2005
    Beiträge
    1.018
    Zitat Zitat von ehenkes
    @Sternthaler: jetzt hast Du mich verwirrt. Ich habe doch nirgends POWER > 255 verwendet.
    Oh man, ich hätte doch früher nach Hause gehen sollen. Du hast natürlich Recht. Ich habe mich mit dem distance-Parameter vertan. Der ist ja bei dir -500.

    Zitat Zitat von ehenkes
    Welchen Wertebereich hat int? Ist das ein 8bit oder 16bit int.
    Egal auf welchem System: Immer 16 Bit. Ist meines wissens der einzige Datentyp der auf allen Betriebssystemen fest ist. Deshalb gibt es die Typen uint32_t und Co.

    Zitat Zitat von ehenkes
    while (tot_count<enc_count){...}
    Stimmt hier alles? tot_count ist doch int, 8bit oder 16bit? Wie wird hier umgewandelt für den Vergleich?
    Du hast ja schon selber gerechnet und bist auf einen Wert für enc_count mit 258 gekommen. Das liegt also noch locker im int-Bereich (16Bit). C castet ja automatisch. Bei einem Vergleich wird (schon wieder: so weit ich weiss) grundsätzlich auf den größten Datentyp 'hochgecastet'. Somit müßte eigendlich ein 32-Bit-Vergleich entstehen.
    Das jedenfalls macht der Compiler daraus. (4 mal cp, somit 4*8Bit=32Bit)
    Code:
       while (tot_count < enc_count)
        15c8:	e1 14       	cp	r14, r1
        15ca:	f1 04       	cpc	r15, r1
        15cc:	01 05       	cpc	r16, r1
        15ce:	11 05       	cpc	r17, r1
        15d0:	09 f4       	brne	.+2      	; 0x15d4
        15d2:	47 c0       	rjmp	.+142    	; 0x1662
    
    Warum auch immer nur mit r1 verglichen werden muss.
    Zitat Zitat von ehenkes
    Dabei wird das linke Rad zum Zählen verwendet. Hier könnte man doch auch das rechte nehmen?
    Ja, ohne Probleme.

    Zitat Zitat von ehenkes
    Wie kann ich die Odometrie testen, ob Diode/Fototransistor auf beiden Seiten überhaupt richtig arbeiten?
    OK, hier mal ein Datensammler:
    (Tastennummerierung: Von vorne auf den Asur gesehen: Links ist 1 rechts ist 6)
    Bedienung:
    Taste 5 fährt den Asuro ca 10 cm vorwärts (Am besten in der Hand halten und die Räder etwas bremsen. Evl. bei unterschiedlicher Beleuchtung ausprobieren, bis beide Räder halbwegs gleichmäßig drehen.)
    Taste 1 sendet die ermittetelten Messdaten in folgendem Format:
    PID LD RD LH RH
    vergiss PID, LD und RD
    In LH und RH sind die Messungen der Odometriesensoren Links und Rechts.
    In Excel sollten die Daten so halbwegs gleichförmige Sinuskurven erzeugen.
    ACHTUNG:
    Taste 2, 3 und 4 schaltet Parameter um. Zur Not Asuro nochmal aus- und wieder anschalten. (Mit IR Übertragung als 'Menue')
    Taste 6 lässt den Asuro auch fahren. Macht hier aber Blödsinn. Nimm Taste 5.

    @stochri
    Schön dich mal wieder zu treffen.
    Hast du hier ein Erklärung? Vor allem mit den Daten von ehenkes.
    Programmseitig sieht es ja ok aus. (Ja, ja, -500 sind der Weg.)
    Angehängte Dateien Angehängte Dateien
    Lieber Asuro programieren als arbeiten gehen.

  10. #10
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    14.04.2007
    Ort
    Einhausen
    Alter
    61
    Beiträge
    674
    Ich habe mit dem Programm
    >> LoggingOdometers V1.0 (2006-05-21, Arexx-Henk) <<
    folgende Daten festgestellt:
    Code:
    LoggingOdometers V1.0 (2006-05-21, Arexx-Henk)
    
    Left Odometer
    
    +00193
    +00197
    +00192
    +00190
    +00193
    +00179
    +00136
    +00109
    +00110
    +00104
    +00087
    +00100
    +00129
    +00145
    +00166
    +00183
    +00198
    +00208
    +00204
    +00192
    +00178
    +00149
    +00120
    +00113
    +00101
    +00078
    +00092
    +00119
    +00120
    +00135
    +00172
    +00199
    +00207
    +00199
    +00197
    +00176
    +00152
    +00139
    +00121
    +00089
    +00095
    +00113
    +00112
    +00116
    +00145
    +00179
    +00183
    +00177
    +00192
    +00200
    +00190
    +00180
    +00153
    +00116
    +00099
    +00107
    +00103
    +00104
    +00134
    +00170
    +00185
    +00196
    +00201
    +00203
    +00195
    +00180
    +00167
    +00137
    +00103
    +00105
    +00112
    +00100
    +00113
    +00143
    +00169
    +00188
    +00204
    +00208
    +00205
    +00196
    +00183
    +00148
    +00105
    +00091
    +00102
    +00099
    +00105
    +00130
    +00148
    +00173
    +00190
    +00198
    +00193
    +00192
    +00192
    +00188
    +00156
    +00115
    +00109
    +00112
    +00096
    +00092
    +00120
    +00147
    +00161
    +00179
    +00197
    +00207
    +00207
    +00197
    +00180
    +00153
    +00137
    +00125
    +00091
    +00083
    +00107
    +00113
    +00113
    +00140
    +00174
    +00192
    +00207
    +00203
    +00197
    +00181
    +00152
    +00139
    +00127
    +00094
    +00096
    +00112
    +00112
    +00116
    +00147
    +00179
    +00182
    +00179
    +00193
    +00199
    +00190
    +00180
    +00150
    +00113
    +00099
    +00107
    +00103
    +00105
    +00135
    +00172
    +00186
    +00197
    +00201
    +00203
    +00192
    +00179
    +00162
    +00126
    +00106
    +00113
    +00105
    +00097
    +00120
    +00148
    +00173
    +00191
    +00204
    +00208
    +00206
    +00192
    +00167
    +00153
    +00118
    +00078
    +00083
    +00106
    +00119
    +00129
    +00146
    +00172
    +00193
    +00201
    +00193
    +00200
    +00192
    +00177
    +00160
    +00125
    +00093
    +00096
    +00109
    +00103
    +00111
    +00142
    +00168
    +00184
    +00193
    +00207
    +00206
    +00191
    +00176
    +00164
    +00130
    +00097
    +00100
    +00099
    +00089
    +00105
    +00130
    +00145
    +00167
    +00191
    +00207
    +00195
    +00184
    +00185
    +00163
    +00130
    +00099
    +00104
    +00114
    +00096
    +00100
    +00131
    +00157
    +00176
    +00188
    +00187
    +00192
    +00191
    +00197
    +00170
    +00131
    +00116
    +00114
    +00093
    +00088
    +00118
    +00150
    +00168
    +00185
    +00199
    +00204
    +00201
    +00196
    +00176
    +00148
    +00133
    +00116
    +00092
    
    Right Odometer
    
    +00221
    +00223
    +00224
    +00217
    +00208
    +00200
    +00188
    +00176
    +00169
    +00169
    +00172
    +00177
    +00186
    +00195
    +00205
    +00214
    +00217
    +00220
    +00215
    +00208
    +00206
    +00198
    +00184
    +00173
    +00167
    +00165
    +00165
    +00172
    +00183
    +00192
    +00204
    +00211
    +00216
    +00216
    +00214
    +00209
    +00204
    +00195
    +00183
    +00174
    +00168
    +00166
    +00167
    +00173
    +00182
    +00192
    +00205
    +00211
    +00215
    +00217
    +00215
    +00209
    +00203
    +00192
    +00176
    +00166
    +00159
    +00160
    +00166
    +00174
    +00182
    +00193
    +00204
    +00215
    +00219
    +00211
    +00207
    +00203
    +00195
    +00192
    +00182
    +00175
    +00169
    +00168
    +00172
    +00178
    +00188
    +00195
    +00208
    +00217
    +00221
    +00221
    +00217
    +00210
    +00200
    +00187
    +00176
    +00171
    +00167
    +00167
    +00171
    +00177
    +00184
    +00195
    +00207
    +00217
    +00220
    +00222
    +00218
    +00208
    +00200
    +00189
    +00174
    +00163
    +00160
    +00163
    +00169
    +00178
    +00188
    +00196
    +00207
    +00214
    +00217
    +00218
    +00209
    +00204
    +00200
    +00188
    +00172
    +00161
    +00155
    +00155
    +00159
    +00171
    +00183
    +00194
    +00206
    +00211
    +00215
    +00214
    +00211
    +00206
    +00199
    +00188
    +00176
    +00167
    +00161
    +00161
    +00165
    +00172
    +00182
    +00196
    +00207
    +00212
    +00216
    +00217
    +00215
    +00209
    +00203
    +00193
    +00179
    +00171
    +00164
    +00164
    +00168
    +00176
    +00184
    +00194
    +00206
    +00217
    +00217
    +00208
    +00206
    +00198
    +00195
    +00190
    +00180
    +00174
    +00169
    +00170
    +00173
    +00179
    +00188
    +00196
    +00209
    +00218
    +00222
    +00220
    +00215
    +00207
    +00195
    +00182
    +00172
    +00167
    +00165
    +00166
    +00172
    +00179
    +00187
    +00199
    +00211
    +00219
    +00221
    +00223
    +00220
    +00211
    +00202
    +00192
    +00177
    +00167
    +00165
    +00167
    +00173
    +00181
    +00189
    +00198
    +00207
    +00215
    +00217
    +00219
    +00212
    +00206
    +00204
    +00192
    +00177
    +00167
    +00162
    +00160
    +00166
    +00176
    +00187
    +00198
    +00208
    +00214
    +00216
    +00215
    +00211
    +00206
    +00199
    +00188
    +00178
    +00171
    +00168
    +00168
    +00172
    +00179
    +00188
    +00201
    +00210
    +00214
    +00217
    +00217
    +00214
    +00208
    +00201
    +00190
    +00176
    +00169
    +00164
    +00167
    
    Left min/max, right min/max values
    
    +00078
    +00208
    
    +00155
    +00224
    
    -Finished-
    Ist das o.k.?

Seite 1 von 5 123 ... LetzteLetzte

Berechtigungen

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