heise online | · | c't | · | iX | · | Technology Review | · | Telepolis | · | mobil | · | Security | · | Netze | · | heise open | · | heise resale | · | Autos | · | c't-TV | · | Jobs | · | Kiosk

Aktuelles Heft #### Support Hotline & FAQ Tipps & Tricks Treiber & BIOS Firmenkontakte #### Download Software zu c't Software-Verzeichnis c't-Projekte Testbilder & Vorlagen #### Service Tipp-Datenbank c't-CD-Register Internettarife Telefontarife Virenschutz #### Magazin Heftarchiv c't specials English Pages Benchmarks Red. Stuff Leserforum c't-Bildmotive URLs aus c't Schlagseite #### Aktionen Browsercheck Krypto-Kampagne Schulen ans Netz Netz gegen Kinderporno TV/Radio-Termine #### Info Abo & Heft Veranstaltungen Mediadaten Kontakt Impressum Kleinanzeigen und Veranstaltungen
| c't Projekte - c't-Bot und c't-Sim - Mailinglisten ## c't-Bot und c't-Sim [Voriger (Datum)] [Nächster (Datum)] [Voriger (Thread)] [Nächster (Thread)] [Nach Datum][Nach Thread] ### AW: [ct-bot] Verhalten behaviour_goto_pos ->transport_pillar_behaviour Absender: Frank Menzel Datum: So, 11.11.2007 20:41:49 In-reply-to: <857E962D-8561-4BC1-8533-7ACBFEDA2A1C@xxxxxxxxxxxxxxx>
    Hallo,
    anbei also das transport_pillar-Verhalten mit den gewünschten
    Anpassungen eigener Screen zur Steuerung und Koordinatenanzeige sowie
    das Entfernen unbenutzter Variablen.

    Gruß, Frank

    -----Ursprüngliche Nachricht-----
    Von: ct-bot-entwickler-bounces@xxxxxxxxxxxxxxxxx
    [mailto:ct-bot-entwickler-bounces@xxxxxxxxxxxxxxxxx] Im Auftrag von Timo
    Sandmann
    Gesendet: Freitag, 9. November 2007 15:06
    An: Entwicklung rund um den c't-bot
    Betreff: Re: [ct-bot] Verhalten behaviour_goto_pos
    ->transport_pillar_behaviour

    Hallo Frank,

    machst du noch einen angepassten Patch für's SVN? :-)
    Dann haben wir neben den Basisverhalten mal wieder ein "produktives"
    Verhalten mehr im Code ;-)

    Gruß Timo

    Am 01.11.2007 um 13:01 schrieb Timo Sandmann:
    > Hallo,
    >
    > Am 31.10.2007 um 19:55 schrieb Frank Menzel:
    >> Hallo,
    >> muß jetzt grundlegend noch was angepasst werden oder kann's so in den
    >> offiziellen Code gehen ? Oder gar nicht gewollt :-?
    >
    > gewollt auf jeden Fall, ich dachte allerdings, das sei erstmal "nur"
    > eine Testversion sozusagen. ;-)
    > Auskommentierte Dinge und Variablen, die nie gelesen werden (siehe
    > andere Mail), sollten aber vorher noch rausfliegen. Außerdem finde
    > ich die Doppel-Belegung der Fernbedienungstasten unschön, denn so
    > muss man immer Verhalten ein- und ausschalten, um die Tastenbelegung
    > so zu ändern, wie man es gerade braucht. Praktisch wäre doch eine
    > Display-Anzeige, wo man gleichzeitig auch sehen kann, welche
    > Koordinaten als Be- und Entladeplatz gerade verwendet werden.
    >
    > Gruß Timo
    >
    >
    > _______________________________________________
    > 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:/botneu/ct-Bot/bot-logic/behaviour_transport_pillar.c
    ===================================================================
    --- C:/botneu/ct-Bot/bot-logic/behaviour_transport_pillar.c	(revision 0)
    +++ C:/botneu/ct-Bot/bot-logic/behaviour_transport_pillar.c	(revision 0)
    @@ -0,0 +1,565 @@
    +/*
    + * c't-Bot
    + *
    + * This program is free software; you can redistribute it
    + * and/or modify it under the terms of the GNU General
    + * Public License as published by the Free Software
    + * Foundation; either version 2 of the License, or (at your
    + * option) any later version.
    + * This program is distributed in the hope that it will be
    + * useful, but WITHOUT ANY WARRANTY; without even the implied
    + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
    + * PURPOSE. See the GNU General Public License for more details.
    + * You should have received a copy of the GNU General Public
    + * License along with this program; if not, write to the Free
    + * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
    + * MA 02111-1307, USA.
    + *
    + */
    +
    +/*! @file 	behaviour_transport_pillar.c
    + * @brief 	Bot startet von einem Farb-Startpad und entdeckt die Welt, bis er auf ein anderes
    + *          Farbpad stoesst. Er faehrt nun zwischen den beiden Farbpads hin und her, sammelt bei
    + *          Ankunft auf einem Farbpad ein in der Naehe befindliches Hindernis in sein Transportfach ein
    + *          und bringt dieses zum anderen Farbpad. Auf seinem Weg zur Abladestelle oder waehrend des
    + *          Entdeckens der Welt zur Farbpadsuche weicht er Hindernissen geschickt aus.
    + *          Es kann mittels des Wand-Explore Verhaltens nur mittels der Farbpads gefahren werden ohne sich
    + *          Koordinaten zu merken, womit er nicht unbedingt zielgerichtet von einem zum anderen Farbpad
    + *          fahren kann. Mittels Zuschalten der Verwendung der MAP-Koordinaten werden die Koords der Pads
    + *          gemerkt und sich dorthin ausgerichtet. Es kann nun mit einem Fahrverhalten zwischen beiden hin- und
    + *          hergefahren werden, wobei entweder der Wandfolger dient oder auch andere Fahrverhalten
    + *          Anwendung finden (Auswahl jeweils per Define).
    + *          Der Verhaltensstart erfolgt entweder via Remotecall oder Taste 9. Befindet sich der Bot auf einem Farbpad, so kann
    + *          via Taste 7 dieses als Zielpad definiert werden (Simfarben werden automatisch erkannt; Real ist dies schwierig, daher
    + *          manuell definierbar)
    + *          Zur Steuerung mit Tasten und der Positionsanzeigen wurde ein eigener Screen definiert
    + *
    + * @author 	Frank Menzel (menzelfr@xxxxxxx)
    + * @date 	23.10.2007
    +*/
    +#include "bot-logic/bot-logik.h"
    +#include <math.h>
    +#include "math_utils.h"
    +#include "map.h"
    +#include "display.h"
    +#include "rc5-codes.h"
    +
    +#ifdef BEHAVIOUR_TRANSPORT_PILLAR_AVAILABLE
    +
    +
    +  // auskommentieren wenn mit Farbpads und ohne Koordinaten gefahren werden soll trotz vorhandener Map
    +  // Weltkoordinaten trotzdem mitgefuehrt zum Drehen genau zur anderen Position
    +  #define USE_KOORDS
    +
    +  // zum Startbeginn explorert der Bot die Welt und erkennt damit ein bekanntes Farbpad automatisch
    +  // soll dies nicht automatisch erfolgen, dann define auskommentieren; mittels Taste 7 kann dann manuell
    +  // das Ziel-Farbpad definiert werden wenn sich der bot auf ein entsprechendes befindet
    +  // wegen den realen Schwierigkeiten mit Farben nur im Sim standardmaessig
    +  #ifdef PC
    +    #define AUTOSEARCH_PADCOL
    +  #endif
    +
    +
    +  // bei Ankunft auf Zielposition wird Klappe auf und zu gemacht; geht natuerlich nur wenn Servoverhalten an sind
    +  #ifdef BEHAVIOUR_SERVO_AVAILABLE
    +    #define SHOW_CLAPS_ON_DEST
    +  #endif
    +
    +  /* ******************************************************************
    +   * ab hier die moeglichen Fahrverhalten, ausgewaehlt je nach Define
    +   * ******************************************************************
    +   */
    +
    +  // Solve_Maze als Explorerverhalten nehmen, natuerlich nur wenn verfuegbar
    +  #ifdef BEHAVIOUR_SOLVE_MAZE_AVAILABLE
    +    //#define GO_WITH_SOLVE_MAZE
    +  #endif
    +
    +  // Fahren nach Karte wenn verfuegbar
    +  #ifdef BEHAVIOUR_MAP_GO_DESTINATION_AVAILABLE
    +   //#define GO_WITH_MAP_GO_DESTINATION    // auskommentieren wenn nicht nach Karte gefahren werden soll
    +   #undef  GO_WITH_SOLVE_MAZE          // nach Karte den Wandfolger entdefinieren
    +  #endif
    +
    +  // Fahren mittels goto_pos Verhalten
    +  #ifdef USE_KOORDS   // geht nur mit Koordinaten selbst, nicht mit Fahren  nach Farbe
    +   #ifdef BEHAVIOUR_GOTO_POS_AVAILABLE
    +     #define   GO_WITH_GOTO_POS    // auskommentieren wenn nicht mit Goto_pos Verhalten gefahren werden soll
    +     #undef  GO_WITH_SOLVE_MAZE          // nach Karte den Wandfolger entdefinieren
    +     #undef  GO_WITH_MAP_GO_DESTINATION
    +   #endif
    +  #endif
    +
    +  //trotz aktiviertem Pillarverhalten nur Hin- und Herfahren ohne Dosen einzufangen
    +  //#define NO_PILLAR_BEHAVIOUR
    +
    +  // zusaetzlich zu den Liniensensoren muessen die Farben laut Abgrundsensoren passen; damit sollten
    +  // beim Realbot Fehlausloesungen vermieden beim Fahren nach Farbe
    +  //#define CHECK_BORDERSENS_FOR_COL
    +
    +static uint8 state=0;
    +
    +
    +  // Weltkoordinaten zum Speichern der Start- und Zielposition, zwischen denen Hin- und Hergefahren wird
    +  static float startpad_x=0;
    +  static float startpad_y=0;
    +  static float destpad_x=0;
    +  static float destpad_y=0;
    +
    +  static float target_x=0;	/*!< Zwischenzielkoordinaten X des xy-Fahrverhaltens */
    +  static float target_y=0;	/*!< Zwischenzielkoordinaten Y des xy-Fahrverhaltens */
    +
    +
    +/*!
    + * Check, ob die Koordinate xy innerhalb eines Radius-Umkreises befindet; verwendet um das
    + * Zielfahren mit gewisser Toleranz zu versehen
    + * @param x x-Ordinate
    + * @param y y-Ordinate
    + * @param destx Ziel-x-Ordinate
    + * @param desty Ziel-y-Ordinate
    + * @return True wenn xy im Umkreis liegt6
    + */
    +#ifdef USE_KOORDS
    +  uint8 koord_in_circle_world (float x, float y, float destx, float desty) {
    +		//Punktdifferenzen
    +		float distx=destx-x;
    +		float disty=desty-y;
    +		uint16 radquad=0;   // Vergleichs-Radiusabstand im Quadrat
    +
    +		// bin ich auf Linie, kann Genauigkeit hoeher sein
    +		radquad=8100;
    +
    +		// Fahre ich gerade mit Linienfolger, dann Umkreis kleiner
    +		#ifdef BEHAVIOUR_FOLLOW_LINE_AVAILABLE
    +		  if (behaviour_is_activated(bot_follow_line_behaviour))
    +		    radquad=900;   // 3cm Umkreis
    +		#endif
    +
    +		// Ist Abstand im Radiusabstand, dann ist der Punkt innerhalb des Umkreises
    +		// gerechnet mit Quadratzahlen, sparen der Wurzel
    +		return (distx*distx + disty*disty) < radquad; // 9cm Umkreis des Bots
    +
    +  }
    +#else
    +  //hier wird immer die Farbe des Zielpads eingetragen, welche es zu erreichen gilt
    +  static uint16 destpad_value=0;
    +
    +  // Farbe der Abgrundsensoren; im Sim identisch der Liniensensoren
    +  #ifdef CHECK_BORDERSENS_FOR_COL
    +    static uint16 destpad_bvalue=0;
    +  #endif
    +
    +#endif
    +
    +  //Startpad1 wird mit Farbe bei Start belegt und Startpad2 fuer das andere Pad
    +  static uint16 STARTPAD_COL1=0;
    +  static uint16 STARTPAD_COL2=0;  // weiss geht somit nicht
    +
    +  static uint8 key_pressed=0;     // Kennung ob Taste gedrueckt fuer man. Zielvorgabe
    +
    +  //real haben die Bordersensoren andere Werte als die Liniensensoren, daher hier mitfuehren
    +  #ifdef CHECK_BORDERSENS_FOR_COL
    +    static uint16 STARTPAD_BCOL1=0;
    +    static uint16 STARTPAD_BCOL2=0;  // weiss geht somit nicht
    +  #endif
    +
    +  // Farbe des selbst definierbaren Zielpads; wird zusaetzlich zu den bekannten Standardfarben gecheckt wenn <> 0
    +  static uint16 PAD_MYCOL=0;
    +
    +  //kurze Wartezeit wenn bot auf Zielposition
    +  #define DELAY_ROLLTIME  800
    +
    +
    +
    +
    +/* Liefert True wenn sich Bot auf Pad mit dem Wert value_pad befindet
    + * @param value_pad   zu checkender Farbwert der Liniensensoren
    + * @param value_bpad  zu checkender farbwert der Bordersensoren
    + */
    +uint8 check_pad(uint16 value_pad,uint16 value_bpad) {
    +	#define COL_TOL 5
    +
    +	// beide Liniensensoren muessen auf der Zielfarbe sein oder nur einer, wenn der andere dafuer Linie erkennt
    +	uint8 ret = (sensLineL>=value_pad-COL_TOL && sensLineL<=value_pad+COL_TOL &&
    +	       sensLineR>=value_pad-COL_TOL && sensLineR<=value_pad+COL_TOL);
    +
    +	if (!ret)
    +	  ret= (sensLineL>=value_pad-COL_TOL && sensLineL<=value_pad+COL_TOL && sensLineR >= LINE_SENSE) ||
    +	       (sensLineR>=value_pad-COL_TOL && sensLineR<=value_pad+COL_TOL && sensLineL >= LINE_SENSE);
    +
    +	if (ret) {
    +       #ifdef CHECK_BORDERSENS_FOR_COL
    +	    // Bordersensoren nur auswerten wenn das Zielpad schon gefunden wurde
    +	    if (STARTPAD_COL2>0) {
    +	      ret = ((sensBorderL>=value_bpad-COL_TOL && sensBorderL<=value_bpad+COL_TOL) ||
    +	        (sensBorderR>=value_bpad-COL_TOL && sensBorderR<=value_bpad+COL_TOL));
    +	    }
    +	  #endif
    +
    +	  }
    +	return ret;
    +}
    +
    +/* Abbruchbedingung des Explorers wenn bereits Start- und Ziel(pad)koordinaten festgelegt sind
    + * und er sich immer von einer zur anderen bewegt; wurde die Zielkoord per Hand festgelegt, so
    + * gibt es keine Padfelder rot/ gruen und es muss beendet werden wenn sich der bot diesen Koords
    + * annaehert
    + * true wenn sich bot auf einem Startfeld befindet
    + */
    +uint8 bot_on_pad(void) {
    +  // es gilt: es sind immer die anderen Koords zu checken, wo ich mich nicht im Umkreis befinde oder fuer
    +  // Farbpads: immer den anderen checken wo ich gerade nicht drauf bin, solange laeuft der Explorer
    +    if (STARTPAD_COL2==0) {
    +    	// noch kein Ziel definiert bzw. gefunden; mit bekannten Farb-Pad-Werten auf Linien-Sensorebene
    +    	// vergleichen; Bordersensoren egal
    +    	return  (check_pad(STARTPAD1,0)||check_pad(STARTPAD2,0)||check_pad(GROUND_GOAL,0)||
    +    	          (PAD_MYCOL>0 && check_pad(PAD_MYCOL,0)))? True : False;
    +
    +    }
    +    else
    +    {   // Zielpad/- koordinaten hier bereits festgelegt
    +		// Wenn Umkreispunkt erreicht in Weltkoordinaten Schluss bei Koordinatenverwendung
    +		#ifdef USE_KOORDS
    +		  return koord_in_circle_world(x_pos,y_pos,target_x,target_y)?True:False;
    +		#else
    +		  // finden keine Koordinaten Verwendung, dann nur nach Farbpads fahren
    +		  #ifdef CHECK_BORDERSENS_FOR_COL
    +		    return check_pad(destpad_value,destpad_bvalue)?True:False;
    +		  #else
    +		    return check_pad(destpad_value,0)?True:False;
    +		  #endif
    +		#endif
    +    }
    +}
    +
    +
    +
    +
    +/* Start-Abbruchbedingung des Explorer Verhaltens zur Suche nach dem Ziel-Farbpad; dieses laeuft solange,
    + * bis der Explorer ueber ein anderes bekanntes Farbfeld faehrt oder per Taste das Farbpad definiert wurde
    + */
    + uint8 destpad_found(void) {
    +
    +
    +   #ifdef AUTOSEARCH_PADCOL  // automatische Suche eingeschaltet
    +  	// Check ob Bot auf einem bekannten Farbpad rot/blau/gruen oder Linienfarbe steht,
    + 	// welche nicht der Farbe zum Startzeitpunkt entspricht
    + 	if (bot_on_pad() && !check_pad(STARTPAD_COL1,0)) {
    +		  STARTPAD_COL2   = sensLineL; // einfach mal linken genommen
    +		  #ifdef CHECK_BORDERSENS_FOR_COL
    +		    STARTPAD_BCOL2 = (sensBorderL + sensBorderR) / 2;  // Mittelwert beider Abgrundsensoren
    +		  #endif
    +		  #ifndef USE_KOORDS
    +		    destpad_value=STARTPAD_COL2;
    +		    #ifdef CHECK_BORDERSENS_FOR_COL
    +		      destpad_bvalue = STARTPAD_BCOL2;
    +		    #endif
    +		  #endif
    +		 // Weltkoordinaten speichern fuer Drehung genau zu diesen Koordinaten
    +		  destpad_x=x_pos;destpad_y=y_pos;
    +
    +		  return True;
    +  	}
    +  	#endif
    + 	return False;  // nicht auf einem Startpadfield
    + }
    +
    +
    +/* Endebedingung des Explorerverhaltens
    + * @return True wenn Endebedingung erfuellt
    + */
    +uint8 check_end_exploring(void) {
    +	if (key_pressed) {
    +		key_pressed=0;
    +		return True;
    +	}
    +	return (STARTPAD_COL2==0) ? destpad_found():bot_on_pad();
    +}
    +
    +
    +
    +
    +void bot_transport_pillar_behaviour(Behaviour_t *data){
    +#define BOT_CHECK_STARTPAD 0
    +#define BOT_EXPLORE        1
    +#define INITIAL_TURN       2
    +#define GOTO_NEXTPAD       3
    +//#define EXPL_LINE          4
    +#define BOT_ON_PAD         5
    +#define GET_PILLAR         6
    +#define UNLOAD_PILLAR      7
    +#define BOT_ROLL           8
    +#define CHECK_LINE_FOLLOW  9
    +#define UNLOAD             10
    +
    +
    +	switch (state){
    +
    +		case BOT_CHECK_STARTPAD:
    +		    // Startkoords und Startpad setzen
    +		    state=BOT_EXPLORE;
    +
    +		    // Start-Farbpad belegen mit Farbwert
    +		      STARTPAD_COL1 = sensLineL;  // linken nehmen
    +		      #ifdef CHECK_BORDERSENS_FOR_COL
    +		        STARTPAD_BCOL1 = (sensBorderL + sensBorderR) / 2;  // Mittelwert beider Abgrundsensoren
    +		      #endif
    +		      // Start-Weltkoordinaten speichern
    +		      startpad_x=x_pos;startpad_y=y_pos;
    +			break;
    +
    +		case BOT_EXPLORE:
    +		    // Solange exploren bis anderes bekanntes Farbpad gruen oder rot gefunden oder Zielkoords/Pad
    +		    // manuell gesetzt wurde;
    +		    // wird bot zu Beginn bei Koordinatenverwendung auf Linie gesetzt, dann geht follow_line los
    +
    +		    state = BOT_ROLL;  // Pad gefunden oder waehrend der Fahrt Taste 7 -> ausrollen lassen
    +		     #ifdef BEHAVIOUR_FOLLOW_LINE_AVAILABLE
    +		     #ifdef USE_KOORDS
    +			  if (sensLineL >= LINE_SENSE || sensLineR >= LINE_SENSE) {
    +			  	#ifdef BEHAVIOUR_AVOID_BORDER_AVAILABLE
    +		              deactivateBehaviour(bot_avoid_border_behaviour);
    +	            #endif
    +
    +			    // Linienfolger uebernimmt
    +			    bot_follow_line(data);
    +
    +			    // Linienfolger deaktivieren, wenn bot im Zielbereich angekommen ist, welcher ja dann manuell
    +			    // fuer die Zielkoordinaten definiert werden muss
    +		        // das cancel-Verhalten laeuft als Paralelverhalten; sobald Linienfolger beendet ist,
    +		        // wird dieses auch beendet
    +		        bot_cancel_behaviour(data, bot_follow_line_behaviour, check_end_exploring);
    +
    +			    break;
    +			   }
    +			 #endif  // nach koordinaten fahren
    +			 #endif  // Linienfolger ueberhaupt an
    +
    +			#ifdef GO_WITH_SOLVE_MAZE
    +			  bot_solve_maze(data);
    +			  // Abbruchverhalten starten und aktiv belassen trotz Inaktivitaet des Explorerverhaltens
    +			  bot_cancel_behaviour(data, bot_solve_maze_behaviour, check_end_exploring);
    +
    +			#else
    +			  #ifdef GO_WITH_MAP_GO_DESTINATION
    +			    // nach Karte kann ich nur fahren, wenn auch Zielpad schon bekannt ist sonst follow_wall
    +			    if (STARTPAD_COL2==0) {
    +			         bot_follow_wall(data,check_end_exploring);
    +			    }
    +			    else
    +			    {
    +			      bot_gotodest_map(data);
    +			    }
    +			  #else
    +			    #ifdef BEHAVIOUR_GOTO_POS_AVAILABLE
    +
    +			      // nach Karte kann ich nur fahren, wenn auch Zielpad schon bekannt ist sonst follow_wall
    +			      if (STARTPAD_COL2==0) {
    +			         bot_follow_wall(data,check_end_exploring);
    +			      }
    +			      else
    +			      {
    +			      bot_goto_pos(data,target_x,target_y,999);
    +			      }
    +			    #else
    +			      // hier koennte man noch andere Explorerverhalten einbinden und verwenden
    +			      bot_follow_wall(data,check_end_exploring);
    +			    #endif
    +			  #endif
    +
    +			#endif
    +
    +			break;
    +
    +        case BOT_ROLL:
    +             deactivateBehaviour(bot_cancel_behaviour_behaviour); // deaktivieren falls noch aktiv
    +             // Bot erst mal ausrollen lassen
    +             #ifndef SHOW_CLAPS_ON_DEST
    +               // nicht warten wenn kurz Klappe auf und zu geht; ist bereits genug Verzoegerung
    +               bot_delay(data, DELAY_ROLLTIME);	// kurzzeitig nix tun
    +             #endif
    +             state = BOT_ON_PAD;
    +             break;
    +
    +        case BOT_ON_PAD:
    +              // hier wird entschieden, ob ich ein Objekt suchen muss zum mitnehmen oder wenn ich was im
    +              // Bauch habe, muss dieses entladen werden
    +              state= (sensTrans==0) ? GET_PILLAR: UNLOAD_PILLAR;
    +
    +           #ifdef SHOW_CLAPS_ON_DEST
    +            if (state==GET_PILLAR) {
    +             bot_servo(data,SERVO1,DOOR_OPEN); // Klappe auf
    +            }
    +           #endif
    +
    +           break;
    +
    +        case GET_PILLAR:
    +           // bin jetzt auf dem Zielpad/ Koords angekommen und starte das Pillarverhalten falls es was zu holen gibt
    +           #ifdef BEHAVIOUR_CATCH_PILLAR_AVAILABLE
    +            #ifndef NO_PILLAR_BEHAVIOUR  // darf nicht explizit augeschaltet sein
    +             bot_catch_pillar(data);
    +            #endif
    +           #endif
    +
    +
    +           state=GOTO_NEXTPAD;
    +           break;
    +
    +       case UNLOAD_PILLAR:
    +           // bin jetzt auf dem Zielpad/ Koords angekommen und starte das Pillar-Unload-Verhalten,
    +           // da ich ja was im Bauch habe
    +           state=GOTO_NEXTPAD;
    +           // evtl. noch etwas vorwaerts fahren, damit Objekt etwas weiter vorn abgestellt wird
    +           // sonst dreht sich bot spaeter schon vorher weg
    +           #ifdef BEHAVIOUR_CATCH_PILLAR_AVAILABLE
    +            #ifndef NO_PILLAR_BEHAVIOUR  // darf nicht explizit ausgeschaltet sein
    +             bot_drive_distance(data,-50,BOT_SPEED_FOLLOW,OPTIMAL_DISTANCE/10);
    +             state=UNLOAD;
    +            #endif
    +           #endif
    +
    +           break;
    +
    +        #ifdef BEHAVIOUR_CATCH_PILLAR_AVAILABLE
    +         #ifndef NO_PILLAR_BEHAVIOUR
    +          case UNLOAD:
    +            state=GOTO_NEXTPAD;
    +            bot_unload_pillar(data);
    +            break;
    +         #endif
    +        #endif
    +
    +		case GOTO_NEXTPAD:
    +		    // hier werden wechselseitig das andere Zielpad/ Koords gesetzt
    + 		   if (target_x==startpad_x && target_y==startpad_y) {
    +			  target_x=destpad_x;target_y=destpad_y;
    + 		    }
    +		    else {
    +			  target_x=startpad_x;target_y=startpad_y;
    +		    }
    +
    +            #ifdef GO_WITH_MAP_GO_DESTINATION
    +              bot_set_destination(map_world_to_map(target_x),map_world_to_map(target_y));
    +            #endif
    +
    +		      // bei fahren nach Farbpads die Zielpadfarbe wechseln; nur ausgewertet, wenn auch nicht
    +		      // nach Koords gefahren wird
    +		      #ifndef USE_KOORDS
    +		        // zuerst fuer Abgrundsensoren
    +		        #ifdef CHECK_BORDERSENS_FOR_COL
    +		          destpad_bvalue= (destpad_value==STARTPAD_COL1)? STARTPAD_BCOL2: STARTPAD_BCOL1;
    +		        #endif
    +		        destpad_value= (destpad_value==STARTPAD_COL1)? STARTPAD_COL2: STARTPAD_COL1;
    +		      #endif
    +			state=INITIAL_TURN;
    +
    +            #ifdef SHOW_CLAPS_ON_DEST
    +              bot_servo(data,SERVO1,DOOR_CLOSE); // Klappe zu
    +            #endif
    +
    +			break;
    +
    +		case INITIAL_TURN:
    +		     // Drehung genau in Richtung Zielkoordinaten, auch wenn ich gerade von einer Wand komme und damit nicht
    +		     // aus der Zielrichtung; Koordinaten auch benutzt beim Fahren nach Farben
    +		     bot_turn(data,calc_angle_diff(target_x-x_pos,target_y-y_pos));
    +		     state = BOT_EXPLORE;
    +
    +			break;
    +
    +		default:
    +			return_from_behaviour(data);
    +			break;
    +	}
    +}
    +
    +
    +/*!
    + * Ruft das Pillarverhalten auf
    + * @param caller	Der obligatorische Verhaltensdatensatz des Aufrufers
    + */
    +void bot_transport_pillar(Behaviour_t * caller){
    +
    +	state=0;
    +
    +	startpad_x=0;startpad_y=0;
    +	destpad_x=0;destpad_y=0;
    +	target_x=-1;target_y=-1;// nicht 0, weil bei 0 auch Startpos losgeht
    +
    +	STARTPAD_COL1=0;STARTPAD_COL2=0;
    +	#ifdef CHECK_BORDERSENS_FOR_COL
    +	  STARTPAD_BCOL1=0;STARTPAD_BCOL2=0;
    +	#endif
    +	switch_to_behaviour(caller,bot_transport_pillar_behaviour,OVERRIDE);
    +}
    +
    +/*!
    + * Routine zum Setzen der Zielkoordinaten auf der Zielposition/ Zielpad
    + * @param x X-World-Zielkoordinate
    + * @param y Y-World-Zielkoordinate
    + */
    +
    +void bot_set_destkoords(float x, float y) {
    +
    +  // Farbe zum Zeitpunkt des Tastendruckes wird als Zielfarbe definiert
    +  // Weiss -wohl nur so im Sim so moeglich- bekommt 1, Hauptsache ungleich 0
    +  // Wess kann nur manuell als Zielfarbe gesetzt werden
    +    STARTPAD_COL2 = sensLineL>0 ? sensLineL : 1;
    +    key_pressed=True;
    +
    +    #ifdef CHECK_BORDERSENS_FOR_COL
    +      STARTPAD_BCOL2 = (sensBorderL + sensBorderR) / 2;  // Mittelwert beider Abgrundsensoren
    +    #endif
    +
    +
    +    // Weltkoordinaten speichern; diese werden nur verwendet
    +    // um sich auf diese bei Drehung auf Farbpad ausrichten zu koennen
    +    if (x==0 && y==0) {
    +	    destpad_x=x_pos;
    +	    destpad_y=y_pos;
    +	}
    +	else
    +	  {// Koordinaten setzen auf Uebergabekoordinaten
    +       destpad_x=x;
    +       destpad_y=y;
    +	  }
    +}
    +
    +#ifdef DISPLAY_TRANSPORT_PILLAR
    +
    +	static void trpill_disp_key_handler(void) {
    +		/* Keyhandling fuer Transport_Pillar-Verhalten */
    +		switch (RC5_Code) {
    +
    +			case RC5_CODE_7:
    +				// akt. Position als Ziel festlegen
    +				RC5_Code = 0;
    +	            bot_set_destkoords(x_pos,y_pos);
    +				break;
    +			case RC5_CODE_9:
    +				// Start des Verhaltens
    +				RC5_Code = 0;
    +				bot_transport_pillar(NULL);
    +				break;
    +		}	// switch
    +	}  // Ende Keyhandler
    +
    +	/*!
    +	 * @brief	Display zum Start der Transport_Pillar-Routinen
    +	 */
    +	void transportpillar_display(void) {
    +		display_cursor(1,1);
    +		display_printf("S-Z %1.0f %1.0f %1.0f %1.0f",startpad_x,startpad_y,destpad_x,destpad_y);
    +		display_cursor(2,1);
    +		display_printf("akt.Ziel: %1.0f %1.0f",target_x,target_y);
    +		display_cursor(3,1);
    +		display_printf("akt.Pos: %1.0f %1.0f",target_x,target_y);
    +		display_cursor(4,1);
    +		display_printf("Go: 9/SetPos: 7");
    +
    +		trpill_disp_key_handler();		  // aufrufen des Key-Handlers
    +	}
    +#endif	// DISPLAY_TRANSPORT_PILLAR
    +
    +#endif
    Index: C:/botneu/ct-Bot/bot-logic/bot-logik.c
    ===================================================================
    --- C:/botneu/ct-Bot/bot-logic/bot-logik.c	(revision 1304)
    +++ C:/botneu/ct-Bot/bot-logic/bot-logik.c	(working copy)
    @@ -1,34 +1,34 @@
     /*
      * c't-Bot
    - *
    + *
      * This program is free software; you can redistribute it
      * and/or modify it under the terms of the GNU General
      * Public License as published by the Free Software
      * Foundation; either version 2 of the License, or (at your
    - * option) any later version.
    - * This program is distributed in the hope that it will be
    + * option) any later version.
    + * This program is distributed in the hope that it will be
      * useful, but WITHOUT ANY WARRANTY; without even the implied
    - * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
    + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
      * PURPOSE. See the GNU General Public License for more details.
    - * You should have received a copy of the GNU General Public
    - * License along with this program; if not, write to the Free
    + * You should have received a copy of the GNU General Public
    + * License along with this program; if not, write to the Free
      * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
      * MA 02111-1307, USA.
    - *
    + *
      */

    -/*!
    +/*!
      * @file 	bot-logik.c
      * @brief 	High-Level Routinen fuer die Steuerung des c't-Bots.
    - * Diese Datei sollte der Einstiegspunkt fuer eigene Experimente sein,
    + * Diese Datei sollte der Einstiegspunkt fuer eigene Experimente sein,
      * den Roboter zu steuern.
    - *
    - * bot_behave() arbeitet eine Liste von Verhalten ab.
    + *
    + * bot_behave() arbeitet eine Liste von Verhalten ab.
      * Jedes Verhalten kann entweder absolute Werte setzen, dann kommen niedrigerpriorisierte nicht mehr dran.
      * Alternativ dazu kann es Modifikatoren aufstellen, die bei niedriger priorisierten angewendet werden.
      * bot_behave_init() baut diese Liste auf.
      * Jede Verhaltensfunktion bekommt einen Verhaltensdatensatz uebergeben, in den Sie ihre Daten eintraegt
    - *
    + *
      * @author 	Benjamin Benz (bbe@xxxxxxxx)
      * @author 	Christoph Grimmer (c.grimmer@xxxxxxxxxx)
      * @date 	01.12.05
    @@ -76,7 +76,7 @@
     /*! hier liegen die Zeiger auf die auszufuehrenden Abgrund Notfall-Funktionen */
     static void (* emerg_functions[MAX_PROCS])(void) = {NULL};

    -/*!
    +/*!
      * Routine zum Registrieren einer Notfallfunktion, die beim Ausloesen eines Abgrundsensors
      * aufgerufen wird; hierdurch kann ein Verhalten vom Abgrund benachrichtigt werden und
      * entsprechend dem Verhalten reagieren
    @@ -90,9 +90,9 @@
     	return proc_nr;
     }

    -/*!
    - * Beim Ausloesen eines Abgrundes wird diese Routine am Ende des Notfall-Abgrundverhaltens angesprungen
    - * und ruft alle registrierten Prozeduren der Reihe nach auf
    +/*!
    + * Beim Ausloesen eines Abgrundes wird diese Routine am Ende des Notfall-Abgrundverhaltens angesprungen
    + * und ruft alle registrierten Prozeduren der Reihe nach auf
      */
     void start_registered_emergency_procs(void) {
     	uint8_t i=0;
    @@ -101,8 +101,8 @@
     	}
     }

    -/*!
    - * Das einfachste Grundverhalten
    +/*!
    + * Das einfachste Grundverhalten
      * @param *data der Verhaltensdatensatz
      */
     void bot_base_behaviour(Behaviour_t *data){
    @@ -136,13 +136,13 @@
     	// Hoechste Prioritate haben die Notfall Verhalten

     	// Verhalten zum Schutz des Bots, hohe Prioritaet, Aktiv
    -	#ifdef BEHAVIOUR_AVOID_BORDER_AVAILABLE
    +	#ifdef BEHAVIOUR_AVOID_BORDER_AVAILABLE
     		insert_behaviour_to_list(&behaviour, new_behaviour(250, bot_avoid_border_behaviour,ACTIVE));
     	#endif
    -	#ifdef BEHAVIOUR_AVOID_COL_AVAILABLE
    +	#ifdef BEHAVIOUR_AVOID_COL_AVAILABLE
     		insert_behaviour_to_list(&behaviour, new_behaviour(249, bot_avoid_col_behaviour,ACTIVE));
     	#endif
    -    #ifdef BEHAVIOUR_HANG_ON_AVAILABLE
    +    #ifdef BEHAVIOUR_HANG_ON_AVAILABLE
     		insert_behaviour_to_list(&behaviour, new_behaviour(245, bot_hang_on_behaviour,ACTIVE));
     		// Registrierung des Handlers zur Behandlung des Haengenbleibens zum Rueckwaertsfahren
      	    register_emergency_proc(&hang_on_handler);
    @@ -171,9 +171,9 @@
     		// Verhalten, das einmal die Umgebung des Bots scannt
     		insert_behaviour_to_list(&behaviour, new_behaviour(152, bot_scan_behaviour,INACTIVE));
     	#endif
    -
    +
     	// Alle Hilfsroutinen sind relativ wichtig, da sie auch von den Notverhalten her genutzt werden
    -	// Hilfsverhalten, die Befehle von Boten-Funktionen ausfuehren, erst inaktiv, werden von Boten aktiviert
    +	// Hilfsverhalten, die Befehle von Boten-Funktionen ausfuehren, erst inaktiv, werden von Boten aktiviert
     	#ifdef BEHAVIOUR_TURN_AVAILABLE
     		insert_behaviour_to_list(&behaviour, new_behaviour(150, bot_turn_behaviour,INACTIVE));
     	#endif
    @@ -193,9 +193,9 @@
     	#endif

     	#ifdef BEHAVIOUR_MEASURE_DISTANCE_AVAILABLE
    -		insert_behaviour_to_list(&behaviour, new_behaviour(145, bot_measure_distance_behaviour, INACTIVE));
    +		insert_behaviour_to_list(&behaviour, new_behaviour(145, bot_measure_distance_behaviour, INACTIVE));
     	#endif
    -
    +
         #ifdef BEHAVIOUR_MAP_GO_DESTINATION_AVAILABLE
     		// Verhalten, um laut Map zu einem bestimmten Ziel zu fahren
             insert_behaviour_to_list(&behaviour, new_behaviour(139, bot_path_bestfirst_behaviour,INACTIVE));
    @@ -217,40 +217,44 @@
     	#ifdef BEHAVIOUR_OLYMPIC_AVAILABLE
     		bot_olympic_init(52,80,INACTIVE);
     	#endif
    -
    +
     	#ifdef BEHAVIOUR_DRIVE_SQUARE_AVAILABLE
     		// Demo-Verhalten, etwas komplexer, inaktiv
     		insert_behaviour_to_list(&behaviour, new_behaviour(51, bot_drive_square_behaviour,INACTIVE));
     	#endif
    -
    +
         #ifdef BEHAVIOUR_FOLLOW_WALL_AVAILABLE
      	    // Explorer-Verhalten um einer Wand zu folgen
      	    insert_behaviour_to_list(&behaviour, new_behaviour(48, bot_follow_wall_behaviour, INACTIVE));
      	    // Registrierung zur Behandlung des Notfallverhaltens zum R ueckwaertsfahren
      	    register_emergency_proc(&border_follow_wall_handler);
     	#endif
    -
    +
     	#ifdef BEHAVIOUR_CATCH_PILLAR_AVAILABLE
      	    insert_behaviour_to_list(&behaviour, new_behaviour(44, bot_catch_pillar_behaviour,INACTIVE));
     		insert_behaviour_to_list(&behaviour, new_behaviour(43, bot_unload_pillar_behaviour,INACTIVE));
     	#endif

    +	#ifdef BEHAVIOUR_TRANSPORT_PILLAR_AVAILABLE
    +		insert_behaviour_to_list(&behaviour, new_behaviour(41, bot_transport_pillar_behaviour, INACTIVE));
    +	#endif
    +
     	#ifdef BEHAVIOUR_FOLLOW_OBJECT_AVAILABLE
     		insert_behaviour_to_list(&behaviour, new_behaviour(40, bot_follow_object_behaviour, INACTIVE));
     	#endif
    -
    +
     	#ifdef BEHAVIOUR_CALIBRATE_PID_AVAILABLE
    -		insert_behaviour_to_list(&behaviour, new_behaviour(30, bot_calibrate_pid_behaviour, INACTIVE));
    +		insert_behaviour_to_list(&behaviour, new_behaviour(30, bot_calibrate_pid_behaviour, INACTIVE));
     	#endif

     	#ifdef BEHAVIOUR_CALIBRATE_SHARPS_AVAILABLE
    -		insert_behaviour_to_list(&behaviour, new_behaviour(29, bot_calibrate_sharps_behaviour, INACTIVE));
    +		insert_behaviour_to_list(&behaviour, new_behaviour(29, bot_calibrate_sharps_behaviour, INACTIVE));
     	#endif

     	#ifdef BEHAVIOUR_TURN_TEST_AVAILABLE
     		insert_behaviour_to_list(&behaviour, new_behaviour(28, bot_turn_test_behaviour, INACTIVE));
     	#endif
    -
    +
     	// Grundverhalten, setzt aeltere FB-Befehle um, aktiv
     	insert_behaviour_to_list(&behaviour, new_behaviour(2, bot_base_behaviour, ACTIVE));

    @@ -277,8 +281,8 @@
      */
     void deactivateBehaviour(BehaviourFunc function) {
     	Behaviour_t *job;	// Zeiger auf ein Verhalten
    -
    -	// Einmal durch die Liste gehen, bis wir den gewuenschten Eintrag haben
    +
    +	// Einmal durch die Liste gehen, bis wir den gewuenschten Eintrag haben
     	for (job = behaviour; job; job = job->next) {
     		if (job->work == function) {
     			LOG_DEBUG("Verhalten %u wird deaktiviert", job->priority);
    @@ -297,7 +301,7 @@
     uint8_t behaviour_is_activated(BehaviourFunc function) {
     	Behaviour_t *job;	// Zeiger auf ein Verhalten

    -	// Einmal durch die Liste gehen, bis wir den gewuenschten Eintrag haben
    +	// Einmal durch die Liste gehen, bis wir den gewuenschten Eintrag haben
     	for (job = behaviour; job; job = job->next) {
     		if (job->work == function)
     			return job->active;
    @@ -314,9 +318,9 @@
      */
     static uint8_t isInCallHierarchy(Behaviour_t *job, BehaviourFunc function) {
     	uint8_t level = 0;
    -
    +
     	if (job == NULL) return 0;	// Liste ist leer
    -
    +
     	for (; job->caller; job=job->caller) {
     		level++;
     		if (job->caller->work == function) {
    @@ -324,23 +328,23 @@
     			return level;	// Direkter Aufrufer in Tiefe level gefunden
     		}
     	}
    -	return 0;	// function kommt in Caller-Liste von job nicht vor
    +	return 0;	// function kommt in Caller-Liste von job nicht vor
     }	// O(n), n:=|Caller-Liste|

     /*!
    - * Deaktiviert alle von diesem Verhalten aufgerufenen Verhalten.
    + * Deaktiviert alle von diesem Verhalten aufgerufenen Verhalten.
      * Das Verhalten selbst bleibt aktiv und bekommt ein SUBCANCEL in seine Datanestruktur eingetragen.
      * @param function	Die Funktion, die das Verhalten realisiert.
      */
     void deactivateCalledBehaviours(BehaviourFunc function) {
     	Behaviour_t *job;	// Zeiger auf ein Verhalten
    -
    +
     	LOG_DEBUG("Beginne mit dem Durchsuchen der Liste");
     	// Einmal durch die Liste gehen, und alle aktiven Funktionen pruefen, ob sie von dem uebergebenen Verhalten aktiviert wurden
     	uint8_t i=0;
     	Behaviour_t* beh_of_function = NULL;
     	for (job=behaviour; job; job=job->next) {	// n mal
    -		if (job->active == ACTIVE) {
    +		if (job->active == ACTIVE) {
     			i++;
     			uint8_t level = isInCallHierarchy(job, function);	// O(n)
     			LOG_DEBUG("Verhalten mit Prio = %u ist ACTIVE, Durchlauf %u", job->priority, i);
    @@ -352,8 +356,8 @@
     				Behaviour_t* tmp = job;
     				job = job->caller;	// zur naechsten Ebene
     				tmp->caller = NULL;	// Caller loeschen, damit Verhalten auch ohne OVERRIDE neu gestartet werden koennen
    -			}
    -		}
    +			}
    +		}
     		if (job->work == function) {
     			/* Verhalten von function fuer spaeter merken, wenn wir hier eh schon die ganze Liste absuchen */
     			beh_of_function = job;
    @@ -367,30 +371,30 @@
     	}
     }	// O(n^2)

    -/*!
    - * Ruft ein anderes Verhalten auf und merkt sich den Ruecksprung
    +/*!
    + * Ruft ein anderes Verhalten auf und merkt sich den Ruecksprung
      * return_from_behaviour() kehrt dann spaeter wieder zum aufrufenden Verhalten zurueck
      * @param from aufrufendes Verhalten
      * @param to aufgerufenes Verhalten
      * @param override Hier sind zwei Werte Moeglich:
    - * 		1. OVERRIDE : Das Zielverhalten to wird aktiviert, auch wenn es noch aktiv ist.
    - * 					  Das Verhalten, das es zuletzt aufgerufen hat wird dadurch automatisch
    + * 		1. OVERRIDE : Das Zielverhalten to wird aktiviert, auch wenn es noch aktiv ist.
    + * 					  Das Verhalten, das es zuletzt aufgerufen hat wird dadurch automatisch
      * 					  wieder aktiv und muss selbst sein eigenes Feld subResult auswerten, um zu pruefen, ob das
    - * 					  gewuenschte Ziel erreicht wurde, oder vorher ein Abbruch stattgefunden hat.
    + * 					  gewuenschte Ziel erreicht wurde, oder vorher ein Abbruch stattgefunden hat.
      * 		2. NOOVERRIDE : Das Zielverhalten wird nur aktiviert, wenn es gerade nichts zu tun hat.
      * 						In diesem Fall kann der Aufrufer aus seinem eigenen subResult auslesen,
      * 						ob seibem Wunsch Folge geleistet wurde.
    - */
    + */
     void switch_to_behaviour(Behaviour_t * from, void (*to)(Behaviour_t *), uint8 override ){
     	Behaviour_t *job;						// Zeiger auf ein Verhalten
    -
    -	// Einmal durch die Liste gehen, bis wir den gewuenschten Eintrag haben
    +
    +	// Einmal durch die Liste gehen, bis wir den gewuenschten Eintrag haben
     	for (job = behaviour; job; job = job->next) {
     		if (job->work == to) {
     			break;		// Abbruch der Schleife, job zeigt nun auf die Datenstruktur des Zielverhaltens
     		}
    -	}
    -
    +	}
    +
     	if (!job) {
     		/* Zielverhalten existiert gar nicht */
     		if (from) from->subResult=SUBFAIL;
    @@ -412,28 +416,28 @@
     		from->active=INACTIVE;
     		from->subResult=SUBRUNNING;
     	}
    -
    +
     	// neues Verhalten aktivieren
     	job->active=ACTIVE;
     	// Aufrufer sichern
     	job->caller =  from;
    -
    +
     	#ifdef DEBUG_BOT_LOGIC
     		if (from) {
     			LOG_DEBUG("Verhaltenscall: %d wurde von %d aufgerufen",job->priority,from->priority);
    -		} else {
    +		} else {
     			LOG_DEBUG("Verhaltenscall: %d wurde direkt aufgerufen",job->priority);
     		}
     	#endif
     }

    -/*!
    +/*!
      * @brief		Kehrt zum aufrufenden Verhalten zurueck
      * @param data 	laufendes Verhalten
    - */
    + */
     void return_from_behaviour(Behaviour_t * data){
     	data->active=INACTIVE; 				// Unterverhalten deaktivieren
    -	if (data->caller){
    +	if (data->caller){
     		data->caller->active=ACTIVE; 	// aufrufendes Verhalten aktivieren
     		data->caller->subResult=SUBSUCCESS;	// Unterverhalten war erfolgreich
     	}
    @@ -445,25 +449,25 @@
      */
     void deactivateAllBehaviours(void){
     	Behaviour_t *job;						// Zeiger auf ein Verhalten
    -	// Einmal durch die Liste gehen und (fast) alle deaktivieren, Grundverhalten nicht
    +	// Einmal durch die Liste gehen und (fast) alle deaktivieren, Grundverhalten nicht
     	for (job = behaviour; job; job = job->next) {
     		if ((job->priority >= PRIO_VISIBLE_MIN) && (job->priority <= PRIO_VISIBLE_MAX)) {
    -            // Verhalten deaktivieren
    -			job->active = INACTIVE;
    +            // Verhalten deaktivieren
    +			job->active = INACTIVE;
     			job->caller = NULL;	// Caller loeschen, damit Verhalten auch ohne OVERRIDE neu gestartet werden koennen
     		}
    -	}
    +	}
     }

    -/*!
    - * @brief	Zentrale Verhaltens-Routine, wird regelmaessig aufgerufen.
    +/*!
    + * @brief	Zentrale Verhaltens-Routine, wird regelmaessig aufgerufen.
      */
    -void bot_behave(void){
    +void bot_behave(void){
     	Behaviour_t *job;						// Zeiger auf ein Verhalten
    -
    +
     	float faktorLeft = 1.0;					// Puffer fuer Modifkatoren
     	float faktorRight = 1.0;				// Puffer fuer Modifkatoren
    -
    +
     	#ifdef RC5_AVAILABLE
     		rc5_control();						// Abfrage der IR-Fernbedienung
     	#endif
    @@ -475,15 +479,15 @@
     			/* WunschVariablen initialisieren */
     			speedWishLeft = BOT_SPEED_IGNORE;
     			speedWishRight = BOT_SPEED_IGNORE;
    -
    +
     			faktorWishLeft = 1.0;
     			faktorWishRight = 1.0;
    -
    +
     			if (job->work)	// hat das Verhalten eine Work-Routine
     				job->work(job);	/* Verhalten ausfuehren */
     			else // wenn nicht: Verhalten deaktivieren, da es nicht sinnvoll arbeiten kann
    -				job->active=INACTIVE;
    -
    +				job->active=INACTIVE;
    +
     			/* Modifikatoren sammeln  */
     			faktorLeft  *= faktorWishLeft;
     			faktorRight *= faktorWishRight;
    @@ -493,11 +497,11 @@
     					speedWishLeft *= faktorLeft;
     				if (speedWishRight != BOT_SPEED_IGNORE)
     					speedWishRight *= faktorRight;
    -
    +
     				motor_set(speedWishLeft, speedWishRight);
     				break;						/* Wenn ein Verhalten Werte direkt setzen will, nicht weitermachen */
     			}
    -
    +
     		}
     		/* Dieser Punkt wird nur erreicht, wenn keine Regel im System die Motoren beeinflusen will */
     		if (job->next == NULL) {
    @@ -506,18 +510,18 @@
     	}
     }

    -/*!
    - * @brief			Erzeugt ein neues Verhalten
    +/*!
    + * @brief			Erzeugt ein neues Verhalten
      * @param priority 	Die Prioritaet
      * @param *work 	Den Namen der Funktion, die sich drum kuemmert
      * @param active	Boolean, ob das Verhalten aktiv oder inaktiv erstellt wird
      */
     Behaviour_t *new_behaviour(uint8 priority, void (*work) (struct _Behaviour_t *data), int8 active){
    -	Behaviour_t *newbehaviour = (Behaviour_t *) malloc(sizeof(Behaviour_t));
    -
    -	if (newbehaviour == NULL)
    +	Behaviour_t *newbehaviour = (Behaviour_t *) malloc(sizeof(Behaviour_t));
    +
    +	if (newbehaviour == NULL)
     		return NULL;
    -
    +
     	newbehaviour->priority = priority;
     	newbehaviour->active=active;
     	newbehaviour->next= NULL;
    @@ -535,11 +539,11 @@
     void insert_behaviour_to_list(Behaviour_t **list, Behaviour_t *behave){
     	Behaviour_t	*ptr	= *list;
     	Behaviour_t *temp	= NULL;
    -
    +
     	/* Kein Eintrag dabei? */
     	if (behave == NULL)
     		return;
    -
    +
     	/* Erster Eintrag in der Liste? */
     	if (ptr == NULL){
     		ptr = behave;
    @@ -553,13 +557,13 @@
     		} else {
     			/* Mit dem naechsten Eintrag vergleichen */
     			while(NULL != ptr->next) {
    -				if (ptr->next->priority < behave->priority)
    +				if (ptr->next->priority < behave->priority)
     					break;
    -
    +
     				/* Naechster Eintrag */
     				ptr = ptr->next;
     			}
    -
    +
     			temp = ptr->next;
     			ptr->next = behave;
     			behave->next = temp;
    @@ -571,7 +575,7 @@
     	/*!
     	 * @brief		Behandelt die Tasten fuer die Verhaltensanezeige, die das jeweilige Verhalten aktivieren oder deaktivieren.
     	 * @author 		Timo Sandmann (mail@xxxxxxxxxxxxxxx)
    - 	 * @date 		14.02.2007
    + 	 * @date 		14.02.2007
      	 * @param data	Zeiger auf ein Array mit Verhaltensdatensatzzeigern
     	 */
     	static void beh_disp_key_handler(Behaviour_t** data){
    @@ -580,12 +584,12 @@
     		switch (RC5_Code){
     			case RC5_CODE_1: callee = data[0]; break;
     			case RC5_CODE_2: callee = data[1]; break;
    -			case RC5_CODE_3: callee = data[2]; break;
    -			case RC5_CODE_4: callee = data[3]; break;
    -			case RC5_CODE_5: callee = data[4]; break;
    -			case RC5_CODE_6: callee = data[5]; break;
    -			case RC5_CODE_7: callee = data[6]; break;
    -			case RC5_CODE_8: callee = data[7]; break;
    +			case RC5_CODE_3: callee = data[2]; break;
    +			case RC5_CODE_4: callee = data[3]; break;
    +			case RC5_CODE_5: callee = data[4]; break;
    +			case RC5_CODE_6: callee = data[5]; break;
    +			case RC5_CODE_7: callee = data[6]; break;
    +			case RC5_CODE_8: callee = data[7]; break;
     		}
     		/* Verhaltensstatus toggeln */
     		if (callee != NULL){
    @@ -593,29 +597,29 @@
     			callee->active ^= 1;
     		}
     	}
    -
    +
     	/*!
     	 * @brief	Zeigt Informationen ueber Verhalten an, 'A' fuer Verhalten aktiv, 'I' fuer Verhalten inaktiv.
     	 * @author 	Timo Sandmann (mail@xxxxxxxxxxxxxxx)
    - 	 * @date 	12.02.2007
    - 	 * Es werden zwei Spalten mit jeweils 4 Verhalten angezeigt. Gibt es mehr Verhalten in der Liste, kommt man
    + 	 * @date 	12.02.2007
    + 	 * Es werden zwei Spalten mit jeweils 4 Verhalten angezeigt. Gibt es mehr Verhalten in der Liste, kommt man
      	 * mit der Taste DOWN auf eine weitere Seite (die aber kein extra Screen ist). Mit der Taste UP geht's bei Bedarf
      	 * wieder zurueck. Vor den Prioritaeten steht eine Nummer von 1 bis 8, drueckt man die entsprechende Zifferntaste
      	 * auf der Fernbedienung, so wird das Verhalten aktiv oder inaktiv geschaltet, komplementaer zum aktuellen Status.
    - 	 * Den Keyhandler dazu stellt beh_disp_key_handler() dar.
    + 	 * Den Keyhandler dazu stellt beh_disp_key_handler() dar.
     	 */
    -	void behaviour_display(void){
    +	void behaviour_display(void){
     		static uint8 behaviour_page = 0;	/*!< zuletzt angezeigte Verhaltensseite */
    -		if (RC5_Code == RC5_CODE_DOWN){
    +		if (RC5_Code == RC5_CODE_DOWN){
     			/* naechste Seite */
     			behaviour_page++;
     			display_clear();	// Screen-Nr. wechselt nicht => Screen selbst loeschen
    -			RC5_Code = 0;	// Taste behandelt
    -		} else if (RC5_Code == RC5_CODE_UP){
    +			RC5_Code = 0;	// Taste behandelt
    +		} else if (RC5_Code == RC5_CODE_UP){
     			/* vorherige Seite */
     			if (behaviour_page > 0) behaviour_page--;
     			display_clear();
    -			RC5_Code = 0;
    +			RC5_Code = 0;
     		}
     		Behaviour_t* behaviours[8] = {NULL};	/*!< speichert Zeiger auf die Verhalten fuer den Keyhandler zwischen */
     		uint8 i,j,k=0;
    @@ -635,7 +639,7 @@
     			}
     		}
     		char status[2] = "IA";	// I: inactive, A: active
    -		/* max. 4 Zeilen mit jeweils 2 Verhalten (= 8 Verhalten) anzeigbar */
    +		/* max. 4 Zeilen mit jeweils 2 Verhalten (= 8 Verhalten) anzeigbar */
     		for (i=1; i<=20; i+=11){	// Spalten
     			for (j=1; j<=4; j++){	// Zeilen
     				while (ptr != NULL && ptr->priority > PRIO_VISIBLE_MAX)
    @@ -643,16 +647,16 @@
     				if (ptr == NULL || ptr->priority < PRIO_VISIBLE_MIN){
     					if (i==1 && j==1 && behaviour_page > 0) behaviour_page--;	// keine unnoetige leere Seite anzeigen
     					if (RC5_Code !=0) beh_disp_key_handler(behaviours);	// Tasten auswerten
    -					return; // fertig, da ptr == NULL oder Prioritaet bereits zu klein
    +					return; // fertig, da ptr == NULL oder Prioritaet bereits zu klein
     				}
     				/* Ausgabe */
     				display_cursor(j, i);
     				display_printf("%u: %3d=%c ", k+1, ptr->priority, status[ptr->active]);
     				behaviours[k++] = ptr;	// speichern fuer Tastenhandler
     				ptr = ptr->next;
    -			}
    -		}
    +			}
    +		}
     		if (RC5_Code !=0) beh_disp_key_handler(behaviours);	// Tasten auswerten
    -	}
    +	}
     #endif	// DISPLAY_BEHAVIOUR_AVAILABLE
     #endif	// BEHAVIOUR_AVAILABLE
    Index: C:/botneu/ct-Bot/bot-logic/behaviour_remotecall.c
    ===================================================================
    --- C:/botneu/ct-Bot/bot-logic/behaviour_remotecall.c	(revision 1304)
    +++ C:/botneu/ct-Bot/bot-logic/behaviour_remotecall.c	(working copy)
    @@ -144,6 +144,9 @@
     	#ifdef BEHAVIOUR_FOLLOW_WALL_AVAILABLE
     		PREPARE_REMOTE_CALL(bot_do_wall_explore,0,""),
     	#endif
    +	#ifdef BEHAVIOUR_TRANSPORT_PILLAR_AVAILABLE
    +		PREPARE_REMOTE_CALL(bot_transport_pillar,0,""),
    +	#endif
     };

     #define STORED_CALLS (sizeof(calls)/sizeof(call_t)) /*!< Anzahl der Remote calls im Array */
    Index: C:/botneu/ct-Bot/include/bot-logic/behaviour_transport_pillar.h
    ===================================================================
    --- C:/botneu/ct-Bot/include/bot-logic/behaviour_transport_pillar.h	(revision 0)
    +++ C:/botneu/ct-Bot/include/bot-logic/behaviour_transport_pillar.h	(revision 0)
    @@ -0,0 +1,62 @@
    +/*
    + * c't-Bot
    + *
    + * This program is free software; you can redistribute it
    + * and/or modify it under the terms of the GNU General
    + * Public License as published by the Free Software
    + * Foundation; either version 2 of the License, or (at your
    + * option) any later version.
    + * This program is distributed in the hope that it will be
    + * useful, but WITHOUT ANY WARRANTY; without even the implied
    + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
    + * PURPOSE. See the GNU General Public License for more details.
    + * You should have received a copy of the GNU General Public
    + * License along with this program; if not, write to the Free
    + * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
    + * MA 02111-1307, USA.
    + *
    + */
    +
    +
    +/*! @file 	behaviour_transport_pillar.h
    + * @brief 	Hin- und Herfahren zwischen zwei Positionen und evtl. Einfangen von Objekten
    + *
    + * @author 	Frank Menzel (menzelfr@xxxxxxx)
    + * @date 	23.10.2007
    +*/
    +
    +#ifndef BEHAVIOUR_TRANSPORT_PILLAR_H_
    +#define BEHAVIOUR_TRANSPORT_PILLAR_H_
    +
    +#include "ct-Bot.h"
    +#include "bot-logic/bot-logik.h"
    +
    +#ifdef BEHAVIOUR_TRANSPORT_PILLAR_AVAILABLE
    +
    +/*!
    + * Transport-Pillarverhalten
    + * @param caller	Der obligatorische Verhaltensdatensatz des Aufrufers
    + */
    +void bot_transport_pillar_behaviour(Behaviour_t *data);
    +
    +/*!
    + * Ruft das Pillarverhalten auf
    + * @param caller	Der obligatorische Verhaltensdatensatz des Aufrufers
    + */
    +void bot_transport_pillar(Behaviour_t * caller);
    +
    +/*!
    + * Routine zum Setzen der Zielkoordinaten auf der Zielposition/ Zielpad
    + * @param x X-World-Zielkoordinate
    + * @param y Y-World-Zielkoordinate
    + */
    +void bot_set_destkoords(float x, float y);
    +
    +/*!
    + * @brief	Display zum Start der Transport_Pillar-Routinen
    + */
    +void transportpillar_display(void);
    +
    +#endif
    +
    +#endif /*BEHAVIOUR_TRANSPORT_PILLAR_H_*/
    Index: C:/botneu/ct-Bot/include/bot-logic/available_behaviours.h
    ===================================================================
    --- C:/botneu/ct-Bot/include/bot-logic/available_behaviours.h	(revision 1304)
    +++ C:/botneu/ct-Bot/include/bot-logic/available_behaviours.h	(working copy)
    @@ -5,7 +5,7 @@

     #ifdef BEHAVIOUR_AVAILABLE

    -/*!
    +/*!
      * @file 	available_behaviours.h
      * @brief 	globale Schalter fuer die einzelnen Verhalten
      */
    @@ -18,7 +18,7 @@
     //#define BEHAVIOUR_HANG_ON_AVAILABLE	/*!< Erkennen des Haengenbleibens als Notfallverhalten? */
     //#define BEHAVIOUR_GOTO_AVAILABLE	/*!< goto vorhanden? */
     //#define BEHAVIOUR_GOTOXY_AVAILABLE	/*!< gotoxy vorhanden? */
    -//#define BEHAVIOUR_GOTO_POS_AVAILABLE	/*!< goto_pos vorhanden? */
    +#define BEHAVIOUR_GOTO_POS_AVAILABLE	/*!< goto_pos vorhanden? */
     #define BEHAVIOUR_TURN_AVAILABLE	/*!< turn vorhanden? */
     //#define BEHAVIOUR_TURN_TEST_AVAILABLE	/*!< turn_test vorhanden? */

    @@ -41,6 +41,8 @@

     //#define BEHAVIOUR_FOLLOW_WALL_AVAILABLE /*!< Follow Wall Explorer Verhalten */

    +#define BEHAVIOUR_TRANSPORT_PILLAR_AVAILABLE /*!< Transport-Pillar Verhalten */
    +
     #define BEHAVIOUR_REMOTECALL_AVAILABLE /*!< Nehmen wir Remote-kommandos entgegen? */
     #define BEHAVIOUR_CANCEL_BEHAVIOUR_AVAILABLE /*!< Deaktivieren eines Verhaltens wenn Abbruchbedingung erfuellt */

    @@ -49,8 +51,8 @@

     #define BEHAVIOUR_DELAY_AVAILABLE /*!< Delay-Routinen als Verhalten */

    -/* Aufgrund einer ganzen reihe von Abhaengigkeiten sollte man beim Versuch Speicher
    - * zu sparen, zuerst mal bei den Hauptverhalten ausmisten, sonst kommen die
    +/* Aufgrund einer ganzen reihe von Abhaengigkeiten sollte man beim Versuch Speicher
    + * zu sparen, zuerst mal bei den Hauptverhalten ausmisten, sonst kommen die
      * Unterverhalten durch die Hintertuer wieder rein
      */
     #ifndef MAP_AVAILABLE
    @@ -60,11 +62,11 @@

     #ifdef BEHAVIOUR_GOTOXY_AVAILABLE
     	#define BEHAVIOUR_TURN_AVAILABLE
    -#endif
    +#endif

     #ifdef BEHAVIOUR_AVOID_COL_AVAILABLE
     	#define BEHAVIOUR_TURN_AVAILABLE
    -#endif
    +#endif

     #ifdef BEHAVIOUR_TURN_TEST_AVAILABLE
     	#define BEHAVIOUR_TURN_AVAILABLE
    @@ -73,31 +75,36 @@
     #ifdef BEHAVIOUR_FOLLOW_LINE_AVAILABLE
     	#define BEHAVIOUR_DRIVE_DISTANCE_AVAILABLE
     	#define BEHAVIOUR_TURN_AVAILABLE
    -#endif
    +#endif

     #ifdef BEHAVIOUR_OLYMPIC_AVAILABLE
     	#define BEHAVIOUR_DRIVE_DISTANCE_AVAILABLE
     	#define BEHAVIOUR_TURN_AVAILABLE
    -#endif
    +#endif

     #ifdef BEHAVIOUR_SIMPLE_AVAILABLE
     	#define BEHAVIOUR_DRIVE_DISTANCE_AVAILABLE
    -#endif
    +#endif

     #ifdef BEHAVIOUR_SOLVE_MAZE_AVAILABLE
     	#define BEHAVIOUR_DRIVE_DISTANCE_AVAILABLE
     	#define BEHAVIOUR_DELAY_AVAILABLE
    -#endif
    +#endif

     #ifdef BEHAVIOUR_DRIVE_SQUARE_AVAILABLE
     	#define BEHAVIOUR_TURN_AVAILABLE
     	#define BEHAVIOUR_DRIVE_DISTANCE_AVAILABLE
    -#endif
    +#endif

     #ifdef BEHAVIOUR_CATCH_PILLAR_AVAILABLE
     	#define BEHAVIOUR_SERVO_AVAILABLE
     #endif

    +#ifdef BEHAVIOUR_TRANSPORT_PILLAR_AVAILABLE
    +	#define BEHAVIOUR_CANCEL_BEHAVIOUR_AVAILABLE
    +	#define BEHAVIOUR_FOLLOW_WALL_AVAILABLE
    +#endif
    +
     #ifndef MCU
     	#undef BEHAVIOUR_CALIBRATE_PID_AVAILABLE
     #endif
    @@ -173,5 +180,7 @@

     #include "bot-logic/behaviour_cancel_behaviour.h"

    +#include "bot-logic/behaviour_transport_pillar.h"
    +
     #endif	// BEHAVIOUR_AVAILABLE
     #endif	/*AVAILABLE_BEHAVIOURS_H_*/
    Index: C:/botneu/ct-Bot/ui/gui.c
    ===================================================================
    --- C:/botneu/ct-Bot/ui/gui.c	(revision 1304)
    +++ C:/botneu/ct-Bot/ui/gui.c	(working copy)
    @@ -133,6 +133,9 @@
     	#ifdef DISPLAY_MAP_GO_DESTINATION
     		register_screen(&mapgo_display);
     	#endif
    +	#ifdef DISPLAY_TRANSPORT_PILLAR
    +		register_screen(&transportpillar_display);
    +	#endif
     }

     #endif	// DISPLAY_AVAILABLE
    Index: C:/botneu/ct-Bot/ui/available_screens.h
    ===================================================================
    --- C:/botneu/ct-Bot/ui/available_screens.h	(revision 1304)
    +++ C:/botneu/ct-Bot/ui/available_screens.h	(working copy)
    @@ -44,7 +44,9 @@
     #define RAM_DISPLAY_AVAILABLE			/*!< Ausgabe des freien RAMs */
     #define DISPLAY_MAP_GO_DESTINATION      /*!< Steuerung Map-Verhalten auf diesem Screen */
     #define DISPLAY_MAP_AVAILABLE			/*!< Zeigt Map-Display an */
    +#define DISPLAY_TRANSPORT_PILLAR        /*!< Steuerung Transport-Pillar-Verhalten auf diesem Screen */

    +
     #ifndef SPEED_CONTROL_AVAILABLE
     	#undef DISPLAY_REGELUNG_AVAILABLE
     #endif
    Index: C:/botneu/ct-Bot/.settings/org.eclipse.cdt.core.prefs
    ===================================================================
    --- C:/botneu/ct-Bot/.settings/org.eclipse.cdt.core.prefs	(revision 0)
    +++ C:/botneu/ct-Bot/.settings/org.eclipse.cdt.core.prefs	(revision 0)
    @@ -0,0 +1,3 @@
    +#Sun Nov 11 19:31:40 CET 2007
    +eclipse.preferences.version=1
    +indexerId=org.eclipse.cdt.core.fastIndexer
Antworten: Re: [ct-bot] Verhalten behaviour_goto_pos ->transport_pillar_behaviour From: Timo Sandmann Referenzen: Re: [ct-bot] Verhalten behaviour_goto_pos ->transport_pillar_behaviour From: Timo Sandmann Voriger (Datum): Re: AW: [ct-bot] Verhalten behaviour_goto_pos ->transport_pillar_behaviour, Timo Sandmann Nächster (Datum): Re: [ct-bot] Verhalten behaviour_goto_pos ->transport_pillar_behaviour, Timo Sandmann Voriger (Thread): Re: AW: [ct-bot] Verhalten behaviour_goto_pos ->transport_pillar_behaviour, Timo Sandmann Nächster (Thread): Re: [ct-bot] Verhalten behaviour_goto_pos ->transport_pillar_behaviour, Timo Sandmann Indizes: Datum Thread |

Copyright © 2007 Heise Zeitschriften Verlag | Kritik, Anregungen bitte an c't-WWW | Datenschutzhinweis Impressum