odometrie verständniss problem

HI
Ich wollt mich mal an die odometrie wagen und hab mir das jetzt mal so überlegt:

erst müssen die fototransistoren die werte auslesen und irgenndwie speicheren (in einem feld? vielleicht?)

dann nach einer bestimmten zeit durch 8 teilen(ich hab die hell-dunkel-folie mit jeweils 4 hellen un 4 dunklen teilen)

und dann die beiden werte mit einander vergleichen und jenachdem die motorgeschwindigkeit anpassen.

Stimmt das vom prinzip her?
ich hab mal in der suchfunktion nachgeschaut aber i wie sieht das dort viel komplizierter aus... :(
außerdem weiss ich noch nicht ganz genau wie ich dass in C schreiben soll...

kann mir jemand helfen..

danke schon mal im voraus :)

Gruß

Für die Geschwindigkeit brauchst du einmal Impulse, die du von der Odometrie bekommst, dann brauchst du noch etwas, damit du weißt, wie lange du dafür gebraucht hast. Das macht ein Timer. Jetzt gibt es 2 möglichkeiten, wie du vorgehst. Entweder du zählst die Impulse in einer bestimmten Zeit, oder du misst die Zeit und stoppst die Zeit, von einer bestimmten Anzahl von Impulsen. Für Odometrie würde ich Interrupt verwenden.

Hi shorty,

Zitat:

---

Zitat von shorty93

... die beiden werte mit einander vergleichen und jenachdem die motorgeschwindigkeit anpassen ...

---

Genauso, mit einem Vergleich der beiden Zeiten (oder der Geschwindigkeiten) findet man den Istwert der Fahrt. Anhand der Vorgabe kann man dann die Regelung machen. Vielleicht siehst Du Dir dazu mal den Code aus der asuro-Lib an. Dass diese Regelungsgeschichte etwas undurchsichtig ist - zumindest in der Anfangszeit - wissen die meisten von uns. Da muss man leider durch. Aber das Turorial zur Regelungstechnik im Wiki ist sehr gut!

Wie bestimmt man nun diese "Werte" mithilfe der Odometrie des asuro?

Zitat:

---

Zitat von 021aet04

Für die Geschwindigkeit brauchst du einmal Impulse, die du von der Odometrie bekommst ...

---

Die Odometrie des asuro liefert keine Impulse. Die Reflexlichtschranke aus LED und Fototransistor an den Odometriescheiben kann die reflektierte Lichtmenge messen. Das sieht dann so aus:

................Bild hier  

Diese Lichtmenge wird mit dem ADC gemessen und anhand des Verlaufes kann festgestellt werden, ob der Fototransistor ein dunkles oder ein helles Segment der Odometriescheibe "sieht". Die Aufgabe besteht jetzt darin, sich einen Schwellenwert auszusuchen, an dem man den Übergang von schwarz auf weiß oder umgekehrt definiert. Nun muss man nur noch die Zeit messen, die von einem Schwellenwert zum anderen verstreicht. Mit der Anzahl Segmente auf einer Scheibe kann daraus die Drehgeschwindigkeit der Odometriescheibe errechnet und mit der Übersetzung zum Antrieb - und dem Radumfang - die gefahrene Geschwindigkeit errechnet werden. Vielleicht hilft Dir dazu noch dieser Thread etwas weiter.

Zitat:

---

Zitat von 021aet04

... Für Odometrie würde ich Interrupt verwenden.

---

Ich nicht - woher soll denn der Interrupt kommen? Interruptgetriebene Drehzahlmessung macht man mit Gabellichtschranken, Hallsensoren oder so etwas - das hat der asuro nicht. Die Reflexlichtschranke ist da eher eine Art analoger Sensor. Allerdings gibt es auch Lösungen mit Reflexlichtschranken, die einen digitalen Wert liefern. Das ist mit der asuro_Technik nicht möglich.

Also shorty, nimm "einfach" die Lib und wenn Du mehr wissen willst, geh die vielleicht durch. Zur Regelungstechnik findest Du im Wiki (fast) alles Wissenswerte.

Hallo

Wie man im Diagramm oben schön erkennen kann ist der Werteverlauf annähernd sinusförmig.

Zitat:

---

Die Aufgabe besteht jetzt darin, sich einen Schwellenwert auszusuchen, an dem man den Übergang von schwarz auf weiß oder umgekehrt definiert.

---

Ohne Schwellwerte funktioniert es auch gut wenn man eine kleine Anzahl (3-7?) von Werten auf auf- oder absteigend prüft. Das kann man ungefähr so zusammenbasteln (nur links):

Code:

---

    OdometrieData(data);
    if ((data[0]<o1_l) && (o1_l<o2_l) && (o2_l<o3_l)) {
        if (!odo_bit_l) {
            count_l ++;
            odo_bit_l=(1==1);
            StatusLED(YELLOW);
        }
    }
    if ((data[0]>o1_l) && (o1_l>o2_l) && (o2_l>o3_l)) {
        if (odo_bit_l) {
            count_l ++;
            odo_bit_l=(1==0);
            StatusLED(OFF);
      }
    }
    o3_l=o2_l;
    o2_l=o1_l;
    o1_l=data[0];

---

(aus https://www.roboternetz.de/phpBB2/ze...=267922#267922)

o1_l bis o3_l sind die alten Odo-Werte, count_l der Segmentezähler und odo_bit_l ist der Merker für die letzte Flanke. Die IFs prüfen ob alle Werte aufsteigend bzw. abfallend sind. Die StatusLED() blinkt im Wechsel der Segmente (wenn man von Hand das Rad dreht). Das sieht leider etwas unübersichtlich aus :)

Gruß

mic

[Edit]
Als fertige Funktion könnte das dann z.B. so aussehen:

Code:

---

#include "asuro.h"

unsigned int count_l,count_r, data[2];
unsigned char odo_bit_l, odo_bit_r;
unsigned int odo_l_0, odo_l_1, odo_l_2, odo_l_3;
unsigned int odo_r_0, odo_r_1, odo_r_2, odo_r_3;

void count(void) {

    OdometrieData(data);

    odo_l_3=odo_l_2;odo_l_2=odo_l_1;odo_l_1=odo_l_0;odo_l_0=data[0];
    if ((!odo_bit_l) && (odo_l_0<odo_l_1) && (odo_l_1<odo_l_2) && (odo_l_2<odo_l_3)) {
    count_l ++; odo_bit_l=(1==1); StatusLED(YELLOW);
    }
    if ((odo_bit_l) && (odo_l_0>odo_l_1) && (odo_l_1>odo_l_2) && (odo_l_2>odo_l_3)) {
    count_l ++; odo_bit_l=(1==0); StatusLED(OFF);
    }

    odo_r_3=odo_r_2;odo_r_2=odo_r_1;odo_r_1=odo_r_0;odo_r_0=data[1];
    if ((!odo_bit_r) && (odo_r_0<odo_r_1) && (odo_r_1<odo_r_2) && (odo_r_2<odo_r_3)) {
    count_r ++; odo_bit_r=(1==1); StatusLED(RED);
    }
    if ((odo_bit_r) && (odo_r_0>odo_r_1) && (odo_r_1>odo_r_2) && (odo_r_2>odo_r_3)) {
    count_r ++; odo_bit_r=(1==0); StatusLED(OFF);
    }
}

int main(void)
{
        Init();
        while(1) count();
        return(0);
}

---

Zitat:

---

Zitat von radbruch

... Ohne Schwellwerte funktioniert es auch gut ... Werten auf auf- oder absteigend prüft ...

---

Genau, ein hübsches, sogar adaptives Verfahren, bei dem unterschiedliche Werte vom Transistor, z.B. bei nicht-abgedeckter Odometrie (baahhhhh - macht ja kaum jemand mehr *ggg*) immer noch sicher erkannt werden. Was mich dabei störte ist der tatsächliche Signalverlauf, siehe meine Messung oben. Im oberen Teil des Diagramms sind im blauen Signalverlauf das zweite und dritte (sogar das erste) Extremum ziemlich weit links, gefolgt von einem streng monoton, aber schwach fallenden Pegel. Dagegen ist das vierte blaue Extremum ziemlich rechtslastig. Hier wird man also bei dieser Flankenerkennung doch etwas danebenliegen. Deshalb wird die Regelung, die sowieso nur so etwa 2 - 3mm lange Wegstücke vorgemessen bekommt, nicht allzu sehr erfreut sein. Na ja, die Schwellwertmethode hat zwar eine bessere, aber immer noch eher eingeschränkte Genauigkeit. Eine optimale Regelung ist am asuro wohl auch schwierig und auch sicher garnicht Entwurfsziel gewesen. Eine Art Sinus hätte ich mir ja auch gewünschterwartet.

hi
danke für die vielen antworten
haben mir schon sehr viel weiter geholfen..

Leider versteh ich davon nicht wirklich alles..
was zeigt das odometrie diagramm eig genau? die motorleistung ?
und was sind schwellenwerte?
srry wenn ich das eig wissen müsste aber ich bin erst dabei das alles zu lernen :D
THX

Zitat:

---

Zitat von shorty93

... srry wenn ich das eig wissen müsste aber ich bin erst dabei das alles zu lernen ...

---

Dann bist Du ja schon mal am richtigen Ende des Weges - da wo es vorangeht *gggg*.

Zitat:

---

Zitat von shorty93

... was zeigt das odometrie diagramm eig genau? die motorleistung ? und was sind schwellenwerte? ...

---

Vorbemerkung: Die Odometrie beschäftigt sich mit der Messung des Weges. Du kennst sicher den Kilometerzähler im Auto - der ist das Anzeigeinstrument für die dortige Odometrie (und der Tacho ein anderes).

Im Diagramm ist die Ordinate (die Achse, die nach o ben zeigt) mit "Odometerwert" beschriftet. Sie zeigt den Wert, den der ADC (Analog-Digital-Converter - ein Messkanal im Controler, der ein analoges Signal misst und den Wert digital zurückgibt) aus der Spannung ableitet, die vom Phototransitor kommt: niedriger Pegel <=> Transistor "sieht schwarz" - hoher Pegel <=> Transistor sieht weiß. Die Spannung schwankt - und der ADC macht daraus Werte zwischen etwa 10 und 190. Dies entspricht etwa 0 V bis 1 V, ist aber hier, genaugenommen, unwichtig. Die Mitte dieser Schwankungen liegt also bei etwa 90. Da könnten wir behaupten, dass hier die Grenze zwischen den weißen und scharzen Feldern der Odometriescheiben an der Reflexlichtschranke vorbeiläuft. Und wir können behaupten, dass wir das als "Schaltwert" nehmen um das "Umschalten" von schwarzem Sektor auf weißen Sektor zu erkennen. Dieser Schaltwert ist eine gewisse Schwelle die unter- bzw. überschritten wird - eben ein Schwellenwert, in unserem Beispiel der Zahlenwert 90, der vom ADC kommt.

Durch Abzählen der Schwellenwerte - siehe Anmerkung - (ich nehme jetzt mal einfach an, dass wir NUR in eine Richtung, z.B. vorwärts, fahren) und Berechnen aus Sektoranzahl, Übersetzung der Zahnräder und Radumfang, kann ich auf die zurückgelegte Länge kommen. Wenn ich dazu die entsprechende Zeit messe, kann ich mir auch die Geschwindigkeit ausrechnen. Anmerkung: die Anzahl, wie oft ich den Schwellenwert von oben oder von unten durchlaufe oder wie oft ich jeweils von unten kommend nach oben oder umgekehrt die Schwelle durchlaufe, ist das, was ich in meinem Beispiel als Zählwert für die Sektoren bzw. Sektorengrenze nehme.

Ist das so verständlich?

Aufpassen! Stell Dir vor, du willst mit dem Auto eine kurvige Straße fahren und hast eine sehr genaue Landkarte. Dann könntest Du die Windschutzscheibe verhängen und das Auto anhand der gemessenen Strecke - siehe Kilometerzähler - über die Strecke lenken. Du weißt, dass das schief gehen wird. Es wird sicherlich Ungenauigkeiten geben, aus denen Deine Position auf der Straße nie genau genug für eine Steuerung sein wird. Das ist ein bisschen das Problem, das wir bei der Odometrie unserer Gefährte haben. Das Ergebnis der Odometrie alleine ist als Navigationsmittel nicht allzu genau, und deshalb nicht wirklich gut geeignet. Aber sie ist geeignet, um anhand der Messwerte die getrennt angetriebenen Räder gleichmässig (für Geradeauslauf) oder unterschiedlich (für Kurvenfahrt) entsprechend irgendwelcher Vorgaben zu regeln.

Die Motorleistung kann ich z.B. durch Messung des Motorstroms und anderer Werte messen - braucht normalerweise kaum jemand.

Hi

Danke für die gute Erklärung!

Jetzt hab ich es verstanden :D

Jetzt geh ich mal daran , das alles in einem programm zu schreiben..(Ich versuchs jedenfalls ;) )

DANKE!!!

Gruß

Hab noch gar nicht richtig angefangen und hab schon wieder ein problem :(

Ich muss ja die wechsel in einer bestimmten zeit zählen, dazu brauch ich einen timer... aber was für ein timer... ich weiss die funktion nicht.

Wo finde ich lib vom asuro und was ist das?(stehn da alle funtionen drin?)

Steht da auch eine timerfunktion drin?

bin grad leicht verwirrt... ._.*

Gruß

Zitat:

---

Zitat von shorty93

Hab ... schon wieder ein problem ... Wo finde ich lib vom asuro und was ist das?(stehn da alle funtionen drin?)
Steht da auch eine timerfunktion drin? ...

---

Hmmm, wenn Du von Köln nach München mit dem Auto fahren würdest (beispielsweise) dann nimmst Du sicher keine Straßenkarte mit, oder? Weil Du wohl die Suchfunktion nicht kennst (die hat einen ähnlichen Zweck): • Suchen • - siehe Befehlszeile gaaaanz oben, dritter Button von links.

Die aktuelle Lib ist hier zu finden. Runterladen und durchlesen. Am Besten tust Du wohl daran, vorher diesen Thread durchzulesen. GAAANZ. Hast Du die BAU- UND BEDIENUNGSANLEITUNG des asuro nicht? Da stehen doch die wichtigsten Funktionen drin ab Punkt 9.2 - allerdings für eine etwas betagte Bibliothek.

Hi

Zitat:

---

vorher diesen Thread durchzulesen. GAAANZ. Hast Du die BAU- UND BEDIENUNGSANLEITUNG des asuro nicht? Da stehen doch die wichtigsten Funktionen drin ab Punkt 9.2 - allerdings für eine etwas betagte Bibliothek.

---

das hab ich schon durchgelesen und die neue lib hab ich auch.. hab nur nie ne html datei gehabt sondern immer nur ein programm( hab wohl das falsche gedownoadet
](*,)

hab jetzt aber mal doch was zusammenprogrammiert (ohne vorher die bibliothek gelesen zu haben)
ist bestimmt grottenfalsch aber erscheint mir irgendwie logisch..
kann mir jemand sagen wo meine denkfehler liegen??

Code:

---

#include "asuro.h"

unsigned int data[2];
unsigned int Zähler_l=0;
unsigned int Zähler_r=0;
unsigned int odo_1l , odo_2l;
unsigned int odo_1r , odo_2r;
int Speed_l  ,Speed_r;
int i;
main(void) {
        init();
        Speed_l=150;
        Speed_r=150;
        MotorDir(FWD,FWD);
        MotorSpeed(Speed_l,Speed_r);
        for(i=0;i<10;i++) {
                OdometrieData(data[0])=odo_1l; /* 1.mal linker Odometrie Wert abfragen*/
                OdometrieData(data[0])=odo_2l; /* 2.mal linker Odometrie Wert abfragen*/
                if((odo_1l<500 && odo_2l>500) || (odo_1l>500 && odo_2l<500)) /*wenn Schwelle da, dann Zähler+1 */
                        Zähler_l++;
        }
        for(i=0;i<10;i++) {
                OdometrieData(data[1])=odo_1r; /* das selber für rechts*/
                OdometrieData(data[1])=odo_2r;
                if((odo_1r<500 && odo_2r>500) || (odo_1r>500 && odo_2r<500))
                        Zähler_r++;
        }
       
        if(zähler_l>zähler_r) { /* wenn links mehr wechsel dann links langsamer*/
                MotorSpeed(Speed_l-5;Speed_r)
                }

        else if(zähler_l<zähler_r) { /*wenn rechts mehr wechsel dann rechts langsamer*/
                MotorSpeed(Speed_l;Speed_r-5)
                }
        else if(zähler_l=zähler_r) {/* wenn rechts gleichviele wechsel wie links dann ischs gud*/
                MotorSpeed(Speed_l;Speed_r)

        while(1);
        return(0);
        }

---

THX

Hallo

[Abschweif]
Die Library für den asuro wurde über längere Zeit weiterentwickelt. Sehr praktisch war dabei die Einführung von PrintInt() und Msleep() und die Umstellung auf den 36kHz-Takt für Sleep(). Die wichtigste Erweiterung (aus meiner Sicht) war die Modifikation des Timers zur IR-Abstandsmessung durch waste ab Version 2.3. Es wurden zu dieser Zeit zwar auch Erweiterungen für die Taster- und Encoderauswertungen eingeführt, diese fanden aber keine breite Anwendung (ich habe darüber bisher kaum etwas gelesen). Ab Version 2.6 entwickelte sich die Lib immer weiter weg von der Hardware des asuro, hauptsächlich die neuen Motorfunktionen entfernen sich immer mehr von der klassischen Odometrie der Ur-Lib. Deshalb verwende ich die Version 2.3 und bin eigentlich glücklich damit :) Alle Versionen gibt's hier zum Download:
http://sourceforge.net/projects/asuro/files/AsuroLib
Der Einstieg zur aktuellen Lib befindet sich hier:
https://www.roboternetz.de/phpBB2/vi...=275614#275614
[/Abschweif]

Zitat:

---

Ich muss ja die wechsel in einer bestimmten zeit zählen

---

Seit ca. V2.2 gibt es die Funktion Gettime(), sie liefert als LongInt die Zeit in Millisekunden seit dem Systemstart. Damit kann man wunderbar nichtblockierend Zeiten messen:

Code:

---

// neue Zeitfunktion
unsigned long Gettime(void)
{
return ((timebase*256)+count36kHz)/36;
}

---

Das Schema:

unsigned long merke_startzeit, gebrauchte_zeit;

merke_startzeit=Gettime();
Mache_irgendwas;
gebrauchte_zeit=merke_startzeit-Gettime();

Für kürzere Zeiten (<1ms) kann man auch direkt auf timebase und count36kHz zugreifen, aber das ist dann schon eher Expert-Level ;)

Gruß

mic