## c't-Projekte - Mailinglisten

[Voriger (Datum)] [Nächster (Datum)] [Voriger (Thread)] [Nächster (Thread)]
[Nach Datum][Nach Thread]

### AW: [ct-bot] neues catch_pillar

Absender: Frank Menzel
Datum: Mi, 03.10.2007 13:58:31
In-reply-to: <000601c804ed$72c59210$fe78a8c0@mexpnew>

    Hallo,
    anbei also das neue Pillarverhalten als Patch...

    Gruß, Frank Menzel

    -----Ursprüngliche Nachricht-----
    Von: ct-bot-entwickler-bounces@xxxxxxxxxxxxxxxxx
    [mailto:ct-bot-entwickler-bounces@xxxxxxxxxxxxxxxxx] Im Auftrag von
    Frank Menzel
    Gesendet: Dienstag, 2. Oktober 2007 14:12
    An: 'Entwicklung rund um den c't-bot'
    Betreff: AW: [ct-bot] neues catch_pillar

    Hallo,
    also der Anhang ging zumindest raus, wo er geblieben ist weiß ich nicht.
    Werde ich dann eben als Patch nachreichen...

    Mit freundlichen Grüßen
    Frank Menzel

    -----Ursprüngliche Nachricht-----
    Von: ct-bot-entwickler-bounces@xxxxxxxxxxxxxxxxx
    [mailto:ct-bot-entwickler-bounces@xxxxxxxxxxxxxxxxx] Im Auftrag von
    Benjamin Benz
    Gesendet: Dienstag, 2. Oktober 2007 10:50
    An: Entwicklung rund um den c't-bot
    Betreff: Re: [ct-bot] neues catch_pillar

    Hallo,

    kann es sein, dass hier ein Attachment zugehören sollte? Außerdem hätten
    wir Änderungen am Code -- wie immer -- gerne als Patches und nicht als
    Dateien, die ausgetauscht werden sollen. Zu so einem Patch gehört dann
    auch ein Eintrag für Changelog.txt usw. Warum wir das wollen, auch wenn
    manch einer sagen mag "eine Datei ist doch viel praktischer" will ich
    hier nicht schon wieder darlegen, bitte Euch aber, es zu akzeptieren. Es
    vereinfacht die Arbeit wirklich und passt auch besser zur
    Versionsverwaltunng mit SVN.

    MfG Benjamin Benz

    Frank Menzel schrieb:
    > Hallo,
    > da das catch_pillar-Verhalten doch noch einige Fehler und Macken
    hatte,
    > habe ich diese mal umgekrempelt und angehangen. Nicht als Patch
    sondern
    > die Datei selbst, da die Änderungen so grundlegend waren.
    > So ist jetzt die Drehung nach 360 Grad Drehung vorbei, wenn nichts
    > gefunden wurde. Auch wird bei Objekterkennung nicht mehr endlos
    > vorwaerts gelaufen und bei Fehlerkennung damit nach einer bestimmten
    > Strecke voraus weiter im Umkreis gesucht. Eine Wand wird ebenfalls
    nicht
    > mehr als einzufangendes Objekt erkannt und andere Fehlerkennungen
    > vermieden.
    > Einfach gegen die bisherige Datei ersetzen und schon geht's...
    > Ach so, beim Entladen gibt's noch ein abgewandeltes Entladen mit den
    > Params curve und cm, so wie bei bot_drive_distance beschrieben. Ein
    > Objekt wird damit xx cm voraus entladen, wobei der Bot diese mit der
    > curve zurücklegt. Macht dann Klappe auf und fährt den Bogen wieder
    > zurück, das Entladen ist dann vorbei.
    >
    > Gruß, Frank Menzel
    >
    >
    >
    ------------------------------------------------------------------------
    >
    > _______________________________________________
    > ct-bot-entwickler Mailingliste
    > ct-bot-entwickler@xxxxxxxxxxxxxxxxx
    > http://www.heise.de/bin/newsletter/listinfo/ct-bot-entwickler

    --
    Benjamin Benz
    Heise Zeitschriften Verlag
    Redaktion c't
    eMail: bbe@xxxxxxxx
    WWW  : http://www.heise.de

    Heise Zeitschriften Verlag GmbH & Co. KG
    Registergericht: Amtsgericht Hannover HRA 26709

    Persönlich haftende Gesellschafterin:
    Heise Zeitschriften Verlag Geschäftsführung GmbH
    Registergericht: Amtsgericht Hannover, HRB 60405
    Geschäftsführer: Ansgar Heise, Steven P. Steinkraus, Dr. Alfons Schräder

    _______________________________________________
    ct-bot-entwickler Mailingliste
    ct-bot-entwickler@xxxxxxxxxxxxxxxxx
    http://www.heise.de/bin/newsletter/listinfo/ct-bot-entwickler

    _______________________________________________
    ct-bot-entwickler Mailingliste
    ct-bot-entwickler@xxxxxxxxxxxxxxxxx
    http://www.heise.de/bin/newsletter/listinfo/ct-bot-entwickler

    Index: C:/eclipse/workspace/ct-Bot/bot-logic/behaviour_catch_pillar.c
    ===================================================================
    --- C:/eclipse/workspace/ct-Bot/bot-logic/behaviour_catch_pillar.c	(revision 1278)
    +++ C:/eclipse/workspace/ct-Bot/bot-logic/behaviour_catch_pillar.c	(working copy)
    @@ -15,14 +15,19 @@
      * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
      * MA 02111-1307, USA.
      *
    - */
    + */

     /*! @file 	behaviour_catch_pillar.c
    - * @brief 	sucht nach einer Dose und fÃ¤ngt sie ein
    + *  @brief 	sucht nach einer Dose und faengt sie ein; bot dreht sich dazu maximal 360 Grad und das
    + *          Verhalten wird dann beendet falls nichts gefunden wurde; ebenfalls wird nur maximal eine
    + *          gewisse Strecke voraus gefahren zum Einfangen und wenn dann nichts im Bauch vom Sensor
    + *          erkannt wurde wird weiter in der Drehung bis 360 Grad gesucht; ist zu Beginn das Objekt
    + *          zwischen beiden Sensoren, erfolgt beim Linkssuche eine kurze Rechtsdrehung und es sollte
    + *          dann das Objekt erkannt und eingefangen werden
      *
    - * @author 	Benjamin Benz (bbe@xxxxxxxx)
    - * @date 	08.12.06
    + * @author 	Frank Menzel (Menzelfr@xxxxxxx)
    + * @date 	20.09.07
     */

    @@ -30,106 +35,235 @@
     #ifdef BEHAVIOUR_CATCH_PILLAR_AVAILABLE

     #include <math.h>
    +#include <stdlib.h>

    -#define START 0
    -#define SEARCH_LEFT 1
    -#define LEFT_FOUND 2
    -#define TURN_MIDDLE 3
    -#define GO 4
    +// Zustaende fuer das Einfangen einer Dose
    +#define START          0
    +#define SEARCH_LEFT    1
    +#define LEFT_FOUND     2
    +#define TURN_MIDDLE    3
    +#define GO             4
     #define END 99

    -// ZustÃ¤nde fÃ¼r das Ausladeverhalten START und END sind bereits weiter oben definiert
    -#define GO_BACK 1
    -#define CLOSE_DOOR 2
    +// Zustaende fÃ¼r das Ausladeverhalten START und END sind bereits weiter oben definiert
    +#define GO_BACK        1
    +#define CLOSE_DOOR     2
    +#define GO_FORWARD     3
    +#define OPEN_DOOR      4

     static uint8 catch_pillar_state=START;		/*!< Statusvariable fÃ¼r das Einfang-Verhalten */
     static uint8 unload_pillar_state=START;		/*!< Statusvariable fÃ¼r das Auslade-Verhalten */
    -static int16 startangle=0;      			/*!< gemerkter Anfangswinkel einfach als Integer */
    +
    +static int16 drive_distance;	        /*!< Zu fahrende Distanz bzw. angepeilter Stand der Radencoder sensEncL bzw. sensEncR */
    +static int8 drive_distance_curve;		/*!< Kruemmung der zu fahrenden Strecke. */
    +
    +
    +  // Sensorwerte
    +  static int16 pLeft=0;
    +  static int16 pRight=0;
    +
    +
    +static uint8 avoid_col_act=False;  // Check auf Aktivitaet zu Beginn, wird dann zwischendurch aus- und eingeschaltet
    +
    +static int16 drive_distance_target;	/*!< Zu fahrende Distanz bzw. angepeilter Stand der Radencoder sensEncL bzw. sensEncR */
    +
    +
    +static uint8 turn_done=False;   // Kennung auf bot_turn ausgefuehrt, falls Objekt unguenstig zu Sensoren steht
    +
    +#define TOL_SENS 50    // Abstandswerte muessen innerhalb dieser Toleranz liegen
    +#define ANGLE_CORR  30 // Korrekturwinkel; verwendet falls Objekt unguenstig stand zu Sensoren bzw. wann Rechtssuche ungueltig
    +
    +/*! Routine berechnet die Anzahl Encoder-Ticks, die der Wegstrecke mm entsprechen
    + *  @param mm Wegstrecke in mm
    + *  @return Anzahl der Encoder-Ticks
    + */
    +  int32 mm_to_ticks(uint16 mm) {
    +	int32 tmp = mm / 10;  // Abstand rechts ist maximale Weglaenge
    +	      tmp*= 10 * ENCODER_MARKS;
    +	      tmp /= WHEEL_PERIMETER;
    +	return tmp;
    +  }
    +
    +
     /*!
      * Fange eine Dose ein
      * @param *data der Verhaltensdatensatz
      */
     void bot_catch_pillar_behaviour(Behaviour_t *data){
    -	static uint8 cancelcheck=False;
     	static float angle;
    +	#define ANGLE_TURN_RES 4 	/*!< Aller x Grad erfolgt Check auf Ende der Drehung */

    +    // Variablen zur Winkelberechnung; benoetige hier keine Float-Aufloesung und daher Int-Genauigkeit
    +	static int16 turned;          /*!< Winkel um den bereits gedreht wurde */
    +	static int16 turned_found=0;  /*!< gemerkter schon gedrehter Winkel wenn links Objekt erkannt wurde */
    +	static int16 last_scan_angle; /*!< Winkel bei dem zuletzt gescannt wurde */
    +
    +    // maximale Strecke, die vorwaerts gelaufen wird zum Einfangen; etwas weiter als ueberhaupt gesehen wird
    +    static int16 dist_to_go = 0/*cm*/;  // wird dynamisch ermittelt aus Abstandswerten
    +
    +	static int16 marks_to_drive = 0;  /*!< nur bestimmte Strecke in Ticks wird voraus gefahren zum Einfangen */
    +	int16 *encoder;                   /*!< Zeiger auf Encoder zur Streckenberechnung */
    +
    +    pLeft=sensDistL;pRight=sensDistR; /*!< Sensorwerte zuweisen */
    +
    +    // Check auf Ende der Drehung
    +    if (catch_pillar_state!=START) {
    +
    +      int16 diff = heading - last_scan_angle;       // Drehung berechnen zu letztem Winkel
    +	  if (diff < -180) diff+=360;
    +
    +	  if (diff>= ANGLE_TURN_RES) {                  // aller x Grad Check auf Ende der Drehung
    +			  turned+= diff;
    +			  last_scan_angle=heading;              // Winkel merken
    +
    +              if (turned >= 360-ANGLE_TURN_RES)     // Ende erreicht, 360-res Grad gedreht
    +                 catch_pillar_state = END;
    +	  }
    +     }
    +
    +
     	switch (catch_pillar_state){
     		case START:
    -		       startangle=heading;
    -		       cancelcheck=False;
    -		       catch_pillar_state=SEARCH_LEFT;
    +		       // Ein paar notwendige Initialisierungen zu Beginn des Verhaltens
    +		       catch_pillar_state=SEARCH_LEFT;  // damit gehts los, Sensor links sucht Objekt
    +		       turned=0;                        // gedrehter Winkel je nach Ausloesung
    +		       turn_done=False;                 // einmalig bot_turn falls Objekt unguenstig steht
    +		       last_scan_angle=heading-ANGLE_TURN_RES;               // letzter gemerkter Winkel
    +		       avoid_col_act=behaviour_is_activated(bot_avoid_col_behaviour); // Wandausweicher an ?
    +
    +		       // Falls ich schon rechts was sehe und links nicht, dann einfach mal rechts drehen und erst dann los
    +		        if (pRight < MAX_PILLAR_DISTANCE && !turn_done && pLeft >= pRight + TOL_SENS){
    +                    	// etwas rechts drehen; aber soweit, das moeglichst der linke etwas vom Objekt rechts steht
    +                    	bot_turn(data,-ANGLE_CORR);  // 30 Grad drehen
    +                    	turn_done=True;  // Drehkennung setzen
    +                    	break;           // und es geht neu los nach Drehung mit START
    +                    }
    +
     		     break;

     		case SEARCH_LEFT:
    -		    // Nach 1x Rundumsuche und nix gefunden ist Schluss; Dazu wird der Check zum Start
    -		    // nach Ueberschreiten der 5Grad-Toleranz eingeschaltet und die Drehung dann beendet wenn
    -		    // der Winkel wieder innerhalb dieser Toleranz liegt
    -	        if (cancelcheck) {
    -	          if (fabs(heading - startangle) < 5 )
    -		        // Damit nicht endlos rundum gedreht wird Abbruch, wenn kein Gegenstand gefunden
    -		        catch_pillar_state = END;
    -	        } else {
    -	        	if (fabs(heading - startangle) >= 5)
    -	        	  cancelcheck=True;
    -	        }
    -
    -		    // linker Sensor muss was sehen, der rechte aber nicht
    -			if (sensDistL < MAX_PILLAR_DISTANCE && sensDistR > MAX_PILLAR_DISTANCE){	// sieht der linke Sensor schon was?
    -				angle=heading;
    -				catch_pillar_state=LEFT_FOUND;
    -			} else
    -				speedWishLeft=-BOT_SPEED_SLOW;
    -				speedWishRight=+BOT_SPEED_SLOW;
    -				//bot_turn(data,5);	// Ein Stueck drehen
    +            // Bot dreht sich solange, bis der linke Sensor Objekt ausmacht
    +            if (abs(pLeft-pRight)>=TOL_SENS && pLeft < MAX_PILLAR_DISTANCE && pRight >= pLeft + TOL_SENS){	// sieht der linke Sensor schon was?
    +				angle=heading;       // Winkel zum Objekt merken
    +				turned_found=turned; // bereits gedrehten Winkel merken
    +				catch_pillar_state=LEFT_FOUND;  // weiter mit naechstem Zustand
    +				speedWishLeft	 = speed_l;     // weiterdrehen mit akuellem Speed
    +	            speedWishRight   = speed_r;
    +				break;
    +               }
    +
    +			   // sehe ich innerhalb der ersten 20 gedrehten Grad schon rechts was -Objekt mittig zwischen Sensoren-, dann
    +			 	// etwas rechts drehen und Verhalten neu beginnen
    +			   if (abs(pLeft-pRight)>=TOL_SENS && turned<20 && !turn_done && pRight < MAX_PILLAR_DISTANCE){
    +			   	// etwas rechts drehen; aber soweit, das moeglichst der linke etwas vom Objekt rechts steht
    +                    	bot_turn(data,-ANGLE_CORR);  // 30 Grad drehen
    +                    	turn_done=True;  // Drehkennung setzen
    +                    	catch_pillar_state=START;
    +                    	break;
    +			   }
    +              // links drehen
    +			  speedWishLeft=-BOT_SPEED_SLOW; speedWishRight=+BOT_SPEED_SLOW;
    +
     			break;
    -
    +
    +
     		case LEFT_FOUND:
    -		    // links und rechts darf nicht gleichzeitig was gesehen werden, sonst weiter mit drehen
    -			if (sensDistL < MAX_PILLAR_DISTANCE && sensDistR < MAX_PILLAR_DISTANCE){
    -		    	catch_pillar_state=SEARCH_LEFT;
    -		    	break;
    -		    }
    -
    -			if (sensDistR < MAX_PILLAR_DISTANCE){	// sieht der rechte Sensor schon was?
    +		    // Sensor links hat bereits Objekt erkannt; Bot nun soweit drehen bis auch
    +		    // der rechte Sensor Objekt in gueltigem Abstand erkennt
    +		    if (turned-turned_found>ANGLE_CORR) {         // > 30 Grad Drehung kann kein gueltiges Objekt mehr kommen
    +		    	 catch_pillar_state=SEARCH_LEFT;
    +				 break;
    +				}
    +
    +			// rechts wird Objekt gesehen und links muss auch gueltig sein
    +			if (pRight < MAX_PILLAR_DISTANCE && pLeft >=pRight+TOL_SENS){	// sieht der rechte Sensor schon was ?
    +				// Winkel berechnen und auf Mitte zum Winkel nach Links-gefundenem setzen
     				angle= heading- angle;
     				if (angle < 0)
     					angle+=360;
     				angle= heading - angle/2;
    -				catch_pillar_state=TURN_MIDDLE;
    -//				bot_turn(data,-angle/2);
    -			} else
    -				speedWishLeft=-BOT_SPEED_SLOW;
    -				speedWishRight=+BOT_SPEED_SLOW;
    -//				bot_turn(data,5);	// Eins Stueck drehen
    +				catch_pillar_state=TURN_MIDDLE;  // naechster Verhaltenszustand
    +				turned_found=turned;             // gedrehten Winkel zu diesem Zeitpunkt merken
    +				// Abstand zum Objekt ermitteln; bis zu diesem wird nur maximal vorwaerts gelaufen zum Einfangen
    +				dist_to_go = pRight  + 40;       // in mm nach rechtem Abstandswert + in-Bauch-Abstand zu Sensoren
    +
    +				// Wegstrecke in Encoder-Ticks umrechnen
    +				marks_to_drive=mm_to_ticks(dist_to_go);
    +
    +				break;
    +			}
    +			// Links drehen
    +			speedWishLeft=-BOT_SPEED_SLOW; speedWishRight=+BOT_SPEED_SLOW;
    +
     			break;

     		case TURN_MIDDLE:
    -				if (fabs(heading - angle) > 2){
    -					speedWishLeft=+BOT_SPEED_SLOW;
    -					speedWishRight=-BOT_SPEED_SLOW;
    -				} else {
    -					bot_servo(data,SERVO1,DOOR_OPEN); // Klappe auf
    -					catch_pillar_state=GO;
    +		        // Bot wird in die Mitte des Winkel zwischen links- und rechts-gesehen positioniert
    +				// langsam rechts drehen
    +				speedWishLeft=+BOT_SPEED_SLOW; speedWishRight=-BOT_SPEED_SLOW;
    +				if (fabs(heading - angle) < 2) {  // gedreht bis Toleranz von 2 Grad erreicht sind
    +                  // Sensorabstand zum Objekt nach Erreichen des Zielwinkels muss stimmen
    +				  if (pLeft < 190  &&  pRight < 190) {  // beide < 19cm ist ungueltig
    +					  catch_pillar_state=SEARCH_LEFT;
    +				      break;
    +					}
    +
    +				  bot_servo(data,SERVO1,DOOR_OPEN); // Klappe auf zum Einfangen
    +				  catch_pillar_state=GO;            // naechster Zustand zum Vorwaertslaufen
    +
    +				  // vom aktuellen Punkt aus sind noch x Ticks zu fahren; also maximale Wegstrecke ermitteln,
    +				  // die bis zum Ziel noch zurueckzulegen ist
    +				  encoder = (int16*)&sensEncR;  // rechten Encoder einfach mal nehmen
    +				  drive_distance_target = *encoder + marks_to_drive;  // max. Zielstrecke in Ticks
    +
    +				  // falls Wandausweicher aktiv war ausschalten zu Beginn von GO
    +				  if (avoid_col_act)
    +				    deactivateBehaviour(bot_avoid_col_behaviour);
     				}
    +
     			break;

     		case GO:
    -			if (sensTrans ==0){
    -				speedWishLeft=+BOT_SPEED_SLOW;
    -				speedWishRight=+BOT_SPEED_SLOW;
    -				// nicht endlos vorwaertslaufen, weiter mit Suche bis Drehende
    -				if (sensDistL < MAX_PILLAR_DISTANCE && sensDistR < MAX_PILLAR_DISTANCE)
    -		    		catch_pillar_state=SEARCH_LEFT;
    +		    // Bot sollte hier das Objekt mittig zwischen den Sensoren "sehen"; es wird
    +		    // nun vorwaerts gefahren bis Sensor zuschlaegt oder die maximale Wegstrecke
    +		    // erreicht wurde
    +			if (sensTrans ==0){  // nichts im Bauch
    +
    +                // Sensoren duerfen  nicht beidseitig Objekt in kleinem Abstand sehen, dann
    +                // dann ist es ungueltig
    + 				if (pLeft < 190  &&  pRight < 190 ) {  // beide < 19cm
    +					  catch_pillar_state=SEARCH_LEFT;
    +					  bot_servo(data,SERVO1,DOOR_CLOSE);
    +				      break;
    +				}
    +
    +               //noch zu fahrende Weglaenge berechnen
    +				encoder = (int16*)&sensEncR;  // rechten Encoder einfach mal nehmen
    +				int16 to_drive    = drive_distance_target - *encoder; // akt. Wegstrecke von maximaler abziehen in Ticks
    +
    +	            // ist maximale Wegstrecke erreicht ohne Objekt eingefangen zu haben, dann gehts mit Neusuche weiter
    +	            if(to_drive <= 0){
    +	              bot_servo(data,SERVO1,DOOR_CLOSE);     // Klappe wieder zu
    +		          catch_pillar_state=SEARCH_LEFT;        // wieder zu search_left
    +		          break;
    +	            }
    +
    +	            // Vorwaertslaufen
    +		        speedWishLeft=BOT_SPEED_SLOW; speedWishRight=BOT_SPEED_SLOW;
    +
     			}
     			else {
    +				  // Objekt ist eingefangen und damit Verhalten zu Ende
     				  bot_servo(data,SERVO1,DOOR_CLOSE);
    -				  catch_pillar_state=END;
    +				  catch_pillar_state=END;
     			 }

     			break;

    +
     		default:
    -			catch_pillar_state=START;
    +			if (avoid_col_act) // wieder Wandausweicher aktivieren falls zu Beginn angeschaltet war
    +			  activateBehaviour(bot_avoid_col_behaviour);
     			return_from_behaviour(data);
     			break;
     	}
    @@ -149,26 +283,41 @@
     /*!
      * Gibt die Dose wieder aus, Entladevorgang
      * @param *data der Verhaltensdatensatz
    - */
    + */
     void bot_unload_pillar_behaviour(Behaviour_t *data){

     	switch (unload_pillar_state){
     		case START:
                  if (sensTrans ==1){  // ist was im Bauch gehts los
    -             	unload_pillar_state=GO_BACK;
    -             	// ist was drin, dann Klappe auf und danach Rueckwaerts
    -             	bot_servo(data,SERVO1,DOOR_OPEN); // Klappe auf
    -             } else	// nix zu tun
    +             	unload_pillar_state= (drive_distance==0)? OPEN_DOOR: GO_FORWARD;
    +             } else	{// nix zu tun
                  	unload_pillar_state=END;
    +             }
     			break;
    +
    +	    case GO_FORWARD:
    +	          if (sensDistL>OPTIMAL_DISTANCE && sensDistR>OPTIMAL_DISTANCE)
    +                bot_drive_distance(data,drive_distance_curve,BOT_SPEED_FOLLOW,drive_distance);//Vorwaerts
    +              unload_pillar_state=OPEN_DOOR;
    +            break;
    +
    +        case OPEN_DOOR:
    +		     bot_servo(data,SERVO1,DOOR_OPEN);
    +		     unload_pillar_state=GO_BACK;
    +		    break;
    +
             case GO_BACK:
    -              bot_drive_distance(data,0,-BOT_SPEED_FOLLOW,10);// 10cm rueckwaerts nur bei Hindernis
    +              if (drive_distance==0)
    +                drive_distance=OPTIMAL_DISTANCE/10;
    +              bot_drive_distance(data,drive_distance_curve,-BOT_SPEED_FOLLOW,drive_distance);// 10cm rueckwaerts nur bei Hindernis
                   unload_pillar_state=CLOSE_DOOR;
                 break;
    +
     		case CLOSE_DOOR:
     		     bot_servo(data,SERVO1,DOOR_CLOSE);
     		     unload_pillar_state=END;
     		    break;
    +
     		default:
     			unload_pillar_state=START;// bei Umschaltung via Verhaltensscreen ist dies notwendig
     			return_from_behaviour(data);
    @@ -178,16 +327,27 @@

    -
    -
     /*!
      * Entlaedt das Objekt wieder
      * @param caller Der obligatorische Verhaltensdatensatz des Aufrufers
      */
     void bot_unload_pillar(Behaviour_t * caller){
    +	bot_unload_pillar_distance(caller,0,0);  // nicht vorwaerts fahren, in einer Geraden zurueck
    +}
    +
    +/*!
    + * Entlaedt das Objekt in einem bestimmten Abstand voraus, wobei auf einem Kreisbogen
    + * analog bot_drive_distance gefahren wird
    + * @param caller Der obligatorische Verhaltensdatensatz des Aufrufers
    + * @param curve		Gibt an, ob der Bot eine Kurve fahren soll. Werte von -127 (So scharf wie moeglich links) ueber 0 (gerade aus) bis 127 (so scharf wie moeglich rechts)
    + * @param speed		Gibt an, wie schnell der Bot fahren soll. Negative Werte lassen den Bot rueckwaerts fahren.
    + */
    +void bot_unload_pillar_distance(Behaviour_t * caller,int8 curve, int16 cm){
     	unload_pillar_state=START;
     	catch_pillar_state=END;		// Sicherheitshalber das catch-Verhalten auf Ende setzen
    -	// Zielwerte speichern
    +	drive_distance_curve = curve;
    +	drive_distance = cm;
    +
     	switch_to_behaviour(caller,bot_unload_pillar_behaviour,OVERRIDE);
     }

    Index: C:/eclipse/workspace/ct-Bot/include/bot-logic/behaviour_catch_pillar.h
    ===================================================================
    --- C:/eclipse/workspace/ct-Bot/include/bot-logic/behaviour_catch_pillar.h	(revision 1278)
    +++ C:/eclipse/workspace/ct-Bot/include/bot-logic/behaviour_catch_pillar.h	(working copy)
    @@ -59,6 +59,15 @@
      */
     void bot_unload_pillar(Behaviour_t * caller);

    +/*!
    + * Entlaedt das Objekt in einem bestimmten Abstand voraus, wobei auf einem Kreisbogen
    + * analog bot_drive_distance gefahren wird
    + * @param caller Der obligatorische Verhaltensdatensatz des Aufrufers
    + * @param curve		Gibt an, ob der Bot eine Kurve fahren soll. Werte von -127 (So scharf wie moeglich links) ueber 0 (gerade aus) bis 127 (so scharf wie moeglich rechts)
    + * @param speed		Gibt an, wie schnell der Bot fahren soll. Negative Werte lassen den Bot rueckwaerts fahren.
    + */
    +void bot_unload_pillar_distance(Behaviour_t * caller,int8 curve, int16 cm);
    +
     #endif

     #endif /*BEHAVIOUR_CATCH_PILLAR_H_*/
    Index: C:/eclipse/workspace/ct-Bot/include/bot-logic/available_behaviours.h
    ===================================================================
    --- C:/eclipse/workspace/ct-Bot/include/bot-logic/available_behaviours.h	(revision 1278)
    +++ C:/eclipse/workspace/ct-Bot/include/bot-logic/available_behaviours.h	(working copy)
    @@ -34,7 +34,7 @@

     //#define BEHAVIOUR_OLYMPIC_AVAILABLE	/*!< Olympiadenverhalten vorhanden ?*/

    -//#define BEHAVIOUR_CATCH_PILLAR_AVAILABLE /*!< Suche eine Dose und fange sie ein */
    +#define BEHAVIOUR_CATCH_PILLAR_AVAILABLE /*!< Suche eine Dose und fange sie ein */

     //#define BEHAVIOUR_FOLLOW_OBJECT_AVAILABLE	/*!< verfolge ein (bewegliches) Objekt */

    Index: C:/eclipse/workspace/ct-Bot/Changelog.txt
    ===================================================================
    --- C:/eclipse/workspace/ct-Bot/Changelog.txt	(revision 1278)
    +++ C:/eclipse/workspace/ct-Bot/Changelog.txt	(working copy)
    @@ -1,5 +1,7 @@
     CHANGELOG fuer c't-Bot
     ======================
    +2007-10-03 Frank Menzel  [Menzelfr@xxxxxxx]: bot_catch_pillar grundlegend ueberarbeitet
    +
     2007-10-01 Timo Sandmann [mail@xxxxxxxxxxxxxxx]: Position der Sharps in bot-local.h korrigiert und TODO.txt aktualisiert

     2007-09-23 Timo Sandmann [mail@xxxxxxxxxxxxxxx]: Linienverfolger ueberarbeitet und an Motorregelung angepasst. Auf die vorherige Version laesst sich mit #define OLD_VERSION zurueckgreifen.
    Index: C:/eclipse/workspace/ct-Bot/.settings/org.eclipse.cdt.core.prefs
    ===================================================================
    --- C:/eclipse/workspace/ct-Bot/.settings/org.eclipse.cdt.core.prefs	(revision 0)
    +++ C:/eclipse/workspace/ct-Bot/.settings/org.eclipse.cdt.core.prefs	(revision 0)
    @@ -0,0 +1,3 @@
    +#Wed Oct 03 13:46:52 CEST 2007
    +eclipse.preferences.version=1
    +indexerId=org.eclipse.cdt.core.fastIndexer

- Referenzen:
  - AW: [ct-bot] neues catch_pillar
    - From: Frank Menzel

- Voriger (Datum): AW: [ct-bot] neues catch_pillar, Frank Menzel
- Nächster (Datum): Re: [ct-bot] neues catch_pillar, Timo Sandmann
- Voriger (Thread): AW: [ct-bot] neues catch_pillar, Frank Menzel
- Nächster (Thread): Re: [ct-bot] neues catch_pillar, Timo Sandmann
- Indizes:
  - Datum
  - Thread