Seltsam. Hab es jetzt mal anders gemacht, nämlich ihn manuell geradeaus fahren lassen, nicht mit dem Befehl "drehrichtung = geradeaus", dann klappt es komischerweise. Die Technik ist manchmal verwirrend.
Ja, der Roboter ist es. Wir sollen das Hindernisumfahren aber mit einem Infrarotsensor regeln, denn wir haben ein Boden, der eingefärbt ist(dunkel zu hell zu dunkel). Zudem ist die Seitenbegrenzung nicht so hoch, dass man sie mit dem Ultraschall sehen könnte.
Nun meine weitere Frage: Glaubt ihr, der folgende Code könnte im Prinzip funktionieren? Mein Problem war bisher, dass sich der Robo nur gedreht hat, da er sich beim dunklen Boden drehen sollte. Aber eigentlich wollte ich das erst, nachdem er das erste Hindernis entdeckt, die Drehung gemacht und richtung "freier" Seite gefahren ist. Wie kann ich das schreiben, sodass er sich nicht "verwirren" lässt?
Code:#include "qfixMiniBoard.h" #include "qfixLCD.h" const int SENSOR3 = 3; int SENSOR1 = 1; int SENSOR2 = 2; int SENSOR = 0; MiniBoard robot; LCD lcd; #define geradeaus 0 #define linksDrehung 1 #define rechtsDrehung 2 #define hindernis 75 #define freieSicht 120 // Wenn der Robo etwas nach links fährt, aber dann gegen das Hindernis, ist dieser Wert zu klein #define True 1 #define False 0 int main() { int abstand=0; //int infrarot= 0; unsigned char drehrichtung = geradeaus; // unsigned char = 8bit integer von 0 bis 255, braucht weniger Platz im RAM unsigned char schonNachLinksAusgewichen = False; while(1) { abstand = robot.analog(1); //infrarot = robot.analog(3); if( drehrichtung == geradeaus) { robot.motors(-250,-250); //geradeaus fahren if( abstand < hindernis) { if(schonNachLinksAusgewichen == False) drehrichtung = linksDrehung; else drehrichtung = rechtsDrehung; } } if( drehrichtung == linksDrehung ) { robot.motors(-200, 200); // nach links drehen if( abstand >= freieSicht ) { robot.motors(250,250) schonNachLinksAusgewichen = True; //msleep(500); //if( infrarot > 185){ //robot.motors(100,-100); //msleep(500); } } if( drehrichtung == rechtsDrehung ) { robot.motors(200, -200); // nach rechts drehen if( abstand >= freieSicht ) { robot.motors(250,250) schonNachLinksAusgewichen = False; //msleep(500); //if( infrarot > 185){ //robot.motors(-100,100); // Er ist zwar schon mal nach links ausgewichen, aber inzwischen auch schon rechtsrum, also wieder von vorne } } } }
Ich würde es in etwa so machen (nur die while Schleife als Pseudocode):
Du musst vermutlich noch ein Delay (msleep) einfügen.Code:while(1) {Lese Ultraschall if (Ultraschall < Limit) {Hinderniss = true}if (Hinderniss == false) {Motoren (200,200)} else {if (drehung == links) {Motoren (-200, 200) drehung = rechts} else {Motoren (200, -200) drehung = links} Lese Linie if (Linie < Limit) {Hinderniss = false}}}
MfG Hannes
Geändert von 021aet04 (02.01.2014 um 19:07 Uhr)
Wie geht das "Lese" ?
Mir fehlt derzeit eigentlich nur noch der Infrarotsensor, also das von dir beschriebene "Lese Linie".... nur wie geht das? Der Rest klappt soweit.
Code:#include "qfixMiniBoard.h" #include "qfixLCD.h" const int SENSOR3 = 3; int SENSOR1 = 1; int SENSOR2 = 2; int SENSOR = 0; MiniBoard robot; LCD lcd; #define geradeaus 0 #define linksDrehung 1 #define rechtsDrehung 2 #define hindernis 85 #define freieSicht 150 // Wenn der Robo etwas nach links fährt, aber dann gegen das Hindernis, ist dieser Wert zu klein #define True 1 #define False 0 int main() { int abstand=0; //int infrarot= 0; unsigned char drehrichtung = geradeaus; // unsigned char = 8bit integer von 0 bis 255, braucht weniger Platz im RAM unsigned char schonNachLinksAusgewichen = False; while(1) { abstand = robot.analog(1); //infrarot = robot.analog(3); if( drehrichtung == geradeaus) { robot.motors(-250,-250); //geradeaus fahren if( abstand < hindernis) { if(schonNachLinksAusgewichen == False) drehrichtung = linksDrehung; else drehrichtung = rechtsDrehung; } } if( drehrichtung == linksDrehung ) { robot.motors(-200, 200); // nach links drehen if( abstand >= freieSicht ) { robot.motors(250,250); msleep(500); schonNachLinksAusgewichen = True; //msleep(500); //if( infrarot > 185){ //robot.motors(100,-100); //msleep(500); } } if( drehrichtung == rechtsDrehung ) { robot.motors(200, -200); // nach rechts drehen if( abstand >= freieSicht ) { robot.motors(250,250); msleep(500); schonNachLinksAusgewichen = False; //msleep(500); //if( infrarot > 185){ //robot.motors(-100,100); // Er ist zwar schon mal nach links ausgewichen, aber inzwischen auch schon rechtsrum, also wieder von vorne } } } }
"Lese Linie" wäre bei dir "infrarot = robot.analog(3);", "Lese Ultraschall" wäre "abstand = robot.analog (1);"
MfG Hannes
Danke dir.
Das Delay(msleep) muss NACH dem Infrarot oder davor? Hab es derzeit davor. Also so:
Edit: Der Robo möchte einfach nicht auf das infrarot reagieren. Alles andere macht er jetzt, nur das Infrarot nicht. Was mach ich um Himmels willen falsch? Ich verzweifle...Code:#include "qfixMiniBoard.h" #include "qfixLCD.h" const int SENSOR3 = 3; int SENSOR1 = 1; int SENSOR2 = 2; int SENSOR = 0; MiniBoard robot; LCD lcd; #define geradeaus 0 #define linksDrehung 1 #define rechtsDrehung 2 #define hindernis 85 #define freieSicht 150 // Wenn der Robo etwas nach links fährt, aber dann gegen das Hindernis, ist dieser Wert zu klein #define True 1 #define False 0 int main() { int abstand=0; unsigned char drehrichtung = geradeaus; // unsigned char = 8bit integer von 0 bis 255, braucht weniger Platz im RAM unsigned char schonNachLinksAusgewichen = False; while(1) { abstand = robot.analog(1); if( drehrichtung == geradeaus) { robot.motors(-250,-250); //geradeaus fahren if( abstand < hindernis) { if(schonNachLinksAusgewichen == False) drehrichtung = linksDrehung; else drehrichtung = rechtsDrehung; } } if( drehrichtung == linksDrehung ) { robot.motors(-200, 200); // nach links drehen if( abstand >= freieSicht ) { robot.motors(250,250); msleep(500); schonNachLinksAusgewichen = True; infrarot = robot.analog(3); //msleep(500); if( infrarot > 185){ robot.motors(100,-100); int infrarot = 0; } } if( drehrichtung == rechtsDrehung ) { robot.motors(200, -200); // nach rechts drehen if( abstand >= freieSicht ) { robot.motors(250,250); msleep(500); schonNachLinksAusgewichen = False; infrarot = robot.analog(3); //msleep(500); if( infrarot > 185){ robot.motors(-100,100); int infrarot = 0; // Er ist zwar schon mal nach links ausgewichen, aber inzwischen auch schon rechtsrum, also wieder von vorne } } } }
Und noch was: Komischerweise fährt der Robo immer auf das Hindernis zu, dreht sich kurz zuvor und bleibt dann mit dem rechten Rad etwas hängen, dreht sich aber weiter. Das macht er, egal wie ich "Hindernis" und "freie Sicht" verändere. Woran liegt das und wie kann ich das ändern(also, dass er sich schon früher dreht)?
Geändert von timmy19 (03.01.2014 um 12:58 Uhr)
Was macht er nicht? Beschreibe genau was er macht (z.B. fährt geradeaus, trifft auf Hindernis, dreht sich nach links und fährt nicht mehr geradeaus sondern dreht weiter).
Grundsätzlich entspricht das Programm nicht dem was ich oben als Pseudocode geschrieben habe (ist aber egal). An deiner Stelle würde ich nicht nur mit einfachen "If" Anweisungen sondern mit "If-else" Anweisungen arbeiten. Der Grund ist relativ einfach. Als Beispiel:
Somit wird zuerst die Schleife mit Linksdrehung ausgeführt, dort wird der Wert geändert. Anschließend wird in der nächsten Schleife auf Rechtsdrehung geprüft, diese ist auch war und wird deswegen ausgeführt. Wenn du stattdessen ein else einsetzt ist das nur eine Schleife und der else Zweig wird nicht ausgeführt (außer wenn das Programm wieder auf diese if Schleife kommt).Code:if (drehrichtung == linksdrehung) {.........drehrichtung = rechtsdrehung;} if (drehrichtung == rechtsdrehung) {.........drehrichtung = linksdrehung;}
Wenn du auf mehrere Werte prüfen willst kannst du z.B so schreibenWo die Delays hinkommen ist grundsätzlich egal (optimal wäre wenn du garkeines brauchst da der Controller in dieser Zeit nichts macht). Du musst immer bedenken was passiert wenn du das Delay an einen Platz setzt.Code:if (variable == 1) { } else if (variable == 2) { } else { }
Als Beispiel du liest einen Sensor ein und steuerst daraufhin einen Motor an.
So wie das Programm jetzt ist ist es sinnlos, da du nach dem Einlesen des Sensors zwar den Motor so ansteuerst das er ausweicht, jedoch im "selben" Moment den Motor wieder geradeausfahren lässt. Das Motor (200,-200) wirst du nicht merken da das viel zu schnell geht, gleichzeitig ist das Delay sinnlos da du nach dem auslesen wartest bis du den Motor ansteuerst.Code:Lese Infrarot Delay if (Infrarot <100) {Motor (200,-200)} Motor (200,200)
Wenn du hingegen das Delay nach Motor(200,-200) hinschreibst wird der für die Zeit des Delays in die Gegenrichtung drehen. Dann ist es sinnvoller. In etwa so:
Code:Lese Infrarot if (Infrarot < 100) {Motor (200, -200) Delay} Motor (200, 200)
Wenn du die Entfernung auf die er reagiert ändern willst musst du den Wert des Limits ändern. Du musst wissen üb der Wert proportional oder nicht proportional zur Entfernung ist. Je nachdem muss der Wert größer oder kleiner werden. Wenn du es nicht weißt wäre es am einfachsten wenn du ein Messgerät nimmst und misst.
Das mit dem Hängenbleiben könntest du lösen indem du die Werte für rechten Motor und linken Motor änderst. z.B. Motor(0, -200) => ein Motor steht und der andere Dreht mit Geschw. 200.
So wie ich dein Programm jetzt verstanden habe (habe mir jetzt den Zeig für Linksdrehung angeschaut):
> Du fährst vorwärts bis zum Hindernis
> drehst nach links bis kein Hindernis erkannt wurde
> anschließend fährst du zurück bis das Infrarot über einem Limit ist
> jetzt fährst du langsamer als vorher nach rechts (motor (-100, 100))
Geradeaus fährst du garnichmehr da du die Variable Drehrichtung nicht mehr auf geradeaus stellst.
MfG Hannes
Also bisher macht der Robo folgendes:
Er fährt geradeaus, bis er das Hindernis erkennt. Leider erkennt er dieses erst minimal davor, sodass er bei der Linksdrehung mit dem Rechten Rad hängenbleibt.
Das Problem ist: Wenn ich den Wert des "Hinderniserkennens" erhöhe, erkennt er plötzlich NICHTS mehr und fährt gegen das Hindernis. Wo liegt dabei das Problem und wie bekomme ich es hin, dass er das Hindernis früher erkennt? Ein Messgerät habe ich leider nicht.
Desweiteren hab ich nun was ausprobiert: Nachdem er linksgedreht hat, hab ich mal ein weiteres Hindernis hingestellt. Eigentlich sollte er nun ja rechtsdrehen, aber er dreht erneut links. Wo liegt nun hier das Problem?
Und wie soll ich das mit dem If-Else machen? versteh ich leider nicht ganz, vllt. kannst du mir das noch etwas genauer erklären.
______
Ja genau, er sollte geradeaus fahren, dann, wenn er das Hindernis erkennt nach links drehen. Nun soll er soweit nach links fahren, bis der Boden wieder eine bestimmte Farbe annimmt(etwa Wert 185, gemessen in der Schule), sich nun wieder rechts drehen und geradeaus auf das nächste Hindernis fahren. Dort nun das ganze in umgekehrter Richtung wieder durchführen. Verstanden? Leider scheitere ich schon an der ersten Rechtsdrehung mit Infrarot.
Wäre euch sau dankbar, wenn ich mir da noch den ein oder anderen Tipp geben könntet, wie ich das weiter lösen könnte.
Code:#include "qfixMiniBoard.h" #include "qfixLCD.h" const int SENSOR3 = 3; int SENSOR1 = 1; int SENSOR2 = 2; int SENSOR = 0; MiniBoard robot; LCD lcd; #define geradeaus 0 #define linksDrehung 1 #define rechtsDrehung 2 #define hindernis 85 #define freieSicht 150 // Wenn der Robo etwas nach links fährt, aber dann gegen das Hindernis, ist dieser Wert zu klein #define True 1 #define False 0 int main() { unsigned char drehrichtung = geradeaus; // unsigned char = 8bit integer von 0 bis 255, braucht weniger Platz im RAM unsigned char schonNachLinksAusgewichen = False; while(1) { int abstand = robot.analog(1); int infrarot = robot.analog(3); if( drehrichtung == geradeaus) { robot.motors(100,100); //geradeaus fahren if( abstand < 85) { if(schonNachLinksAusgewichen == False) drehrichtung = linksDrehung; else drehrichtung = rechtsDrehung; } } if( drehrichtung == linksDrehung ) { robot.motors(-100, 100); // nach links drehen msleep(300); if( abstand >= 120) { robot.motors(100,100); msleep(280); schonNachLinksAusgewichen = True; msleep(1500); if( infrarot > 185){ robot.motors(100,-100); } } if( drehrichtung == rechtsDrehung ) { robot.motors(200, -200); // nach rechts drehen if( abstand >= 120 ) { robot.motors(100,100); msleep(280); schonNachLinksAusgewichen = False; int infrarot = robot.analog(3); msleep(1500); if( infrarot > 185){ robot.motors(-100,100); // Er ist zwar schon mal nach links ausgewichen, aber inzwischen auch schon rechtsrum, also wieder von vorne } } } } } }
Du prüfst in deinem Programm auf geradeaus, linksdrehung und rechtsdrehung. Ich würde aber zuerst einmal nur prüfen ob du geradeausfährst oder ausweichen musst.
Also nur die while Schleife. Die Variable musst du vorher initialisieren. Vor der While Schleife "int abstand",... Dann brauchst du die Variable nur verwenden.
Das Programm sollte so funktionieren. Was hast du als Hindernis genommen. Je nach Objekt könnte es Probleme geben. Glatte Objekte (z.B. Bücher) 90° zum Sensor ist optimal, sollte auch nicht zu klein sein. Flaschen o.Ä. ist nicht optimal, da eigentlich nur die Fläche den Schall Richtung Sensor wirft der 90° zum Sensor steht.Code:while(1) {abstand = robot.analog (1); if (abstand < 85) {Hindernis = true;} if (Hindernis == false) {robot.motors (-250, -250);} else {if (Drehrichtung == links) {robot.motors (200, -200); Drehrichtung = rechts;} else {robot.motors (-200, 200); Drehrichtung = links;} infrarot = robot.analog (3); if ( infrarot < 85) {Hindernis = false;}} msleep(500);}
Hast du Leds die du ansteuern kannst? So kannst du die Messwerte testen die vom Sensor kommen, du könntest auch die Motoren nehmen. Sensorwert direkt an den Motor geben.
Am Besten wäre es dann wenn du den Roboter anheben kannst und ein Objekt vom oder zum Sensor bewegst. Dann sollte sich die Motordrehzahl ändern.Code:i = robot.analog (1); robot.motors (i, 0); msleep(300);
MfG Hannes
Klingt im Prinzip völlig verständlich. Nur hab ich nun dasselbe Problem wie am Anfang: Der Robo macht nichts außer 2 cm vor und dann wieder zurück zufahren(also so nen ruckeln). Nach einer kleinen Änderung macht er immerhin die linksdrehung. Also muss das am "Geradeausfahren" liegen. Aber wo ist da der fehler?
Letztes Mal lag es irgendwie an der Else-Steuerung. Wie kann es ich schaffen, dass ich die Else-Steuerung nutzen kann, ohne das dieser "Fehler" auftritt? Hast du da ne Ahnung?
Edit: Warum erkennt der Robo meine Hand als Hindernis und dreht sich dann perfekt, aber jede andere Sache erkennt er nicht oder zu spät? Ich verzweifle... :/
Geändert von timmy19 (05.01.2014 um 12:50 Uhr)
Du könntest versuchen das msleep zu verlängern.
Ich vermute das das so abläuft:
Das Hindernis wird erkannt, der Roboter dreht, fährt nach vor und erkennt das Objekt erneut, weicht wieder aus, fährt wieder nach vor erkennt das Hindernis wieder,....
Somit würde sich das ruckeln erklären.
Wie ich oben schon gefragt habe was nutzt du als Hindernis?
Was du auch noch machen kannst das wäre das "abstand = robot.analog(1);" und die "if (abstand < 85)" Schleife in den "if (Hindernis == false)" Zweig geben.
Du kannst auch versuchen ein komplettes Ausweichmanöver ins Programm zu integrieren. Z.B. Wenn Hindernis erkannt Abstandsmessung abschalten, fahre zurück, drehe seitlich, fahre vor, wenn neben dem Hindernis Abstandsmessung einschalten.
MfG Hannes
Berechtigungen
Zitieren
Lesezeichen