"Hindernisfahrt"

[timmy19]

Das klappt. Kann mir aber nicht vorstellen, dass das ein falscher Messwert ist, vorallem da der ja in dem Falle ja gar nicht relevant ist, denn er gehört ja zum Ultraschall. Was könnte es denn noch sein? Bin ganz verzweifelt, denn wenn ich die links rechts- Regelung rausnehm klappt alles, was ich möchte...

Achso und nein, ich hab kein LCD, die Werte haben wir in der Schule gemessen. Ist ja auch nur der "Abstand" zum Hindernis.

Edit: Mein aktueller Code:

#include "qfixMiniBoard.h"
#include "qfixLCD.h"


const int SENSOR3 = 3;
	   int SENSOR1 = 1;
	   int SENSOR2 = 2;
	   int SENSOR = 0;

MiniBoard robot;
LCD lcd;

int i=0;
int mitt = 0;
int drehrichtung = 0;
  

int main(){
{  
	while(1){
   int i = robot.analog(1) ;
   
  
   if (i > 75){
   robot.motors(250,250); //geradeaus
   }
   else
{if (drehrichtung == 0)
{
robot.motors(-200, 200);
drehrichtung = 1;
}
else
{
robot.motors(200, -200);
drehrichtung = 0;
}
  msleep(2500);
  if( mitt > 185){
   robot.motors(100,-100);
  msleep(300);
}

[-schumi-]

Du solltest dir unbedingt eine übersichtliche Einrückung angewöhnen! Das unterschätzt man als Anfänger, aber sowas erhöht die Lesbarkeit ungemein (und dann kommt auch nicht so ein Durcheinander raus, z.B. zu viele { und } (nach main) oder eine Variable zwei mal als Int deklariert (i) usw)

So ganz kann ich deinen Code auch nicht nachvollziehen wenn ich ehrlich bin (was soll "mitt" sein?).. Aber ich glaube dein Hauptproblem ist, dass du bei einem Abstand von <75 (also z.B. 74) kurz (300ms) nach links drehst, und dann gleich wieder geradeaus fährst weil der Abstand jetzt ja >75 (also z.B. 76) ist. Somit zuckelt der Robo nur etwas umher...

Als inspiration (sollte eigentlich lauffähig sein wenn ich keine Tippfehler gemacht habe und dein Sensor einen Abstand von 120 messen kann):

#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;
    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 )
            {
                drehrichtung = geradeaus;
                schonNachLinksAusgewichen = True;
            }
        }
        if( drehrichtung == rechtsDrehung )
        {
            robot.motors(200, -200); // nach rechts drehen
            if( abstand >= freieSicht )
            {
                drehrichtung = geradeaus;
                schonNachLinksAusgewichen = False; // Er ist zwar schon mal nach links ausgewichen, aber inzwischen auch schon rechtsrum, also wieder von vorne
            }
        }
    }
}

[timmy19]

Wow danke, das hilft mir schon nen ganzes Stück weiter. Nur ein Problem hab ich:

Wenn der Robo die Linksdrehung gemacht hat, fährt der bei deinem Code plötzlich rückwärts weiter. Das kann ich nicht ganz nachvollziehen. Kannst du mir da helfen?

PS: "mitt" sollte ein Infrarotsensor sein, den ich zwischendrin eingebaut hatte, aber nicht funktionierte und daher wieder rausstrich(der muss aber noch rein!)

[-schumi-]

Wenn der Robo die Linksdrehung gemacht hat, fährt der bei deinem Code plötzlich rückwärts weiter. Das kann ich nicht ganz nachvollziehen.

Das kann ich auch nicht nachvollziehen... Es ist ja gar kein "robot.motors(xxx,yyy);" mit zwei negativen Werten im Programm drin

[EDIT]
Kann es sein, dass es sich bei deinem Robo um diesen hier handelt: http://en.wikipedia.org/wiki/Qfix_robot_kit ?
Das Umfahren von Hindernissen ist nämlich mit mehreren Abstandssensoren deutlich einfacher/zuverlässiger..

[timmy19]

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?

 #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
			
			
			
			
			
			}  
		}		  
	}	

}

[021aet04]

Ich würde es in etwa so machen (nur die while Schleife als Pseudocode):

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
}
}
}

Du musst vermutlich noch ein Delay (msleep) einfügen.

MfG Hannes

[timmy19]

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.

#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
			
			
			
			
			
			}  
		}		  
	}	

}