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