"Die Verfolgung" - Video

... und noch ein kleines Video:

http://de.youtube.com/watch?v=tt2Q8K9ApOE

Gruss
M.

Cool gemacht!

Ich habe deinen Code ja auch überarbeitet, aber nicht das gute Ergebnis von dir erreicht. Bei mir schwankt der ASURO nicht so stark und verliert dadurch leichter das Ziel.

Kannst du bitte den Code mal posten oder mir ans Forum mailen, damit ich vergleichen kann?

Zitat:

---

Zitat von pinsel120866

Kannst du bitte den Code mal posten oder mir ans Forum mailen, damit ich vergleichen kann?

---

na ja, das Programm ist jetzt an DOROs Geschwindigkeit und Größe angepasst. Ich bezweifle, dass der ASURO mit diesen Einstellungen andere Objekte genauso gut verfolgen kann.

Code:

---

//-------------------------------------------------------------------
//-------------------------------------------------------------------
// M1.R
// doroverfolgung_v01
// mit tasterabfrage
//-------------------------------------------------------------------
//-------------------------------------------------------------------

#include "asuro.h"
#include "myasuro.h"


//-------------------------------------------------------------------
//variable
uint16_t i;
uint8_t tasterwert, objekt_weit, objekt_nah, rechts, richtung, abbrechen;




//-------------------------------------------------------------------
// defines

#define nah 1  //1
#define weit 3  //max 16

#define speedniedrig 0 //50
#define speedhoch 200        //180
#define speedausgleich 10

#define schwenkdauer 80 //60

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


//-------------------------------------------------------------------
// wenden
void kollision (void)
{
        tasterwert = PollSwitch();
        FrontLED(ON);
        MotorDir(RWD,RWD);
        if (tasterwert > 6) // linker taster
        {
                BackLEDleft(ON);
                BackLEDright(HALF);
                MotorSpeed(160,0);
        }
        else
        {
                BackLEDleft(HALF);
                BackLEDright(ON);
                MotorSpeed(0,160);
        }
        Msleep(100);
        MotorSpeed(160,160);
        Msleep(300); // noch ein stückchen rückwärts
        MotorDir(FWD,FWD);
        abbrechen = 0;
        KeyPressed();
        FrontLED(OFF);
        BackLEDleft(OFF);
        BackLEDright(OFF);
}


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

void fahr_nach_links (void)
{
        BackLEDleft(HALF);
        BackLEDright(OFF);
        MotorDir(FWD,FWD);
        MotorSpeed(speedniedrig,speedhoch+speedausgleich);
}

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

void fahr_nach_rechts (void)
{
        BackLEDleft(OFF);
        BackLEDright(HALF);
        MotorDir(FWD,FWD);
        MotorSpeed(speedhoch,speedniedrig+speedausgleich);
}

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


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

        StatusLED(OFF);       

        akku_kontrolle();

        //geradeaustest
        /*
        MotorDir(FWD,FWD);
        MotorSpeed(speedniedrig,speedniedrig+speedausgleich);
        Msleep(2000);
       
        MotorSpeed(speedhoch,speedhoch+speedausgleich);
        Msleep(2000);
        MotorSpeed(0,0);
        */
       
        //-------------------------------------------------------------------
        // warten
       
        while (objekt_sichtbar(weit) == 0)
        {
                BackLEDleft(HALF);
                BackLEDright(HALF);
                StatusLED(OFF);
                MotorDir(FWD,FWD);
                MotorSpeed(0,0);
        }
       

        //-------------------------------------------------------------------
        // hauptschleife

        while(1)
        {       
               
                if (objekt_weit == 0)
                {
                        StatusLED(YELLOW);
                        BackLEDleft(HALF);
                        BackLEDright(HALF);
                        MotorDir(FWD,FWD);
                        MotorSpeed(200,200);
                        //Msleep(100);
                }
               
                objekt_weit = objekt_sichtbar(weit);
               
                if (KeyPressed() == 1)
                {       
                        kollision();       
                }

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

                                if (KeyPressed() == 1)
                                {       
                                        kollision();
                                        abbrechen = 1;       
                                }
                               
               
                                while(abbrechen == 0)
                                {
                                        while ((objekt_sichtbar(weit) == 1) && (abbrechen == 0) && (objekt_sichtbar(nah) == 0))
                                        {                                               
                                                StatusLED(GREEN);
                                                if (KeyPressed() == 1)
                                                {       
                                                        kollision();
                                                        abbrechen = 1;       
                                                }
                                               

                                                //fahr nach links
                                                if ((objekt_sichtbar(weit) == 1) && (richtung == 0) && (abbrechen == 0))
                                                {       
                                                        i=0;
                                                        while ((abbrechen == 0) && (i<= schwenkdauer))
                                                        {
                                                                if (KeyPressed() == 1)
                                                                {       
                                                                        kollision();
                                                                        abbrechen = 1;       
                                                                }
                               
                                                                fahr_nach_links ();
                                                                richtung=1;
                                                                i++;
                                                                Msleep(1);
                                                        }
                                                        i=0;
                                                }
                       
                       
                                                //fahr nach rechts
                                                if ((objekt_sichtbar(weit) == 1) && (richtung == 1) && (abbrechen == 0))
                                                {
                                                        i=0;
                                                        while ((abbrechen == 0) && (i<=schwenkdauer))
                                                        {
                                                                if (KeyPressed() == 1)
                                                                {       
                                                                        kollision();
                                                                        abbrechen = 1;       
                                                                }
                                                       
                                                        fahr_nach_rechts ();
                                                        richtung=0;
                                                        i++;
                                                        Msleep(1);
                                                        }
                                                        i=0;
                                                }
                                        }
       
               
                                        //wenn kein objekt mehr zu sehen ist       
                                        if ((objekt_sichtbar(weit) == 0) && (abbrechen == 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
                                                        StatusLED(YELLOW);
                                                        BackLEDleft(OFF);
                                                        BackLEDright(OFF);
                                                       

                                                        if (richtung == 0)
                                                        {
                                                                i = 0;
                                                               
                                                                while ((objekt_sichtbar(weit) == 0) && (abbrechen == 0))
                                                                {
                                                                        if (KeyPressed() == 1)
                                                                        {       
                                                                                kollision();
                                                                                abbrechen = 1;       
                                                                        }
                                                                       
                                                                        //ein stück nach links
                                                                        fahr_nach_links ();
                                                                        //Msleep(150);
                                                                        if (objekt_sichtbar(weit) == 1) //und noch ein stück nach links
                                                                        {
                                                                                fahr_nach_links ();
                                                                                Msleep(150);
                                                                        }
                                                                        richtung=0; //danach mit links anfangen
                                                                        Msleep(1);
                                                                                                                                       
                                                                }
                                                                abbrechen = 1;                                                               
                                                        }

                                                        //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) && (abbrechen == 0))
                                                                {
                                                                        if (KeyPressed() == 1)
                                                                        {       
                                                                                kollision();
                                                                                abbrechen = 1;       
                                                                        }
                                                                        //ein stück nach rechts
                                                                        fahr_nach_rechts();
                                                                        //Msleep(150);
                                                                        if (objekt_sichtbar(weit) == 1) //und noch ein stück nach rechts
                                                                        {
                                                                                fahr_nach_rechts ();
                                                                                Msleep(150);
                                                                        }
                                                                        richtung=1; //danach mit rechts anfangen
                                                                        Msleep(1);
                                                                       
                                                                }
                                                                abbrechen = 1;
                                                                StatusLED(OFF);
                                                                BackLEDleft(OFF);
                                                                BackLEDright(OFF);
                                                        }
                                                }
                                        //wenn objekt ganz nah, bremsen
                                        if (objekt_sichtbar(nah) == 1)
                                        {
                                                StatusLED(RED);
                                                BackLEDleft(OFF);
                                                BackLEDright(OFF);
                                               
                                                MotorDir(BREAK,BREAK);

                                                if (KeyPressed() == 1)
                                                {       
                                                        kollision();
                                                        abbrechen = 1;       
                                                }
                                        }
                                }
                        }

                //-------------------------------------------------------------------               
                               
        }

        while (1);
          return 0;
}

---

Gruss
M.

Hi M1.R,

ich wollte gerade dein Verfolgungsprogramm kompilieren und kriege 6 Fehler:

Code:

---

Build started 27.3.2008 at 13:32:26
set -e; avr-gcc -MM -mmcu=atmega8 -I. -g -Os -I../../lib/inc -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms=asuro.lst asuro.c \
    | sed 's,\(.*\)\.o[ :]*,\1.o \1.d : ,g' > asuro.d; \
    [ -s asuro.d ] || rm -f asuro.d
set -e; avr-gcc -MM -mmcu=atmega8 -I. -g -Os -I../../lib/inc -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms=test.lst test.c \
    | sed 's,\(.*\)\.o[ :]*,\1.o \1.d : ,g' > test.d; \
    [ -s test.d ] || rm -f test.d
-------- begin --------
avr-gcc --version
avr-gcc (GCC) 4.2.2 (WinAVR 20071221)
Copyright (C) 2007 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

avr-gcc -c -mmcu=atmega8 -I. -g -Os -I../../lib/inc -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms=test.lst test.c -o test.o
In file included from asuro.h:61,
                from test.c:9:
c:/winavr/bin/../avr/include/avr/signal.h:36:2: warning: #warning "This header file is obsolete.  Use <avr/interrupt.h>."
test.c: In function 'kollision':
test.c:47: warning: implicit declaration of function 'BackLEDleft'
test.c:48: warning: implicit declaration of function 'BackLEDright'
test.c:48: error: 'HALF' undeclared (first use in this function)
test.c:48: error: (Each undeclared identifier is reported only once
test.c:48: error: for each function it appears in.)
test.c:62: warning: implicit declaration of function 'KeyPressed'
test.c: In function 'fahr_nach_links':
test.c:73: error: 'HALF' undeclared (first use in this function)
test.c: In function 'fahr_nach_rechts':
test.c:84: error: 'HALF' undeclared (first use in this function)
test.c: In function 'main':
test.c:100: warning: implicit declaration of function 'akku_kontrolle'
test.c:116: warning: implicit declaration of function 'objekt_sichtbar'
test.c:118: error: 'HALF' undeclared (first use in this function)
make: *** [test.o] Error 1
Build failed with 6 errors and 6 warnings...

---

Wie kann ich ihm "HALF" beibringen?

Hallo Pinsel,

Zitat:

---

Zitat von pinsel120866

ich wollte gerade dein Verfolgungsprogramm kompilieren und kriege 6 Fehler

---

ja klar, da fehlen ja auch die Definitionen und Funktionen!
Ich dachte, du wolltest nur deine Werte mit meinen vergleichen. ;)

Du findest die Funktion KeyPressed hier, und alles Andere ist in
diesem Quellcode drin.

Gruss
M.

Hallo M.

bitte nicht böse sein, ich wollte natürlich auch den Praktischen Teil vergleichen :oops:

Hier ist übringens der von mir adaptierte Code von deinem SUMO-Programm:

Code:

---

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

---

Zitat:

---

Zitat von pinsel120866

bitte nicht böse sein, ich wollte natürlich auch den Praktischen Teil vergleichen

---

Entschuldigung - war nicht böse gemeint!
Im Anhang die HEX - Datei.
Gruss
M.