"Hindernisfahrt"

[timmy19]

Hallo ich bin neu hier.

Nun zu meinem Problem:

Ich muss für die Schule ein Programm schreiben, bei der ein Roboter Hindernisse UMfahren muss. Leider komm ich nicht derzeit noch nicht soweit, da ich ein Problem habe. Der Roboter erkennt das Hindernis und fährt links. Nach einer Weile sollte er wieder nach rechts fahren, was er aber konsequent nicht tut. Wollte das eigentlich mit einem Infrarotsensor regeln(es gibt einen bestimmten Boden vorgegeben), bekomm das aber nicht hin. Habe was dazu geschrieben, aber irgendwie reagiert der Roboter nicht darauf. Vielleicht könnt ihr mir sagen was der Fehler ist. Das ist aber nur mein erstes Problem.

Das zweite:

Nachdem der Roboter nach rechts gefahren ist, fährt er ja auf das nächste Hindernis zu. Nun sollte er, wenn er das Hindernis erkennt, aber nicht nach links, sondern jetzt nach rechts fahren. Habe es versucht mit einer Variable x dies zu regeln, also dass beim ersten Hindernis X=1, beim zweiten X=-1 und so weiter und so fort. Das klappt aber nicht, dann fährt der Roboter immer nur vor und zurück.

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


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

MiniBoard robot;
LCD lcd;


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

Ich hoffe ihr könnt mir helfen.

PS: Falls das hier, das falsche Forum ist, tut es mir Leid, hab kein anderes gefunden...

[021aet04]

Warum rechnest du x=x*(-1) ?

Ich würde einfach den else Zweig anpassen. Für die Drehrichtung nimmst du eine Variable. Du änderst einfach den Zustand zwischen 0 und 1.

...
...
else
{
if (drehrichtung == 0)
{
robot.motors(-200, 200);
drehrichtung = 1;
}
else
{
robot.motors(200, -200);
drehrichtung = 0;
}
msleep(300);
}

Bei Rechnungsaktionen muss man aufpassen das du den Controller nicht überforderst. Ohne Rechnen ist der Controller auch schneller, da es resourcenschonender ist. Man verwenden auch wenn möglich keine Rechenaktrionen sondern Konstanten (z.B. U=2 x pi x r => U = 6,28 x r).

MfG Hannes

[timmy19]

Danke dir.

Das Problem ist nun aber genau dasselbe, wie wenn ich mit x = x*(-1) rechne. Der Roboter bewegt sich immer nur vor und zurück.
Was ist das Problem?

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


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

MiniBoard robot;
LCD lcd;


int main(){
{
int i=0;
int mitt = 0;
int drehrichtung = 0;
  
	while(1){
   int i = robot.analog(1) ;
   int mitt= robot.analog(3);
   
  
   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(300);
}
   
   
  
   }
   }
   
   
   }

[021aet04]

Welcher Bereich wird bei der Drehzahl genutzt? Hast du Tasten oder Potis auf dem Roboter die du verwenden kannst?

Du könntest éinmal versuchen statt -200 z.B. 100 eintragen. Ich vermute (ich kenne dein System nicht) das der Wertebereich von -127 bis +128 oder 0 bis 255 geht (das wäre genau ein Byte).

MfG Hannes

[timmy19]

Ich habe Tasten zum Starten des Roboters und der Drehzahlbereich geht von -255 bis 255.

Wenn ich das mit 100 versuche löst es das Problem leider nicht, der Roboter bewegt sich einfach nur langsamer hin und her...

Edit: Ich glaube, das Problem liegt einfach in der Regelung mit "rechts" und "links" (das was ich mit x= x*(-1) lösen wollte.

[021aet04]

Gib einmal die ganzen "int ..." aus der main Funktion hinaus (vor "main {"). Dann könntest du einmal versuchen ohne Analogauswertung die Motoren drehen lassen.

z.B.

main
 {
while(1)
{
robot.motors (200,200);
msleep(1000);
robot.motors (-200,200);
msleep(1000);
robot.motors(200,-200);
msleep(1000);
}
}

Wenn das funktioniert hast du ein Problem mit der Analogauswertung. Eventuell passt der Messwert nicht. Ich habe etwas von "LCD" gelesen, hast du eines? Eventuell kannst du dir den Messwert ausgeben lassen.

MfG Hannes

[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.

[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?