Optimierung der Bewegung mit Ultraschall-Abstandssensoren

**ehenkes** · 03.06.2007, 18:34

ASURO mit US-Abstandssensoren und den zusätzlichen Funktionen aus ultrasonic.c (aus Lib 3). Mich würde interessieren, wie ihr das Bewegungsmuster optimiert habt, damit sich ASURO nicht ständig fest fährt? Hier meine aktuelle Version, mit der er sich schon ganz nett bewegt. Er kann sich jetzt allerdings noch nach hinten fest fahren. Da fehlt mir noch die richtige Idee.

Code:

#include "asuro.h"
#define MAXDIFF 80

int main(void)
{
  int abstand, abstand_alt, diff, zaehler=0;
  Init();
  abstand = Chirp();
   
  while(TRUE)
  {
    abstand_alt = abstand;
	abstand = Chirp();	++zaehler;
	diff = abstand - abstand_alt;
	
	if( (abstand>15) && (abs(diff)<MAXDIFF) )
	{
	  StatusLED(GREEN);
	  MotorDir(FWD, FWD);
	  MotorSpeed(150, 150);
	}
	else if( (abstand>10) && (abstand<=15) && (abs(diff)<MAXDIFF) )
	{
	  StatusLED(GREEN);
	  MotorDir(FWD, FWD);
	  MotorSpeed(100, 150);
	  Msleep(30);
	}
	else
	{
	  StatusLED(RED);
	  MotorDir(RWD, RWD);
	  MotorSpeed(150, 100);
	  Msleep(100);
	}
	
	if (zaehler > 400)
	{
		StatusLED(RED);
		BackLED(ON,ON);
	    MotorDir(RWD, RWD);
	    MotorSpeed(200, 250);
	    Msleep(10);
		BackLED(OFF,OFF);
	}
	if (zaehler > 405)
	{
		StatusLED(RED);
		BackLED(ON,ON);
	    MotorDir(RWD, RWD);
	    MotorSpeed(250, 200);
	    Msleep(10);
		BackLED(OFF,OFF);
				
		if(zaehler > 410)
		  zaehler = 0;
	}
  }
  return 0;
}

**stochri** · 03.06.2007, 22:25

Du kannst die Reibung detektieren, um eine Kollision festzustellen ( auch nach hinten ).

Code:

#include "asuro.h"  // bitte die neue Datei benutzen
                    // asuro.h und asuro.c vom 31.03.05

#define aus MotorDir(BREAK,BREAK)
#define go {MotorSpeed(150,150);MotorDir(FWD,FWD);}
#define backturn { MotorSpeed(150,250);MotorDir(RWD,RWD);Msleep(1000);}

/*************************************************************************************

  ASURO discovers your apartment

  program made by stochri july, 2005

*************************************************************************************/

int speed()
{
   int rightspeed,leftspeed;
   int leftold,rightold;

   Encoder_Set(0,0);      // reset encoder


   leftold=encoder[LEFT];
   rightold=encoder[RIGHT];
   Msleep(300);
   leftspeed=encoder[LEFT]-leftold;
   rightspeed=encoder[RIGHT]-rightold;

   //SerWrite("  speed Left,Right ",19);
   //PrintInt(leftspeed);
   //PrintInt(rightspeed);
   return leftspeed+rightspeed;
}

int main(void)
{
   int n,v,nullspeed;

   Init();
   Encoder_Init();
   StatusLED(OFF);
   SerWrite("\n\rASURO OK\n\r",8);

   go;
   Msleep(500);

   nullspeed=speed()-10;

   while(1)
   {
      v=speed();
      SerWrite("\n\r speed ",9);
      PrintInt(v);

      if(v<nullspeed)
      {
         backturn;
         go;
         Msleep(500);
      }

   }
   return 0;
}

**ehenkes** · 03.06.2007, 23:33

Gute Idee. Danke!

**stochri** · 04.06.2007, 18:51

Hallo Erhard,

schön, dass Dir die Idee gefällt. Wir haben hier auch schon über weitergehende Verfahren diskutiert ( hier ) Vielleicht sind ja noch was interessantes für Dich dabei.

Vielleicht hier noch mal zur Intention dieses Threads:
Mein Ansatz ist, mit den vorhandenen Mitteln das Maximale aus der Technik herauszuholen. Das interessante daran ist, dass man unter Umständen auf Lösungsmöglichkeiten kommt, die andere auf Grund des Suchraumes gar nicht finden würden.
Der ASURO hat eine sehr eingeschränkte Sensorik und Aktuatorik und es hängt sehr stark von den geistigen Vorstellungskraft derjenigen ab, was damit erreicht werden kann.

Mir ist bei der Beschäftigung mit dem Kollisionserkennungsalgorithmus aufgefallen, dass sich der ASURO zwar selten aber doch machmal in einer Ecke verfangen kann.
Normalerweise bemerkt der Algorithmus, wenn die Radgeschwindigkeit langsamer wird. Dann fährt der Roboter in einem ca. 90° Winkel zurück.
Jetzt gibt es Situationen, bei denen der Roboter sozusagen in einene Dead-Lock gerät, bei dem er ständig anstößt, zurückfährt, vorfährt und an der selben Stelle anstößt.
Wenn ein Mensch den ASURO nicht sehen könnte, aber auf einem Computerbildschirm die Radgeschwindigkeit beobachtet, dann könnte er aus der Periodizität der Radgeschwindigkeitsänderung Rückschlüsse auf das Hängenbleiben des Roboters ziehen.

Hier läst sich ein Algorithmus entwickeln, der sozusagen auf einer höheren Abstraktionsebenene den Zustand des Roboters erkennen kann und entsprechend eingreift.

Eine zweite Sache, die ab und zu mal passiert, ist, dass der Roboter nach hinten umfällt und die Räder in der Luft drehen. Hier liese sich ebenfalls ein Algorithmus erstellen, der aus der Kenntnis der Raumgröße weiss, dass wenn die Räder längere Zeit ohne Kollisionserkennung laufen, der Roboter umgefallen sein muss.