Kalibrierung der Motoren

[Werner++]

Wenn ich das ausführe, fährt er erst 5 Sekunden im Kreis, danach aber relativ gerade. Hat jemand eine Ahnung, wie das geht?

Hallo BeeWee,

nein, da habe ich auch keine Idee. Aber um nochmal auf Dein ursprüngliches Programm zurückzukommen. Mit der Funktion CalibrateWheels stellst Du das Verhältnis der Geschwindigkeiten von rechtem zu linken Rad fest. Warum sollte der Asuro gerade aus fahren, wenn man den linken Wert bei Motorspeed damit multipliziert?
Da der Nullpunkt der Geschwindigkeit nicht bei 0 liegt, sondern bei einem Wert für MotorSpeed ca. um die 100 oder mehr, so kann das gewählte Verfahren im Grunde nie zu einer Geradeausfahrt führen.

Gruß
Werner

[Sternthaler]

Oh, oh,
wer hat denn da all die schönen warnings vom Compiler übersehen?

Ich habe den Code nun auch mal übersetzt und die warnings gesehen.
Das übersetzen vom Programm, mit der Abc()-Funktion, liefert einen Output mit:
"test.c:9: warning: implicit declaration of function `Abc'"

Was macht der Compiler da den raus?
Oh, schade, das wird ein int-Typ. Danach ist alles irgendwie falsch.

So geht es nun:
(Im ersten Programm fehlt auch noch ein "#include <string.h>", und dan sind da immer noch warnings)"

#include "asuro.h"

/*  DAS HIER IST WICHTIG */
float Abc(void);
void TimeSleep (unsigned int time);

int main (void)
{
   float wheel_factor;

   Init ();
   
   wheel_factor = Abc ();

   MotorSpeed (255, 255 * wheel_factor);
   TimeSleep (2000);

   MotorSpeed (255, 255 * 1.00);
   TimeSleep (2000);

   MotorSpeed (0, 0);

   while (1);
   return 0;
}

float Abc(void)
{
   return 1.00;
}

void TimeSleep (unsigned int time)
{
   // Sleep for ``time`` miliseconds
   unsigned int i;

   for (i = 0; i < time; i++)
      Sleep(72);
}

[radbruch]

Man seid ihr schnell. Ein Lösungsversuch ohne float:

int8_t CalibrateWheels(int8_t power_right) {
....

return power_right * count_left / count_right ;
}

@Werner++

Mit der Funktion CalibrateWheels stellst Du das Verhältnis der Geschwindigkeiten von rechtem zu linken Rad fest.

Es werden die Impulse innerhalb einer bestimmten Zeit gemessen. Daraus könnte man dann schon die Geschwindigkeit berechen, aber das braucht man nicht. Das wird auch sehr ungenau, weil der Hochlauf der Motoren noch nicht berücksichtigt ist. Auch andere Faktoren wie mechanische Ungenauigkeiten der Räder, der Untergrund und die Traktion spielen hier noch rein. Vereinfacht kann man aber sagen: Gleiche Impulszahl auf beiden Seiten bedeutet geradeaus.

[Sternthaler]

Und dann hier auch noch die Lösung für den letzten warning aus dem eigendlichen Programm:

void Write (char *msg); // Die Variable msg bitte mit * als Pointer uebergeben.

Und nun, alle zusammen: Juchu

@radbruch
Pfiffige Lösung zum umgehen des Problems!

[ehenkes]

Ihr seid ja richtig fix bei der Hitze.
Ich habe in der Zwischenzeit doch noch mit float herum gespielt, zum Geradeausfahren reicht das leider noch nicht, mal dreht er nach links, mal nach rechts ab.

#include "asuro.h"
#include <string.h> //strlen

void TimeSleep(unsigned int time) 
{
        unsigned int i;
        for (i = 0; i < time; ++i) 
            Sleep(72);
} 

void Write(char * msg) 
{
        SerWrite( msg, strlen(msg));
}

unsigned int is_bright(unsigned int darkness) 
{
    if (darkness > 512) 
        return 0;
	else 
        return 1;
}

float CalibrateWheels(void) 
{
    Write("Start calibration");
    
    unsigned int i;        // counter
    unsigned int data[2];  // odometry data

    // rotation count of the wheels
    unsigned int count_left  = 0;
    unsigned int count_right = 0;

    // contains the last brightness state for the wheels
    unsigned int last_state[2];
    OdometrieData(data);
    last_state[0] = is_bright(data[0]);
    last_state[1] = is_bright(data[1]);

     // the relation between the left amd the right wheel's rotation count
     float relation;

     // start driving
     MotorDir(FWD, FWD);
     MotorSpeed(120, 120);
     TimeSleep(500); //Zum Hochfahren

     // 5 seconds
     for (i = 0; i < 100; ++i) 
     {
        OdometrieData(data);

        // if a wheel's brightness changed, increase the counter
        if (is_bright(data[0]) != last_state[0]) 
	    count_left++;
        if (is_bright(data[1]) != last_state[1]) 
            count_right++;

        last_state[0] = is_bright(data[0]);
    	last_state[1] = is_bright(data[1]);

        TimeSleep(50);
    }

    relation = (float) count_right / (float) count_left;

    // done testing, stop wheels
    MotorSpeed(0, 0);

    Write("Finished calibration");
    return relation;
}

int main(void)
{
        Init();

        MotorSpeed(120, 120.0f * CalibrateWheels());

        while(1);
        return 0;
}

Hat jemand einen Tipp dazu aus euren bisherigen Überlegungen?

[Sternthaler]

Im Moment fällt mir nur folgendes ein:

Drum prüfe, was der Linker bindet, ob sich nicht noch ein warning findet.

Und auch von mir ein Willkommen an BeeWee und Werner++
Tut mit leid, hatte ich in der Hitze des Tages und der Fehlersuche übersehen, dass es euch neu in's Roboternetz gebracht hat.

[datobbs]

hi ehenks,

und von mir ebenfalls ein Willkommen an BeeWee und Werner++

ich habe noch nicht allzuviel ahnung,
aber ich würde mir mal am ende der calibration count_left und count_right ausgeben lassen, weil ich einfach mal spekulieren würde dass die nicht sonderlich hoch sind...vielleicht täusch ich mich auch...

gruß tobi

[ehenkes]

Der ASURO fährt während der Kalibrierung besser gerade aus als danach. Laughing

Drum prüfe, was der Linker bindet, ob sich nicht noch ein warning findet.

Süßer Spruch! Den kannte ich noch gar nicht.

[damaltor]

Sagt mal fahren euro asuros echt erst so spät los? meiner fährt bei (70,70) schon (solage es nicht bergauf geht =)

[Sternthaler]

@damaltor
Bei 70? Wahnsinn!!! Fährst du mit Batterien? Alles geölt? Oder normaler Asuro?

@ehenkes
Hatte ich im Überschwang des Glück's gestern mal so erfunden. Meine Mutter hatte in meiner Sturm- und Drangzeit immer etwas Ähnliches auf den Lippen. Allerdings hatte sie keine Linker im Sinn. Und ich auch nicht