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

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


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