Anbei mal eine Vorab ansicht des Textes andem ich zur Zeit arbeite vielleicht kann ich den mit deiner Hilfe Kompletieren.
Vortext:
Die Idee zu einem Kartenmodell im Roboter
Die Welt wird zu einem Schachbrett und wir teilen sie in Quadrate auf.
Die Größe der Quadrate ist eigentlich egal, aber sie ist ein Kompromiß zwischen Speicherbedarf und Genauigkeit. Je kleiner, desto genauer, aber desto mehr Speicher wird benötigt. Hier spielt die Robotergröße und der verwendete Controller und/oder PC eine Rolle.
In meiner Berechnung und den Beispielen gehe ich von 5 cm Quadraten aus.
Die von mir in C programmierten Berechnungen/Darstellungen sind so zu verstehen:
Spielfeld 2 x 2m = 40 x 40 Quadrate = 1600 Werte.
Die Zahl 40 paßt in 1 Byte (0 bis 255 oder alternativ definiert –127 bis +127)
Also reicht das für jeden Punkt auf der Karte selbst wenn der Roboter sehr ungünstig aufgestellt wird.
Beispiel:
Bild hier
Wie man in dem oberen Bild sieht, ist die Koordinate immer vom Startpunkt des Roboters abhängig. Daraus ergeben sich folgende Vorgaben:
Die Speicherstruktur muß so groß sein, das die Zahlenwerte sowohl in den positiven, wie auch in den negativen Bereich des Arrays passen. Warum? Wir wissen ja nicht, wo der Roboter startet.
Problem: Da wir nicht wissen wo wir sind, können wir das Array nicht füllen, wenn wir es wie ein Koordinaten-System anlegen. In einer Array-Karte [40][40] finden wir den Punkt ja nicht.
Also definieren wir die Karte anders:
Karte[1600][2]
Jetzt können wir die Karte von jedem Punkt ausgehend füllen.
Der Nachteil ist aber, das der Speicherbedarf so eben mal auf das doppelte ansteigt: satte 3200 Byte für die Karte[1600][2], im Gegensatz zu den 1600 Byte bei der Karte[40][40]
Noch ein Nachteil unserer definition der Karte uns Fehlt die Information über den Punkt. Wir können nur durch das suchen die Aussage treffen das wir schon mal dort waren.
Also müßte die Karte[1600][3] definiert werden, um dieselbe Leistungsfähigkeit zu erhalten. Das wären aber dann schon 4800 Bytes = 4,7 Kbytes.
Aus diesem Dilemma weiß ich zur Zeit auch keinen Ausweg.
Ich finde ein paar Zeilen Code sagen mehr als tausend Worte:
Code:
int g_nLastEntry = 0;
BYTE g_Karte[1600][3];
bool WritePos(BYTE X,BYTE Y)
{
for(int pos=0;pos< g_nLastEntry;pos++)
{
if((X = g_Karte[pos][0]) &&(Y = g_Karte[pos][1]))
{
return true;
}
}
g_Karte[g_nLastEntry][0] = X;
g_Karte[g_nLastEntry][1] = Y;
g_Karte[g_nLastEntry][2] = 1;
return false;
}
main()
{
//Fahren
//Poserrechen
if(WritePos)
{
//Hier waren wir schon mal
}
}
Wie kommen wir auf X und Y:
Wir wissen die Drehrichtung des Rades (vorwärts/rückwärts) und welches Rad wie viele Schritte macht (mit Steppern oder mit Rad-Decodern).
Ist in der Zeit (t) die Anzahl der Tick's (Rad-Decoderimpulse oder Schritte des Steppers)
gleich, bewegt der Roboter sich geradeaus. Wenn die Anzahl der Tick's, die 5 cm entsprechen erreicht sind, rechnen wir X+1 oder X-1 jenachdem ob vorwärts oder rückwärts gefahren wird.
Beispiel:
Ein Rad mit dem Durchmesser von 5 cm hat einen Umfang von 15,70 cm. Bei einem Rad-Decoder mit der Teilung 256 entspricht das dann 0,061 cm pro Tick. Dann sollten 82 Tick's ca. 5 cm sein.
Wir brauchen also ein Rad welches den Takt angibt, entweder das Linke oder das Rechte. Je nach Lust und Laune.
Jetzt wird es kompliziert: Die Kurve:
Bild hier
Wir gehen von einem Rad-Abstand von 15 cm aus.
Wenn ein Rad steht, ergibt das einen Kreisumfang (Wendekreis) von 94 cm.
Wenn die Räder sich gegenläufig drehen (Drehpunkt liegt dann zwischen den Rädern), haben wir einen Kreisumfang von 47 cm.
Fall 1: Ein Rad steht
Nur das rechte Rad dreht sich um 30 Tick's nach vorne. Das entspricht einer Bewegung auf dem großen Kreis um 1,83 cm.
Also:
Länge Kreisbogen : b = pi* d *(Alpha/360) gesucht wird Alpha
b = 1,83 cm
d= 94 cm
Alpha = ?
b*360
-------- = Alpha
d*pi
Richtig ?
*Ende*
Verstehst du das ?
Das mit der Kurve zu berechen wird nichte ienfach aber ich hoffe das ich es trotzdem irgendwann erklären kann und ich mich nicht ganz täusche
Zitieren
Lesezeichen