c't Projekte - c't-Bot und c't-Sim -
Mailinglisten
[Voriger (Datum)]
[Nächster (Datum)]
[Voriger (Thread)]
[Nächster (Thread)]
[Nach Datum][Nach Thread]
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