Objektverfolgung mit SUMO-Adapter

[pinsel120866]

Hi,

ich habe mir mal überlegt mit meinem SUMO-Adapter die Objektverfolgung zu realisieren. Jetzt mal ein paar Fragen:

- ist dies mit dem SUMO-Adapter überhaupt möglich?
- brauche ich dazu nicht mindestens 3 IR-LEDs?
- hat das schon einmal jemand versucht?
- muss ich Umbauten am ASURO vornehmen?

Ich stelle mir das so vor, dass der ASURO einem anderen ASURO nachfährt und immer einen bestimmten Abstand einhält.

[damaltor]

eine abstandsmessung, welche du ja für die verfolgung benötigst, geht schon mit einer LED. wenn du auch die richtung bestimmen willst, dann müssten 2 LEDs funktionieren, die etwas schräg zueinander stehen. so kann der asuro immer in die richtung fahren, wo die LED bzw die Abstandsmessung eitwas "sieht".

[pinsel120866]

Aha, jetzt wäre es noch cool herauszufinden wie ich eine weitere IR-LED auf die SUMO-Platine drauf bringe, damit der ASURO 2 "Augen" hat. Parallel schalten wird wohl nicht gehen, oder?

[robo.fr]

Interessanterweise sollte das auch mit einer LED gehen. Probier doch mal das Programm von M. aus, das "sieht" die Hindernisse eigentlich ganz gut.
Wenn der ASURO beim Fahren leicht pendelt, kann er in die Richtung, deren Signal stärker ist, sich etwas mehr bewegen.
Dann sollter er das Objekt verfolgen können.

robo

[pinsel120866]

OK, Robo. Ich werde außerdem versuchen dein Testprogramm für die Platine auszubauen, wenn du es erlaubst.

[robo.fr]

OK, Robo. Ich werde außerdem versuchen dein Testprogramm für die Platine auszubauen, wenn du es erlaubst.

Klar, deshalb habe ich auch die Open-Source Lizentbestimmung drangehängt. Nur eines wär e mir wichtig: "Please maintain the list of authors". Es soll ja so sein, dass man weiß, wer betstimmte Teile am Gesamtprojekt programmiert hat.

Bester Gruß,
robo

[M1.R]

Probier doch mal das Programm von M. aus, das "sieht" die Hindernisse eigentlich ganz gut. ja, mit dem "Verfolgungsteil" von meinen Joghurt-Sumo Programm funktionniert da so halbwegs, wenn sich das verfolgte Objekt nicht zu schnell seitlich wegbewegt. Ich hatte sowieso vor, bei Gelegenheit das Programm in ein Verfolgungsprogramm umzubauen.

@pinsel
Das kannst du aber auch selber versuchen:
- das Programm von allen unnötigen Teilen befreien
- wenns Objekt nah ist statt über die Linie schieben stehenbleiben
- Geschwindigkeit, Abstand, Schwenkdauer, Verlierdauer anpassen
Gruss
M.

[pinsel120866]

Hallo,

ich habe das Programm von M1.R mal an die Objektverfolgung angepasst. Funktioniert ganz gut, allerdings verliert der ASURO leicht das vorfahrende Objekt. Möglicherweise braucht es doch noch eine zusätzliche IR-LED, damit die Sache besser funktioniert.



#include "asuro.h"
#define HALF 2

uint16_t i, zuf;
uint8_t objekt_weit, objekt_nah, rechts, links, speed1, speed2, richtung;


//abstand für ir-messung
#define nah 1 //1
#define weit 7 //max 16

#define schwenkdauer 100
#define verlierdauer 500



//-------------------------------------------------------------------
//projekt-funktionen
//-------------------------------------------------------------------

void BackLEDleft(uint8_t status);
void BackLEDright(uint8_t status);
uint8_t objekt_sichtbar(uint8_t abstand);


//------------------------------------------------------------------
//backled funktionen um die leds unabhängig voneinander
//hell leuchten oder glimmen zu lassen
//------------------------------------------------------------------
// rechte led
void BackLEDright(uint8_t status) // aus - hell - glimm
{
PORTD &= ~(1 << PD7); //odoleds aus
if (status == OFF)
{ //rechte backled aus
DDRC |= (1 << PC0); //rechts auf out
PORTC &= ~(1 << PC0); //rechte aus
}
if (status == ON)
{
//rechte backled hell
DDRC |= (1 << PC0); //rechts auf out
PORTC |= (1 << PC0); //rechte an
}
if (status == HALF)
{ //rechte backled glimmt
DDRC &= ~(1 << PC0); //rechts auf in
}
}

//------------------------------------------------------------------
// linke led
void BackLEDleft(uint8_t status) // aus - hell - glimm
{
PORTD &= ~(1 << PD7); //odoleds aus
if (status == OFF)
{ //rechte backled aus
DDRC |= (1 << PC1); //links auf out
PORTC &= ~(1 << PC1); //linke aus
}
if (status == ON)
{
//rechte backled hell
DDRC |= (1 << PC1); //links auf out
PORTC |= (1 << PC1); //linke an
}
if (status == HALF)
{ //rechte backled glimmt
DDRC &= ~(1 << PC1); //links auf in
}
}


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

uint8_t objekt_sichtbar(uint8_t abstand)

Ist ein Objekt in der Entfernung kleiner oder gleich
dem Eingangsparameter "abstand" erkennbar?

objekt_sichtbar(7) liefert TRUE zurück, falls überhaupt
ein Object detektierbar.

abstand:
0: 5cm
1: 7cm
2: 13cm
3: 15cm
4: 16cm
5: 17cm
6: 18cm
7: 22cm

( Testobjekt: Joghurtecher, Umgebungsbeleuchtung: Zimmer )

return: TRUE falls Objekt gefunden
FALSE wenn nicht
------------------------------------
geändert (m1.r):
schaltet nach dem messen die led aus
und wartet noch 1ms wegen
der AGC(automatic gain control,
automatische Verstärkungsregelung) des empfängers
------------------------------------

Zeitbedarf: 6ms

author: robo.fr, christoph ( ät ) roboterclub-freiburg.de
date: 2008

************************************************** ***********************/
uint8_t objekt_sichtbar(uint8_t distance)
{
uint16_t j,z;

DDRD |= (1 << DDD1); // Port D1 als Ausgang
PORTD &= ~(1 << PD1); // PD1 auf LOW => ir-led an

OCR2 = 254-distance; // wenn OCR2=0xFE dann Objekt sehr nahe
z=0;
for(j=0;j<30;j++) // loop time: 5ms
{
if (PIND & (1 << PD0))z++;
Sleep(6); // 6*Sleep(6)=1ms
}
PORTD |= (1 << PD1); // PD1 auf High led auschalten
Msleep(1); // kurz warten
if (z>=29) return FALSE; // Objekt nicht gefunden
else return TRUE;
}


//-------------------------------------------------------------------
//-------------------------------------------------------------------
//hauptprogramm
int main(void)
{
Init();

objekt_weit = objekt_sichtbar(weit);


while(1)
{

objekt_weit = objekt_sichtbar(weit);

//-------------------------------------------------------------------
//wenn objekt gesehen, verfolgen!!
if (objekt_weit == 1)
{
StatusLED(YELLOW);
BackLEDleft(OFF);
BackLEDright(OFF);
MotorDir(FWD,FWD);
richtung = 0;


while ((objekt_sichtbar(weit) == 1) && (objekt_sichtbar(nah) == 0))
{

//fahr nach links
if ((objekt_sichtbar(weit) == 1) && (richtung == 0))
{
i=0;
while (i<= schwenkdauer)
{
StatusLED(YELLOW);
BackLEDleft(HALF);
BackLEDright(OFF);
MotorSpeed(100,155);
richtung=1;
i++;
Msleep(1);
}
i=0;
}


//fahr nach rechts
if ((objekt_sichtbar(weit) == 1) && (richtung == 1))
{
i=0;
while (i<=schwenkdauer)
{
StatusLED(YELLOW);
BackLEDleft(OFF);
BackLEDright(HALF);
MotorSpeed(155,100);
richtung=0;
i++;
Msleep(1);
}
i=0;
}
}


//wenn kein objekt mehr zu sehen ist
if (objekt_sichtbar(weit) == 0)
{
//wenn letzte richtung nach rechts war
//dann ist das objekt links verloren gegangen
//linke backled an
//nach links fahren bis objekt wieder da ist

BackLEDleft(OFF);
BackLEDright(OFF);


if (richtung == 0)
{
i = 0;

while ((objekt_sichtbar(weit) == 0) && (i<=verlierdauer))
{
StatusLED(RED);
BackLEDleft(HALF);
BackLEDright(OFF);
MotorSpeed(0,255);
richtung=0; //danach mit links anfangen
Msleep(1);
i++;
}

}

//wenn letzte richtung nach links war
//dann ist das objekt rechts verloren gegangen
//rechte backled an
//nach rechts fahren bis objekt wieder da ist
//oder nach einer gewissen zeit nicht wieder aufgetaucht ist
else if (richtung == 1) //letzte richtung war nach links
{

i = 0;
while ((objekt_sichtbar(weit) == 0) && (i<=verlierdauer))
{
StatusLED(RED);
BackLEDleft(OFF);
BackLEDright(HALF);
MotorSpeed(255,0);
richtung=1; //danach mit rechts anfangen
Msleep(1);
i++;
}

StatusLED(OFF);
BackLEDleft(OFF);
BackLEDright(OFF);
}
}
//wenn objekt ganz nah, stehen bleiben
if (objekt_sichtbar(nah) == 1)
{
StatusLED(RED);
BackLEDleft(ON);
BackLEDright(ON);
MotorDir(FWD,FWD);
MotorSpeed(0,0); //stehen bleiben
Msleep(1);
}
}

//-------------------------------------------------------------------





}






while (1);
return 0;
}


Ausprobieren erlaubt, Anregung und Kritik erwünscht.

[oberallgeier]

... mit meinem SUMO-Adapter ...Vermutlich ist die Frage doof, aber bitte, wie sieht der SUMO-Adapter aus? Oder - in welchem Thread findet man den Aufbau beschrieben (die Suchfunktion zeigt eine ziemlich lange Latte....).
Danke für die Antworten.

[pinsel120866]

Hallo oberallgeier,

Infos zum SUMO-Adapter kriegst du hier:

http://www.roboterclub-freiburg.de/asuro/hardware/chAtmegaAdapter/SumoAdapter.html

[robo.fr]

Aha, jetzt wäre es noch cool herauszufinden wie ich eine weitere IR-LED auf die SUMO-Platine drauf bringe, damit der ASURO 2 "Augen" hat. Parallel schalten wird wohl nicht gehen, oder?

Hallo pinsel,

mir ist eine sehr einfache Lösung eingefallen, dem ASURO mit dem SUMO-Adapter 2 Augen zu verpassen:
Die Lösung lautet, die Dioden nicht parallel, sondern anti-parallel zu schalten.
Du kannst dann mit der Polarität von TxD auswählen, welche der beiden Dioden senden soll.
Die Lösung hat allerdings den Nachteil, dass man dann die IR-Sendedioden vermutlich nur noch schlecht zur Datenübertragung verwenden kann, da ja immer eine der beiden Dioden leuchtet. Dazu gibt es wiederum 4 verschiedene Lösungsmöglichkeiten
1. mit einem Jumper eine IR-LED abklemmen
2. für Kommunikation eine IR-LED abdecken
3. Die 2.te LED an einen anderen Pin des Atmega8 hängen, z.B. den Tasteninterrupt
4. eine Software UART programmieren die TxD hochohmig schaltet

Gruß,
robo

[pinsel120866]

Hi robo,

"Anti-parallel" - wie soll das gehen? Als freien Kanal würde ich den Tasteninterrupt bevorzugen.

[robo.fr]

Hallo Pinsel,
eine Diode hat einen Richtungspfeil. Dieser Pfeil zeigt in die Richtung, in der die Diode Strom durchlässt. Antiparallel bedeutet, eine Diode an die gleichen Anschlüsse wie die schon vorhandene Diode anzuschließen, nur eben, dass der Richtungspfeil anderstrum zeigt.
Wenn Du die Diode an den Tastaturinterruptpin anschließt, musst Du noch einen Widerstand in Serie schalten. Dann muss man den Pin auf Ausgang programmieren, und den TXD Pin auschalten, wenn man diese Diode leuchten lassen will.

Gruß,
robo