Probleme mit Go(...)

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

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.

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(...)?

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

@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?

Zitat:

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

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.

"Odometriebeleuchtung vorher einschalten"

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

Liste der Anhänge anzeigen (Anzahl: 2)

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

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