Hey,
Ich wollte mal fragen wie ihr eure Motoren so steuert mit den Daten der Odometrie.
Da mein eines Getriebe schwerer zu drehen geht, habe ich ein leichten links drall und will den ausgleichen mit der Odometrie.
Mein gedanke ist das ich mir die Differenz der beiden Odometrie getLeft und getRight liefern lasse und damit irgendwie meine Motoren steuere das er gerade fährt.
Danke schonmal.

Da die motpid.h funktion bei mir keine Wirkung zeigt und er immer noch schief fährt habe ich mich mal selber rann gesetzt..

Aber es funktioniert immer noch nicht manchmal habe ich das gefühl das er korrigiert aber nicht immer was meint ihr sind meine Sensoren vll. defekt ?

#include <nibobee/robomain.h>





void setup() {

odometry_init ();
motpwm_init ();

}



void loop() {
int power_l;
int power_r;
int pwm;
int ticksl;
int ticksr;
int faktor_r;
int faktor_l;
//int ticksd;

power_l = 300;
power_r = 300;

odometry_reset ();
motpwm_setLeft(power_l);
motpwm_setRight(power_r);
delay(100);

ticksl=odometry_getLeft(0);
ticksr=odometry_getRight(0);

if( ticksl > ticksr )
{
//ticksd=ticksl-ticksr;
//pwm=(int)((ticksl-ticksr)*8.53333333); // Fynn
//pwm=(int)((ticksl-ticksr)*0.0427); // Papa
//power_l=power_l-pwm;
//motpwm_setLeft(power_l);
faktor_l=power_l/ticksl;
pwm=(int) ((ticksl-ticksr)*faktor_l);
power_l=power_l-pwm;
motpwm_setLeft(power_l);
}
if( ticksr > ticksl )
{
//ticksd=ticksr-ticksl;
//pwm=(int)((ticksr-ticksl)*8.53333333); // Fynn
//pwm=(int)((ticksr-ticksl)*0.0427);
//power_r=power_r-pwm;
//motpwm_setRight(power_r);
faktor_r=power_r/ticksr;
pwm=(int) ((ticksr-ticksl)*faktor_r);
power_r=power_r-pwm;
motpwm_setRight(power_r);


}
delay(100);
}

Was gibt Dir "odometry_Get.."?

Eine Ticks-Anzahl. Wenn Du nur daran eine Korrektur (pro Seite) festmachst bringt Dir das nichts.
Die Differenz zwischen links und rechts in Relation zur Gesamt-Ticks-Anzahl (der betrachteten Seite) zu ermitteln wäre schon zielführender. Damit kannst Du einen Korrektur-Faktor ermitteln und diesen anwenden.

Du musst dazu aber sinnvollerweise jeweils die Odometrie-Werte beim Auslesen zurücksetzen (odometry_get...(1)"), damit der jeweilige Zähler nicht überläuft (oder entsprechend mit dem Überlauf umgehen).

Also z.B. bei Ticks_a > Ticks_b:

Faktor = ( 10000 / Ticks_a ) * ( Ticks_a - Ticks_b )
power_a = 300 - ( ( 300 * Faktor ) / 10000 ).

Wenn Du "int"-Variablen nimmst hast Du keine Nachkommastellen ... für den Faktor

Dankeschön für deine Antwort, ich versuch das mal umzusetzen ich glaub das war der Denk anstoss der mir gefehlt hat...
Ich mach das alles zum ersten mal und bin noch ein bisschen überfordert hehe ^_*.

Xagoo schrieb:
Das waren wir alle

Kannst du mir noch eins verraten wieso / durch 10000 und wieso 300 - ((300*faktor) /10000)

/ 10000 weil der Faktor sich aus 10000 / Ticks_gesamt * Ticks_Differenz errechnet. Wie geschrieben gib es bei "int" keine Nachkommastellen - Du musst mit ganzen Zahlen rechnen.

z. B. ( 10000 / 500 ) * 20 = 400

und 300 -

weil die betroffene Seite zu schnell ist und um einen Faktor reduziert (Geschwindigkeit) werden muss

Die Ziel-Geschwindigkeit für beide Räder ist 300 - das schnellere Rad muss gebremst (alternativ das langsamere Rad beschleunigt)
werden, also

300 - ((300 * 400) / 10000) = 300 - 12 = 288.