"Hindernisfahrt"

Liste der Anhänge anzeigen (Anzahl: 1)

Hab ich gemacht, zumindest so halbwegs.

Ich glaube es ist logisch: Am ersten weißen Kreis soll sich der Robo(das Quadrat) links drehen, dann ab dann per Infrarot den Boden scannen und sich am schwarzen Kreis(Wert >180) rechts drehen, damit er auf das nächste Hindernis zu fahren kann. Danach dasselbe in grün nur umgekehrt, also erst rechts drehen, dann links. Wie gesagt, ich hab was für das Infrarot geschrieben, nur will es nicht. Wie kann ich das anders machen?

Und noch eine Frage: Wie kann ich es machen, dass sich der Robo genau 90° dreht? Irgendwie macht der das nur manchmal...

So sieht das Programm derzeit aus:

Code:

while(1) { int abstand = robot.analog(1); //int infrarot = robot.analog(3); if( drehrichtung == geradeaus) { robot.motors(25,25); //geradeaus fahren if( abstand < hindernis) { if(schonNachLinksAusgewichen == False) drehrichtung = linksDrehung; else drehrichtung = rechtsDrehung; } } if( drehrichtung == linksDrehung ) { robot.motors(-255, 255); // nach links drehen if( abstand >= freieSicht ) { robot.motors(125,125); schonNachLinksAusgewichen = True; //if( infrarot > 180){ //robot.motors(100,-100); //msleep(500); //} } } if( drehrichtung == rechtsDrehung ) { robot.motors(200, -200); // nach rechts drehen if( abstand >= freieSicht ) { robot.motors(100,100); schonNachLinksAusgewichen = False; //msleep(500); //if( infrarot > 180){ //robot.motors(-100,100); //} // Er ist zwar schon mal nach links ausgewichen, aber inzwischen auch schon rechtsrum, also wieder von vorne } } } }

____

Leider habe ich im Alltag nicht all zu viel Zeit dafür, mich einzulesen und jetzt ist zu spät, Ferienende. Zudem sollte das Ding eigentlich bis Mittwoch fertig sein, werd ich aber wohl nicht schaffen. Nun gut, kann man nix machen...

Liste der Anhänge anzeigen (Anzahl: 2)

Gut, dass du endlich eine Skizze lieferst. Das mit den Hindernissen habe ich erst nicht so verstanden, erst wie du das Infrarot erklärt hast. Dafür habe ich dann das Infrarot nicht kapiert. So sieht man gleich was Sache ist, und es ist ganz klar, dass das vorherige Programm hierfür nicht geeignet ist.

Da du es zumindest versucht hast gibts auch als Belohnung (auch im Anhang nochmal als tmp.c, damit die Einrückungen korrekt erhalten bleiben):

Code:

#include "qfixMiniBoard.h" #include "qfixLCD.h" MiniBoard robot; // Müssen evtl. angepasst werden: #define HindernisAbstand 85 #define Schwarzwert 180 #define Drehgeschwindigkeit 25 #define Drehzeit 3000 // in ms #define Fahrgeschwindigkeit 25 // Feste Konstanten: #define SensorAbstand 1 #define SensorInfrarot 3 #define Links 1 #define Rechts 2 int main() { // Es wird davon ausgegangen, dass der Robo so los fährt wie auf deiner Skizze, also auf der rechten Seite (und somit als erstes nach links muss): unsigned char naechsteAbbiegungNach = Links while(1) { robot.motors(Fahrgeschwindigkeit,Fahrgeschwindigkeit); // Zuerst mal geradeaus fahren while(robot.analog(SensorAbstand)>HindernisAbstand); // Und so lange kein Hindernis in sicht nichts anderes tun robot.motors(0,0); // Jetzt muss ein Hindernis da sein, also erst mal stehen bleiben if(naechsteAbbiegungNach == Links) // Wenn wir jetzt als nächstes nach links müssen... robot.motors(-Drehgeschwindigkeit, Drehgeschwindigkeit); // ..drehen wir mal nach links else if(naechsteAbbiegungNach == Rechts) robot.motors(Drehgeschwindigkeit, -Drehgeschwindigkeit); msleep(Drehzeit); // Da es keinen Anhaltspunkt gibt, wie weit nach links, einfach mal eine bestimmte Zeit lang... robot.motors(Fahrgeschwindigkeit,Fahrgeschwindigkeit); // Und wenn fertig gedreht wieder geradeaus fahren (jetzt bewegt sich der Robo von einer Seite zur anderen) while(robot.analog(SensorInfrarot)<Schwarzwert); // Solange der Infrarotwert nicht "schwarz" bedeuted, nichts weiter machen robot.motors(0,0); // Jetzt muss der schwarze Punkt da sein, also erst mal stehen bleiben // Bsp. für Linksabbiegung: Um die Linksabbiegung abzuschließen muss der Robo sich jetzt wieder nach rechts drehen, damit er wieder gerade steht. if(naechsteAbbiegungNach == Links) robot.motors(Drehgeschwindigkeit, -Drehgeschwindigkeit); else if(naechsteAbbiegungNach == Rechts) // Und um die Rechtsabbiegung abzuschließen nach links drehen robot.motors(-Drehgeschwindigkeit, Drehgeschwindigkeit); msleep(Drehzeit); // Da es keinen Anhaltspunkt gibt, wie weit nach links, einfach mal eine bestimmte Zeit lang... robot.motors(0,0); // fertig gedreht // So, jetzt hat der Roboter entweder von der rechten auf die linke Seite gewechselt (Linksabbiegung) oder anders herum. Da er durch das zweite Drehen in die andere Richtung // jetzt auch wieder gerade steht und auf das nächste Hindernis zufahren kann, geht das ganze wieder von vorne losgehen. Nur müssen wir vorher noch die nächste Abbiegung bestimmen, // die logischerweise genau das Gegenteil von der letzten Abbiegung ist: if(naechsteAbbiegungNach == Links) naechsteAbbiegungNach == Rechts; else if(naechsteAbbiegungNach == Rechts) naechsteAbbiegungNach == Links; } return 0; // Keine Relevanz für den Programmablauf, gehört sich aber für ein sauberes C-Programm }

Auch wenn du deine Hausaufgabe jetz (zumindest zum Großteil hast), musst du noch an deinen Fähigkeiten in Sachen Programmierung arbeiten. Denn wenn ihr darüber auch Prüfungen schreibt, wirst du da mit Ach und Krach durchrasseln.. (Ich würde vorschlagen, du übst weiter mit dem Robo, aber mit einfacheren Aufgabenstellungen)

Viele Grüße
schumi

PS: das #define ist einfach nur Textersetzung, die vom sogenannten Preprozessor durchgeführt wird. Der entfernt auch alle Kommentare usw. und bereitet so den Quellcode zum kompilieren (übersetzen in Maschinensprache) vor. Wie das Programm mit den Ersetzungen aussieht kannst du auch im Anhang sehen (ich habe nur die #include weggelassen, weil die auch der Preprozessor behandelt, die aber nicht auf meinem Computer installiert sind)

[EDIT]
Habe noch Fehler gefunden:
Bei den msleep muss es natürlich nicht Drehgeschwindigkeit sondern Drehzeit heißen! Kann ich aber in den Anhängen anscheinend nicht mehr ändern.. Und das #define True/False ist jetzt auch überflüssig

Für koordiniertes Drehen bräuchtest du entweder Schrittmotore oder eine Winkelrückmeldung von den Rädern, ansonsten wirst du immer Abweichungen drin haben.

Was funktioniert an den schwarzen Kreisen nicht?
Hab ich das richtig verstanden, dass der Roboter an der Unterseite irgendwo (?) einen Infrarotsensor hat, der Schwarz von nicht-Schwarz unterscheiden kann? Das wär dann doch genauso zu lösen, wie die Detektion vom Hindernis, nur, dass er sich nicht zwingend nochmal zurück bewegen muss.

Um den schwarzen Kreis sicher zu treffen, wäre wirklich gut, wenn der Roboter seine Orientierung bestimmen könne. Das Einfachste wäre wohl ein Kompasssensor, ansonsten lässt sich das wohl nur über die Radstellungen gewinnen. Gibt auch noch andere Verfahren, die dann aber meist mit zusätzlichen Raumpunkten, zB. Infrarotmarkern, arbeiten, aber das wird eben immer aufwändiger. Wenn sowas nicht zur Verfügung steht, musst du wohl oder übel hoffen, dass er beim Drehen nicht zu weit von den 90° abweicht. Gegebenenfalls die Wartezeit beim Drehen noch anpassen, sind ja noch ziemlich runde Werte. Vielleicht bringt es ja schon was, beim Drehen mit der Geschwindigkeit ein wenig runter zu gehen.

Soviel hab ich jetzt gar nicht erwartet. ;)
Aber danke! :)

Nun, es gibt dennoch nen kleinen Fehler:
Er dreht sich ständig im Kreis(hatte das Problem schonmal, als ich den Infrarotsensor einsetzte). Könnt mir also vorstellen, dass das wieder am Infrarotsensor(?!) liegt. Er fährt nämlich solange geradeaus, bis er die Stelle gefunden hat, die über 180 ist. Wie kann man das ändern, dass der den Infrarotsensor erst nach dem ersten Drehen benutzt, also erstmal ganz normal auf das Hindernis zu fährt, sich dann dreht und dann die Stelle sucht, die über dem Wert 180 liegt? Vielleicht kann man den Infrarotsensor ja "schlafen" lassen bis zu ner bestimmten Zeit.

Kannst du noch mal ganz genau Schritt für Schritt erklären, was passiert wenn du ihn so wie in deiner Skizze hinsetzt und einschaltest? Du musst immer so präzise wie möglich beschreiben, sonst weis man nicht an welcher Stelle des Codes es hapert..

Also: Wenn ich ihn so hinsetzte wie bei der Skizze macht er nichts anderes als die dunkle Farbe suchen(Wert 180) und sich darüber im Kreis zu drehen... weiß gar nicht warum, schätze aber das das am Infrarot liegt.

Wie gesagt: Hatte das Problem schonmal, konnte es aber damals schon nicht lösen... ihr vllt.?

Kann es sein, dass er direkt danach wieder eine schwarze Fläche sucht, und da er ja immer noch auf ihr drauf steht, findet er sie auch gleich wieder und dreht sich nochmal etc.
Müsstest wohl so umprogrammieren, dass er danach nur wieder nach einem Hindernis sucht und die schwarze Fläche ignoriert.

Er soll die schwarze Fläche ja erst suchen, wenn er schon einmal links gedreht hat... Von daher wäre meine Frage: Wie kann ich es so programmieren, dass er das Infrarot erst dann einschaltet, wenn er sich schonmal gedreht hat? Geht das überhaupt? Das ist mein Grundproblem von anfang an gewesen und ich hab es nie lösen können. Sobald das Infrarot ins Programm geschrieben wurde, drehte er sich nur noch.

Zitat:

Zitat von timmy19

Wie kann ich es so programmieren, dass er das Infrarot erst dann einschaltet, wenn er sich schonmal gedreht hat?

Also ich habe schon mehreren Leuten (im echten Leben ;)) C beigebracht. Und diese Frage bestätigt einen Verdacht den ich schon vorher hatte, nämlich dass du noch nicht ganz verstanden hast wie ein Programm abläuft. Komischerweise scheint das aber vielen Leuten zuerst nicht in den Kopf zu gehen, nur die wenigsten checken es sofort..

Desshalb erkläre ich noch bevor irgend ein Code gezeigt wird folgendes:
Stell dir vor du liest eine Bedienungsanleitung. Wie machst du das? Na klar, Schritt für Schritt, und nebenbei machst du immer das was in diesem Schritt zu tun ist. Das was du vorher gemacht hast und was du später machen musst spielt in diesem Moment keine Rolle.

Was du machst wenn du programmierst ist eine Bedienungsanleitung für den Mikrocontroller schreiben. Und der ließt die auch nicht irgendwie durcheinander oder macht alles gleichzeitig, sonder auch streng Schritt für Schritt. Und zwar Zeile für Zeile von oben nach unten. Beispiel:

Code:

int main (void) { int zahl = 5; if( zahl>100) { Alarm_Einschalten(); } zahl = 5000; return 0; // Programmende }

Ganz einfach: Eine Variable "zahl" wird mit dem Inhalt 5 erstellt. Wenn die zahl größer 100 ist wird Alarm ausgelöst, und dann wird 5000 in zahl geschrieben.

Was ich denke dass du vermutest dass passiert: sobald das "zahl = 5000;" ausgeführt wird, wird Alarm ausgelöst. :!: DAS IST NICHT SO :!:

Denk dir du bist ein Mikrocontroller und liest das Programm, was du tust ist:

int zahl = 5; -> Arbeitsspeicher für die Variable "zahl" reservieren und 5 reinspeichern
if( zahl>100) -> Ist denn zahl > 100? NEIN, denn zahl ist 5. Also kann der nächste Befehl (also die { blabla } ) übersprungen werden
zahl = 5000; -> Gut, dann speichern wir 5000 in den Arbeitsspeicher der für "zahl" reserviert ist
return 0; -> Programmende. Habe fertig.

Du wirst jetzt warscheinlich sagen: "Ja, aber bei Schritt 3 speichere ich ja 5000 in Zahl, da muss ich doch den Alarm einschalten!". NEIN. Der Mikrocontroller merkt sich nicht was vorher war, er macht folgt strikt Zeile für Zeile den Befehlen. (wie ich schrieb: "Das was du vorher gemacht hast und was du später machen musst spielt in diesem Moment keine Rolle.").

Zurück zu deiner Frage:

Zitat:

Zitat von timmy19

Wie kann ich es so programmieren, dass er das Infrarot erst dann einschaltet, wenn er sich schonmal gedreht hat?

Und dann den Code:

Code:

#include "qfixMiniBoard.h" #include "qfixLCD.h" MiniBoard robot; // Müssen evtl. angepasst werden: #define HindernisAbstand 85 #define Schwarzwert 180 #define Drehgeschwindigkeit 25 #define Drehzeit 3000 // in ms #define Fahrgeschwindigkeit 25 // Feste Konstanten: #define SensorAbstand 1 #define SensorInfrarot 3 #define Links 1 #define Rechts 2 int main() { // Es wird davon ausgegangen, dass der Robo so los fährt wie auf deiner Skizze, also auf der rechten Seite (und somit als erstes nach links muss): unsigned char naechsteAbbiegungNach = Links while(1) { robot.motors(Fahrgeschwindigkeit,Fahrgeschwindigkeit); // Zuerst mal geradeaus fahren while(robot.analog(SensorAbstand)>HindernisAbstand); // Und so lange kein Hindernis in sicht nichts anderes tun robot.motors(0,0); // Jetzt muss ein Hindernis da sein, also erst mal stehen bleiben if(naechsteAbbiegungNach == Links) // Wenn wir jetzt als nächstes nach links müssen... robot.motors(-Drehgeschwindigkeit, Drehgeschwindigkeit); // ..drehen wir mal nach links else if(naechsteAbbiegungNach == Rechts) robot.motors(Drehgeschwindigkeit, -Drehgeschwindigkeit); msleep(Drehzeit); // Da es keinen Anhaltspunkt gibt, wie weit nach links, einfach mal eine bestimmte Zeit lang... robot.motors(Fahrgeschwindigkeit,Fahrgeschwindigkeit); // Und wenn fertig gedreht wieder geradeaus fahren (jetzt bewegt sich der Robo von einer Seite zur anderen) while(robot.analog(SensorInfrarot)<Schwarzwert); // Solange der Infrarotwert nicht "schwarz" bedeuted, nichts weiter machen robot.motors(0,0); // Jetzt muss der schwarze Punkt da sein, also erst mal stehen bleiben // Bsp. für Linksabbiegung: Um die Linksabbiegung abzuschließen muss der Robo sich jetzt wieder nach rechts drehen, damit er wieder gerade steht. if(naechsteAbbiegungNach == Links) robot.motors(Drehgeschwindigkeit, -Drehgeschwindigkeit); else if(naechsteAbbiegungNach == Rechts) // Und um die Rechtsabbiegung abzuschließen nach links drehen robot.motors(-Drehgeschwindigkeit, Drehgeschwindigkeit); msleep(Drehzeit); // Da es keinen Anhaltspunkt gibt, wie weit nach links, einfach mal eine bestimmte Zeit lang... robot.motors(0,0); // fertig gedreht // So, jetzt hat der Roboter entweder von der rechten auf die linke Seite gewechselt (Linksabbiegung) oder anders herum. Da er durch das zweite Drehen in die andere Richtung // jetzt auch wieder gerade steht und auf das nächste Hindernis zufahren kann, geht das ganze wieder von vorne losgehen. Nur müssen wir vorher noch die nächste Abbiegung bestimmen, // die logischerweise genau das Gegenteil von der letzten Abbiegung ist: if(naechsteAbbiegungNach == Links) naechsteAbbiegungNach == Rechts; else if(naechsteAbbiegungNach == Rechts) naechsteAbbiegungNach == Links; } return 0; // Keine Relevanz für den Programmablauf, gehört sich aber für ein sauberes C-Programm }

Wenn du jetzt nach dem auslesen des Infrarotsensors suchst, wirst du feststellen, dass er nur in der rot markierten Zeile eine vorkommt. In allen anderen Zeilen ist der Infrarotsensore absolut piepschnurzegal! (<- Nicht möchte es nur deutlich genug sagen ;)) Jetzt merkst du hoffentlich, dass deine Frage keinen Sinn ergibt..

Zitat:

Zitat von timmy19

Also: Wenn ich ihn so hinsetzte wie bei der Skizze macht er nichts anderes als die dunkle Farbe suchen(Wert 180) und sich darüber im Kreis zu drehen...

Analyse (Versuche es im Quelltext nachzuvollziehen, das grüne entspricht deiner Frage):

Über der roten Zeile fährt er geradeaus

In der roten Zeile macht er nichts, solange er den schwarzen Punkt noch nicht gefunden hat

Dann bleibt er stehen (er hat den Punkt gefunden)

Dann dreht er je nach Drehrichtung (mit den if's)
wartet für 3 Sekunden
Er bleibt stehen
Dann wechselt er die "nächsteAbbiegungNach" und springt an den Anfang de while-Schleife
Dann fährt er geradeaus, ändert nichts bis er das Hindernis gefunden hat, bleibt dann stehen
Er dreht sich wieder für 3 Sekunden
Fährt dann wieder geradeaus, bzw erster Punkt dieser Aufzählung

Man könnte jetzt also zur Annahme kommen dass deine Entfernungsmessung nicht funktioniert und immer ein Hindernis sieht (rote Zeile).
(Und im übrigen wird man das stehenbleiben auch nicht sehen könne, weil er sofort danach auf eine andere Bewegung umschaltet)

ABER: Dann müsste sich der Robo 3+3 Sekunden in die eine und dann 3+3 Sekunden in die andere Richtung drehen. Du hast aber nicht präzise genug geantwortet, so dass man nicht weis, was der Robo genau tut. Eine richtige Antwort wäre gewesen:

Zitat:

Wenn ich den Robo wie in der Skizze auf seine Startposition setze, ihn dann einschalte fährt er nur geradeaus. Außer er findet einen schwarzen Punkt, dann dreht er sich auf ihm nach links und hört auch nach ca. 20 Sekunden nicht damit auf

Ich habe das was du nicht gesagt hast rot markiert:

Einschalten: Nur so kann man davon ausgehen, dass der Roboter sein Programm auch von vorne an abarbeitet, und nicht "irgendwo mitten in der Bedienungsanleitung drin steckt" wenn du ihn auf seine Startposition setzt
links: Wenn er sich nur in eine Richtung dreht, stimmt jedenfalls noch mehr nicht als eine nichtfunktionierende Abstandsmessung
20 Sekunden: Wenn nur die Abstandsmessung nicht funktioniert, wechselt er alle 3+3 = 6 Sekunden die Drehrichtung. Man weis jetzt nicht; vielleicht hast du den Robo nur für 5 Sekunden drehen lassen?

Ich hoffe deinem Grundverständnis für Programmcode ein wenig auf die Sprünge geholfen zu haben. Nur leider ist es sehr schwer das jemandem übers Internet beizubringen.. Und wenn du ganz ganz genaue Angaben machst was ganz genau der Robo tut und ihn auch sicher erst einschaltest wenn er auf seiner Startposition sitzt, dann bekommen wir das Ding vielleicht noch zum laufen..

Es scheint tatsächlich noch bisschen mehr falsch zu sein. Der Robo zeigt nämlich unterschiedliche Reaktionen beim selben Startpunkt:

ERSTENS: Beim ersten Starten drehte er sich nur nach links( bis ich nach etwa 20 sec abgeschalten habe)
ZWEITENS: Er fuhr einmal kurz vor, dann wieder zurück, dann drehte er sich wieder paar mal nach links und fuhr dann ständig nur noch vor und zurück (wieder so nen Ruckeln)

Hab das dann paar mal ausprobiert, mal kam das eine mal das andere.

Das kann meiner Meinung nach trotzdem an nichts anderem liegen, als am Infrarot...

Edit: Nein er fährt definitiv nur nach links, jetzt grade schon mindestens 40 sec.