"Hindernisfahrt"

[timmy19]

Keine Angst, ich lese mir die Beiträge schon genau durch. Ich habe die Anweisungen mit den Variablen auch so umgesetzt gehabt, nur zwischen drin klappte das dann nicht mehr... ist jetzt auch egal.

Und doch, Schumis Programm klappt bis auf die Tatsache, dass der Robo erst minimal vor dem Hindernis dreht und die Infrarotsteuerung(die klappt immer noch nicht...) Es klappt wahrscheinlich aber nur, weil da ohne Else-Steuerung gearbeitet wird. Um weiter zu kommen, wäre es vllt. sinnvoll, die Else-Steuerung(so leid es mir tut, sowohl um deine Arbeit, als auch darum da ich es gerne so gemacht hätte, da es schicker aussieht), weg zulassen und an dem anderen Programm weiterzuarbeiten.

#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;  
	int abstand   = robot.analog(1);
	int infrarot  = robot.analog(3);
  
    while(1)
    {
        
		
        if( drehrichtung == geradeaus)
        {
            robot.motors(100,100); //geradeaus fahren
            if( abstand < 150)
            {
                if(schonNachLinksAusgewichen == False)
                    drehrichtung = linksDrehung;
                else
                    drehrichtung = rechtsDrehung;
            }
        }
        if( drehrichtung == linksDrehung )
        {
		    robot.motors(-100,-100);
			msleep(100);
            robot.motors(-150, 150); // nach links drehen
			msleep(300);
            if( abstand >= 150 )
            {
                robot.motors(100,100);
				msleep(500);
                schonNachLinksAusgewichen = True;
				
				
				if( infrarot < 150){
		        robot.motors(100,-100);
				msleep(500);
				
            }
        }
        if( drehrichtung == rechtsDrehung )
        {
            robot.motors(150, -150); // nach rechts drehen
			msleep(300);
            if( abstand >= 150 )
            { 
			    robot.motors(-100, -100);
				msleep(100);
                robot.motors(100,100);
				msleep(500);
                schonNachLinksAusgewichen = False; 
				
				int infrarot  = robot.analog(3);
				if( infrarot < 150){
				robot.motors(-100,100);
				msleep(500);
				
	
			// Er ist zwar schon mal nach links ausgewichen, aber inzwischen auch schon rechtsrum, also wieder von vorne
			
			
			
			
			
			}  
		}		  
	}	

}	
}
}

Wie gesagt: Das hier funktioniert soweit(arbeite sozusagen an zwei Versionen gleichzeitig), dass der Robo fährt, sich dann minimal vor dem Hindernis dreht. Die Rücksteuerung per Infrarot wäre jetzt das nächste, was ich gerne versuchen würde, vllt. klappt es dann ja. Würde mich extrem freuen.

Also, weißt du, was hier der Fehler an der Infrarotsteuerung sein könnte? Ich sehe keinen und weiß deshalb nicht was ändern.

_____

Bei dem mit der Else-Schleife bleibt das Problem, dass er sich nur dreht. Hab schon ein paar Dinge verändert, aber immer dasselbe Problem, er scheint den "If-Teil" einfach nicht auszuführen.

[-schumi-]

Irgendwie ist das alles etwas durcheinander.. Es ehrt mich zwar, dass das Grundgerüst deines Codes immer noch das von mir gepostete ist, aber mit dem Infrarot dazwischen wird das jetzt nicht mehr so funktionieren. Denn mein Code war so gedacht:

• Kein Hindernis -> Roboter fährt vorwärts
• kurz vor Hindernis -> so lange nach links drehen bis absolut kein Hindernis mehr
• vorwärts bis zum nächsten Hindernis -> so lange nach links drehen bis absolut kein Hindernis mehr
• vorwärts bzw. wieder von vorne

Aber jetzt soll er irgendwie über infrarot merken, dass er sich nicht mehr weiter nach links drehen soll oder so, so ganz habe ich das auch noch nicht verstanden. Und man kann jetzt nicht das Programm so ändern wie du es willst, indem man einfach Zeilen dazu schreibt, sondern man muss das Programm durch und durch verstehen (!) und dann abändern (Wie Hannes auch schon schrieb). Ich habe mich da bei meinem Code anscheinend etwas zu viel auf aussagekräftige Variablennamen verlassen und zu wenig erläutert..

An deiner Stelle würde ich jetzt folgendermaßen vorgehen:

1. Eine Skizze anfertigen (und hier posten. Entweder von Hand zeichnen und ein scharfes Foto machen, oder ein Foto von deinem Aufbau machen und genau erklären, oder auch am PC zeichnen wenn du passende Software hast)
2. Ganz genau Punkt für Punkt erläutern was der Robo machen soll. Worauf soll er reagieren, was spielt alles eine Rolle etc. (Der hat auch kein "Verständnis" und erkennt selbst was du tun möchtest, du musst alles haarklein definieren)
3. Herausfinden, wie die Sensoren des Roboters funktionieren, insbesondere bei welchen Werten du reagieren möchtest. Du schreibst z.B. dass er zu spät vor dem Hindernis stehen bleibt. Dann musst du zuerst einmal herausfinden bei welchem Abstandswert er reagieren soll. Um das zu tun schreibst du ein ganz einfaches Programm, das z.B. dass der Robo bis zu einem bestimmten Wert vorwärts fährt und dann stehen bleibt. Dann änderst du diesen Wert bis er dir passt, notierst ihn und postest ihn dann auch hier (das betrifft den Abstand und den Infrarot Wert)

Wenn du das hast, können wir dir helfen das Programm zu schreiben. Denn ich denke, dass du mit der bisherigen Vorgehensweise nicht mehr weiter kommst..

Viele Grüße
schumi

PS: Wie steht es eigentlich um deine Kenntnisse in Sachen C? Kannst du mit "#define" überhaupt was anfangen? Was ist der unterschied zu "const"? Und warum const' du deine SENSOR* Variablen?

[021aet04]

Schumi kann ich nur zustimmen.

Du könntest dich ins Thema C einlesen, wäre vielleicht nicht schlecht. Z.B. http://www.c-howto.de/ => dort findest du alles was du brauchst (Schleifen, Verzweigungen, Variablen,...)

MfG Hannes

[timmy19]

Also das mit dem Foto wird heute schwer(kann ich ev. morgen machen), aber ich kann es euch erklären:

- Unser Aufbau ist ein Untergrund, der sich farblich ändert - von dunkel zu hell(in der Mitte) zu dunkel.
- Darauf stehen mehrere Hindernisse, immer im Wechsel rechts links(etwa 4-6 Stück).
- Der Robo fährt also auf das erste Hindernis zu, dreht früh genug links, dann bis zu einer bestimmten Farbe wieder geradeaus(etwa 180), dann soll er sich wieder so drehen, dass er "gerade" steht.
- Dann fährt er auf das nächste Hindernis zu(diesmal auf der linken Seite), soll sich rechts drehen, wieder bis zu der selben Farbe auf der anderen Seite fahren, wieder links drehen. Und das eben zwei bis drei Mal.
- Wie gesagt, leider haben wir kein LED und daher kann ich mich nur auf die Werte beziehen, die wir in der Schule gemessen haben und bei welchen es bei den Hindernissen bestens geklappt hat. Warum es bei meinen Hindernissen nicht klappt versteh ich selber nicht...
- An den Seiten der Strecke links und rechts sind jeweils keine für den Roboter erkennbaren Hindernisse, deshalb muss das mit Infrarot gemacht werden und ein Sensor eingebaut werden.

Hilft das schon weiter?

PS: Meine Kenntnisse in C sind nicht besonders(wie ihr sicher bemerkt habt. ), aber was define ist versteh ich grad so noch. Wenn du das meinst, warum ich das mit if(abstand < hindernis) in if(abstand < 85) umgebaut habe, dass liegt daran, dass der Robo irgendwie teilweise darauf nicht reagiert hat, es mit if(abstand < 85) aber besser geklappt hat.

[Geistesblitz]

Infrarotsensoren haben aber so die Eigenart, dass sie extrem unterschiedlich auf die Farbe und die Beschaffenheit des Untergrunds reagieren. Bei weißem, spiegelglatten Untergrund (oder Aluminium) löst der Sensor schon sehr früh aus, bei rauhem schwarzen Untergrund kaum. Da wäre Ultraschall vielleicht doch besser, aber darauf kannst du keinen Einfluss nehmen, wenn das die Aufgabenstellung nicht vorsieht. Das heißt, dass du jetzt wirklich überlegen musst, wie du die richtigen Werte für dich herausfinden kannst. Um zu sehen, welcher Wert vom Infrarotsensor am besten zu der gewünschten Weite passt, wo der Roboter sich drehen soll, kannst du zB. ein einfaches Programm schreiben, wo der Sensor einfach abgefragt wird und je nachdem, ob der Wert über einem bestimmten Wert ist, eine LED schaltet. Dann kannst du den Roboter näher an das Hindernis halten oder weiter weg und gucken, wann die LED an oder aus geht. Das probierst du dann mit mehreren Werten (und vielleicht auch mit verschiedenen Hindernissen), bis du einen Wert gefunden hast, der gut ist. Dass man auch einfach den Sensorwert auf die Motoren geben kann, ist auch eine gute Möglichkeit. Weißt du denn, was für ein Infrarotsensor verwendet wird und was für Werte man wann erwarten kann?
Kann mir gar nicht vorstellen, dass du keine LED oder ähnliches am Roboter hast, sowas ließe sich gut für Debuggingzwecke verwenden (zB., ob in bestimmte Verzweigungen gesprungen wird oder ähnliches).

[timmy19]

Da reden wir aneiander vor bei: Klar, ich hab 3 LEDs(2 grün, 1 rot), ich meinte so nen LED-Display an dem man Werte ablesen kann, das hab ich nämlich nicht...

Edit: Hab das jetzt getestet: Für meine Bahn ist infrarot < 120 perfekt.

Mein Code sieht nun so aus:

#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;  
	int abstand   = robot.analog(1);
	int infrarot  = robot.analog(3);
  
    while(1)
    {
        
		
        if( drehrichtung == geradeaus)
        {
            robot.motors(200,200); //geradeaus fahren
            if( abstand < 90)
            {
                if(schonNachLinksAusgewichen == False)
                    drehrichtung = linksDrehung;
                else
                    drehrichtung = rechtsDrehung;
            }
        }
        if( drehrichtung == linksDrehung )
        {
		    robot.motors(-100,-100);
			msleep(100);
            robot.motors(-150, 150); // nach links drehen
			msleep(300);
            if( abstand >= 150 )
            {
                robot.motors(200,200);
				msleep(500);
                schonNachLinksAusgewichen = True;
				robot.motors(150, -150); 
				
				if( infrarot < 120){
		        robot.motors(100,-100);
				msleep(500);
				
            }
        }
        if( drehrichtung == rechtsDrehung )
        {
			robot.motors(-100, -100);
			msleep(100);
            robot.motors(150, -150); // nach rechts drehen
			msleep(300);
            if( abstand >= 150 )
            { 
			    robot.motors(200,200);
				msleep(500);
                schonNachLinksAusgewichen = False; 
				robot.motors(-150, 150);
				
				int infrarot  = robot.analog(3);
				if( infrarot < 120){
		        robot.motors(100,-100);
				msleep(500);
				
	
			// Er ist zwar schon mal nach links ausgewichen, aber inzwischen auch schon rechtsrum, also wieder von vorne
			
			
			
			
			
			}  
		}		  
	}	

}	
}
}

Trotzdem reagiert der Robo nicht auf den Boden. Ich weiß leider immer noch nicht woran das liegt. Kann das sein, dass er gar nicht soweit in seiner Schleife vorankommt?

[Geistesblitz]

Ich hab gerade mal versucht, deinen Code zu entziffern, aber die Einrückungen machen es wirklich sehr unleserlich. Wenn eine geschweifte Klammer aufgeht, sollte alles darunter eine Stufe weiter rechts stehen, wenn eine geschweifte Klammer zu geht, weiter nach links. Oder wird dein Code durch die Code-Tags übern Haufen geworfen?

Jedenfalls vermute ich auch mal, dass deine Probleme in der Verschachtelung liegen, hab mindestens eine Stelle gesehen, wo ein elseif oder zumindest ein else angebracht wäre.

Edit: warum wird eigentlich eine LCD_Bibliothek eingebunden, wenn kein LCD vorhanden ist? Muss ich das verstehen?

nochmal Edit: ist abstand der Wert, den du vom Entfernungssensor ausliest, um ein Hinternis zu detektieren? Der wird nämlich einmal am Anfang vor der while-Schleife ausgelesen und dann nie wieder...das heißt, der Wert ändert sich nie. Du musst den Sensor bei jedem Schleifendurchlauf auslesen mit

abstand = robot.analog(1);

sonst kann das gar nix werden...

[021aet04]

Und wieder "int infrarot = robot.analog(3);" in der while Schleife.

MfG Hannes

[timmy19]

Danke, hab dass aber schon irgedwann heute morgen reingeschrieben. Soweit passt das jetzt auch. Jetzt brauch ich nur noch dieses blöde Infrarot. Hier der Code der Linksdrehung:

if( drehrichtung == linksDrehung )
        {
		    robot.motors(-255, 255); // nach links drehen
			
			
            if( abstand >= freieSicht )
            {
                robot.motors(200,200);
                schonNachLinksAusgewichen = True;
				//if( infrarot > 180){
				//robot.motors(100,-100);
				//msleep(500);
				//}
				
            }

Das Infrarot ist grad noch auskommentiert, da es nicht klappt. Wie bekomm ich es hin, dass:

- Der Robo nach der Linksdrehung eben wieder geradeaus in waagrechte Richtung fährt, aber währenddessen per Infrarot den Boden prüft und bei > 180 (das ist der Wert, hab ich über die LEDs geprüft) sich wieder dreht (hier nach rechts)? Wenn ich das nicht habe, komm ich gar nicht weiter und ich weiß leider nicht, was ich da noch verändern könnte, so dass er das macht. Habt ihr ne Ahnung, wie ich das hinbekommen könnte?

[021aet04]

Was funktioniert nicht? Was macht der Roboter?
Mach einfach eine Skizze wie und wo der Roboter auf was reagieren soll. Das dein Roboter waagrechter Richtung fährt ist eigentlich logisch.

Du könntest dich auch weiter informieren (es gibt nicht nur if Schleifen) z.B. der Link den ich oben gepostet habe. Es gibt auch fußgesteuerte Schleifen, if und while sind kopfgesteuerte Schleifen da diese am Anfang überprüft werden.

Für die Skizze kannst du ein CAD Programm herunterladen oder du verwendest einfach Paint.

MfG Hannes