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

Aktuelles Heft #### Support Hotline & FAQ Tipps & Tricks Treiber & BIOS Firmenkontakte #### Download Software zu c't Software-Verzeichnis c't-Projekte Testbilder & Vorlagen #### Service Tipp-Datenbank c't-CD-Register Internettarife Telefontarife Virenschutz #### Magazin Heftarchiv c't specials English Pages Benchmarks Red. Stuff Leserforum c't-Bildmotive URLs aus c't Schlagseite #### Aktionen Browsercheck Krypto-Kampagne Schulen ans Netz Netz gegen Kinderporno TV/Radio-Termine #### Info Abo & Heft Veranstaltungen Mediadaten Kontakt Impressum Kleinanzeigen und Veranstaltungen
| c't Projekte - c't-Bot und c't-Sim - Mailinglisten ## c't-Bot und c't-Sim [Voriger (Datum)] [Nächster (Datum)] [Voriger (Thread)] [Nächster (Thread)] [Nach Datum][Nach Thread] ### AW: [ct-bot] Neues wall_explorer-Verhalten... Absender: Frank Menzel Datum: Di, 28.08.2007 20:48:44 In-reply-to: <4A58CD0D-1DDC-43EC-97CE-6202257A21D2@xxxxxxxxxxxxxxx>
    Hallo,
    habe jetzt alles berücksichtigt und den Patch angehangen...

    Mit freundlichen Grüßen
    Frank Menzel

    -----Ursprüngliche Nachricht-----
    Von: ct-bot-entwickler-bounces@xxxxxxxxxxxxxxxxx
    [mailto:ct-bot-entwickler-bounces@xxxxxxxxxxxxxxxxx] Im Auftrag von Timo
    Sandmann
    Gesendet: Montag, 27. August 2007 21:02
    An: Entwicklung rund um den c't-bot
    Betreff: Re: [ct-bot] Neues wall_explorer-Verhalten...

    Hi,

    Am 27.08.2007 um 08:29 schrieb Menzel, Frank IT-OO4:
    > Ich habe aber noch ein paar Anmerkungen:
    > Die aus dem Olympic-Verhalten ausgelagerte Funktion "int16
    > is_obstacle_ahead(int16 distance)" sollte dann am besten auch aus
    > der olympic.c-Datei raus und in sensor.c, denn der Distanzsensor-
    > Vergleich wird ja nicht mehr nur von olympic benutzt.
    > -> verstehe ich nicht, da die Routine in Olympic ja benutzt wird,
    > also auch der Sensorvergleich benutzt wird... Kann die Routine
    > trotzdem auslagern.

    ich meine folgendes: Die einzelnen Verhalten sind in
    unterschiedlichen Dateien aufgeteilt und werden mit unterschiedlichen
    #defines aktiviert. Ich fände es am Übersichtlichsten, wenn alles,
    was in der Datei behaviour_xyz.c steht auch mit
    BEHAVIOUR_XYZ_AVAILABLE komplett an- oder abgeschaltet wird. Sonst
    weiß man nie so genau, was jetzt alles mit compiliert wird, welche
    Funktion, die auch von anderen Codeteilen benutzt wird, wo überhaupt
    definiert ist usw. Wenn jede zweite bahviour-Datei auch Code enthält,
    der immer compiliert wird, unabhängig vom #define-Schalter für dieses
    Verhalten, für das die Datei eigentlich gedacht war, verliert man
    schnell den Überblick.
    Außerdem ist eine Funktion, die prüft ob ein Hindernis in Entfernung
    X existiert, so allgemein, dass sie immer im Code vorhanden sein
    kann / sollte. Zudem geht sie in einer "Verhaltensdatei" auch unter
    und wird kaum benutzt, obwohl es sich an vielen anderen Stellen
    anbieten würde. Daher der Vorschlag diese Funktion auszulagern.

    > Anstatt der Funktion "int8 time_reached(uint16 ms)" würde ich
    > lieber "bot_delay_behaviour" benutzen, so wie das u.a. auch bot_turn
    > () macht, dann haben wir den Code dafür nur einmal.
    > -> Problem ist nur, daß das delay-Verhalten selbst das aufrufende
    > Verhalten deaktiviert und erst nach Ablauf der Zeit wieder
    > aktiviert. Der Unterscheid zu den bisher benutzten Aufrufen ist
    > aber der, dass mein Verhalten weiterhin aktiv sein muß und solange
    > die Drehgeschwindigkeiten setzen muß. Kann das Delay-Verhalten also
    > so nicht verwenden.

    Oh stimmt, das hatte ich übersehen. In diesem Fall ist man mit
    timer_ms_passed() am besten bedient.

    > "int8 wall_is_vertical(void)" rechnet die Differenz in floating-
    > point Werte um, ich denke mal das ist eher ein Tippfehler und nicht
    > beabsichtigt, oder? Außerdem ist der Name der Funktion etwas
    > merkwürdig...
    > -> ist klar
    >
    > Die Geschwindigkeitsunterscheidungen für Sim-Bot und Real-Bot finde
    > ich auch nicht so gut, weil der Sim ja eigentlich den echten Bot
    > möglichst genau simulieren sollte, auch wenn es im Sim (bisher)
    > keinen Nachlauf des Bots gibt.
    > -> auch klar...

    Viele Grüße,
    Timo

    _______________________________________________
    ct-bot-entwickler Mailingliste
    ct-bot-entwickler@xxxxxxxxxxxxxxxxx
    http://www.heise.de/bin/newsletter/listinfo/ct-bot-entwickler
    Index: C:/t/patch/ct-Bot/bot-logic/behaviour_olympic.c
    ===================================================================
    --- C:/t/patch/ct-Bot/bot-logic/behaviour_olympic.c	(revision 1225)
    +++ C:/t/patch/ct-Bot/bot-logic/behaviour_olympic.c	(working copy)
    @@ -103,18 +103,6 @@
     	else return True;
     }

    -/*!
    - * Die Funktion gibt aus, ob sich innerhalb einer gewissen Entfernung ein Objekt-Hindernis befindet.
    - * @param distance Entfernung in mm, bis zu welcher ein Objekt gesichtet wird.
    - * @return Gibt False (0) zurueck, wenn kein Objekt innerhalb von distance gesichtet wird. Ansonsten die Differenz
    - * zwischen dem linken und rechten Sensor. Negative Werte besagen, dass das Objekt naeher am linken, positive, dass
    - * es naeher am rechten Sensor ist. Sollten beide Sensoren den gleichen Wert haben, gibt die Funktion 1 zurueck, um
    - * von False unterscheiden zu koennen. */
    -int16 is_obstacle_ahead(int16 distance){
    -	if(sensDistL > distance && sensDistR > distance) return False;
    -	if(sensDistL - sensDistR == 0) return 1;
    -	else return (sensDistL - sensDistR);
    -}

     /*!
      * Gibt aus, ob der Bot eine fuer sein Slalomverhalten geeignete Saeule vor sich hat.
    Index: C:/t/patch/ct-Bot/bot-logic/behaviour_follow_wall.c
    ===================================================================
    --- C:/t/patch/ct-Bot/bot-logic/behaviour_follow_wall.c	(revision 0)
    +++ C:/t/patch/ct-Bot/bot-logic/behaviour_follow_wall.c	(revision 0)
    @@ -0,0 +1,277 @@
    +/*
    + * 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_follow_wall.c
    + * @brief 	Wandfolger Explorer; faehrt solange vorwaerts, bis er an eine Wand kommt, an die er sich gewisse Zeit wegdreht;
    + *          nach links dreht er sich, wenn rechts eine Wand als naeher erkannt wird sonst nach rechts; es erfolgt
    + *          hier auch eine Abgrundauswertung; wird erkannt dass entweder
    + *          beide Abgrundsensoren den Abgrund detektieren oder der bot senkrecht zur Wand steht, so wird via Zeitzaehler
    + *          ein Pseudo-Zufallswert bis 255 ausgewertet und danach die neue Drehrichtung links/ rechts ermittelt;
    + *          zur Mindestdrehzeit wird ebenfalls immer dieser Zufallswert zuaddiert
    + *          sehr sinnvoll mit diesem Explorer-Verhalten ist das hang_on-Verhalten, welches durch Vergleich mit Mausdaten
    + *          ein Haengenbleiben erkennt, rueckwaerts faehrt und das hier registrierte Notverhalten startet. Dieses wiederum
    + *          sorgt dafuer, dass der bot sich wegdreht und weiterfaehrt wie an einer Wand. Gleiches gilt fuer das Abgrundverhalten.
    + *
    + *
    + * @author 	Frank Menzel (Menzelfr@xxxxxxx)
    + * @date 	05.05.2007
    +*/
    +
    +#include "bot-logic/bot-logik.h"
    +
    +#include "timer.h"
    +#include <stdlib.h>
    +
    +#ifdef BEHAVIOUR_FOLLOW_WALL_AVAILABLE
    +
    +  /* Zustaende fuer check_wall_behaviour-Verhalten */
    +	#define CHECK_FOR_BACK		        1
    +	#define CHECK_WALL_GO				2
    +	#define CHECK_WALL_TURN				3
    +	#define CHECK_FOR_READY             4
    +
    +   /*  Verhaltens- und letzter gemerkter Status  */
    +    static uint8 state=CHECK_FOR_BACK;
    +	static uint8 laststate=0;
    +
    +    /* Zeitzaehlerwert vor Neusetzen */
    +    static uint16 lastmsTime =0;
    +
    +    /*  Abgrund wurde erkannt */
    +      volatile int8 border_follow_wall_fired=False;
    +
    +   /* Mindest-Wartezeiten fuer Drehung; auf diese Werte wird noch der Pseudo-Zufallswert aus
    +    * TIMER_GET_TICKCOUNT_8 raufaddiert, kann also bis 255 mehr sein */
    +    #define DELAY_NORMAL     100       // normale Wartezeit
    +    #ifdef PC
    +      #define DELAY_AFTER_HOLE 300       // Wartezeit nach Abgrund
    +      #define DELAY_AFTER_HOLE_VERT 400
    +    #else
    +      #define DELAY_AFTER_HOLE 150       // Wartezeit nach Abgrund
    +      #define DELAY_AFTER_HOLE_VERT 200
    +    #endif
    +    /* Delay-Time, solange wird mindestens gedreht, gesetzt im Prog */
    +    static uint16 delay_time_turn = 0;
    +
    + 	static int16 wall_side=0;  // <0 Hindernis links, sonst rechts
    +
    +   /* Abbruchfunktion des Verhaltens() */
    +   int8 (*check_function)(void)=0;	/*!< Die Funktion, mit der das bot_explore_behaviour() feststellt, ob es etwas gefunden hat.
    +											 * Die Funktion muss True (1) zurueckgeben, wenn dem so ist, sonst False (0).
    +											 * Beispiele fuer eine solche Funktion sind check_for_light, is_good_pillar_ahead etc.*/
    + /*! ermittelt Zufallswert je nach Zeitzaehler
    +  *  @param   Zeit-Vergleichswert
    +  *  @return  liefert 1 oder -1 in Abhaengigkeit der abgelaufenen Zeit als Zufallskomponente
    +  */
    +  int8 get_randomside(uint8 compval) {
    +	return  (TIMER_GET_TICKCOUNT_8 >compval) ? -1 : 1 ;
    +  }
    +
    + /*!
    + * Notfallhandler, ausgefuehrt bei Abgrunderkennung oder Haengenbleiben; muss registriert werden und laesst
    + * den bot etwas rueckwaerts fahren und dreht ihn zur Seite
    + */
    +void border_follow_wall_handler(void) {
    +	// Routine muss zuerst checken, ob follow_wall auch gerade aktiv ist, da nur in diesem
    +	// Fall etwas gemacht werden muss
    +	if (!behaviour_is_activated(bot_follow_wall_behaviour))
    +		return;
    +
    +	border_follow_wall_fired=True;  // Setzen der Syncvar des Verhaltens, die immer abgefragt wird
    +
    +    state = CHECK_FOR_BACK;
    +
    +    if (sensBorderL > BORDER_DANGEROUS && sensBorderR > BORDER_DANGEROUS)
    +      {
    +      	wall_side = get_randomside(127); // links fuer < 127 sonst rechts
    +      	delay_time_turn = DELAY_AFTER_HOLE_VERT + TIMER_GET_TICKCOUNT_8; // Mindest- und Zufallszeit
    +      }
    +    else
    +    {
    +      wall_side = (sensBorderL > BORDER_DANGEROUS) ? -1:1;  // Drehseite festlegen
    +      delay_time_turn = DELAY_AFTER_HOLE + TIMER_GET_TICKCOUNT_8; // Mindest- und Zufallszeit
    +    }
    +
    +    // rueckwaertsfahren; bei schon aktivem Verhalten durch Notfallverhalten selbst wird dieses
    +    // hier nicht ausgefuehrt
    +	bot_drive_distance(0,0,-BOT_SPEED_FOLLOW,10);
    +}
    +
    +
    +
    +/*!  Das eigentliche Wandfolgerverhalten; Bot faehrt gerade voraus bis zu einer Wand und dreht sich gewisse Zeit solange,
    + *   bis keine Wand mehr in geringem Abstand gefunden wird; trifft er senkrecht auf eine Wand, wird per Zufall die Seite
    + *   ermittelt, wohin sich der Bot wegdreht (gilt auch fuer Abgrund); das Speiel geht wieder von vorn los
    + *   @param data  der Verhaltensdatensatz
    + */
    +void bot_follow_wall_behaviour(Behaviour_t *data){
    +
    +    int16 sensor = 0;          // Merker fuer Abstandssensor je nach Wand links oder rechts
    +
    +   if(check_function && (*check_function)()) // wenn ueberhaupt definiert und Abbruchbedingung erfuellt
    +     state = CHECK_FOR_READY;
    +
    +
    +	switch (state){
    +
    +		case CHECK_FOR_BACK:           // Check auf zu nah oder bei Abgrund mit Rueckwaertsfahren
    +	    // Der Bot erkennt Hindernis
    +		  if (border_follow_wall_fired || is_obstacle_ahead(OPTIMAL_DISTANCE+ADJUST_DISTANCE)) {  // aus bot_olympic
    +		   /* Abhaengig von der Seite, auf der die Wand ist, Entfernung ermitteln fuer rueckwaerts */
    +            sensor = (is_obstacle_ahead(OPTIMAL_DISTANCE+ADJUST_DISTANCE)<0) ? sensDistL: sensDistR ;
    +
    +			if (border_follow_wall_fired) {  // gesetzt durch registriertes Abgrundverhalten
    +				  state = CHECK_WALL_TURN;   // nach rueckwaerts immer zum drehen
    + 			      border_follow_wall_fired=False;
    +			      lastmsTime = TIMER_GET_TICKCOUNT_16; // Zeitzaehler geht jetzt los, damit mindestens xxms gedreht wird
    +				  break;
    +			}   // Notfall erkannt
    +
    +		}  // Hindernis oder Abgrund vorhanden
    +
    +		/* kam ich von Drehung, dann auch wieder dorthin sonst fahren */
    +		state = (laststate == CHECK_WALL_TURN) ? CHECK_WALL_TURN: CHECK_WALL_GO ;
    +
    +		break;
    +
    +
    +		case CHECK_WALL_GO:
    +
    +	    // Der Bot erkennt Hindernis oder Abgrund und muss gecheckt werden
    +			if (is_obstacle_ahead(OPTIMAL_DISTANCE+ADJUST_DISTANCE)) {  // innerhalb xx cm Hindernis
    +
    +			/* naechsten Status setzen und aktuellen merken */
    +			state=CHECK_FOR_BACK;
    +			laststate=CHECK_WALL_TURN;
    +
    +			// Seite des Hindernisses ermitteln; <0 links, >= 0 rechts
    +            wall_side = is_obstacle_ahead(OPTIMAL_DISTANCE+ADJUST_DISTANCE);  // Seite ermitteln
    +
    +            /* bei Wand 90Grad voraus, dann per Zufall nach links oder rechts wegdrehen */
    +	        if(sensDistL < COL_FAR && sensDistR < COL_FAR)
    +	  	        wall_side = get_randomside(127);  // < 127 links sonst rechts
    +
    +            break;
    +		}
    +
    +
    +		       // Geschwindigkeiten je nach gesehener Entfernung setzen
    +               if(sensDistL > COL_FAR && sensDistR > COL_FAR ) {
    +			     speedWishLeft=BOT_SPEED_MAX;
    +			     speedWishRight=BOT_SPEED_MAX;
    +               }
    +               else
    +               {
    +               	if(sensDistL > COL_CLOSEST && sensDistR > COL_CLOSEST) {
    +               		speedWishLeft=BOT_SPEED_FAST;
    +			        speedWishRight=BOT_SPEED_FAST;
    +               	}
    +               	else
    +               	{
    +               	 speedWishLeft=BOT_SPEED_NORMAL;
    +			     speedWishRight=BOT_SPEED_NORMAL;
    +               	}
    +               }
    +
    +	       laststate=CHECK_WALL_GO;    // merken dass ich aus GO komme
    +
    +			break;                     // immer weiter fahren in GO
    +
    +		case CHECK_WALL_TURN:
    +		    // nun bestimmte Zeit von Wand wegdrehen, je nach bereits ermittelter Seite
    +
    +            // Setzen der Drehgeschwindigkeiten
    +		    if   (wall_side < 0) {  // rechtsdrehen wenn Wand links
    +              speedWishLeft  = BOT_SPEED_MEDIUM;
    +			  speedWishRight = -BOT_SPEED_MEDIUM;
    +		    }
    +			else
    +			{   // sonst linksdrehen, wenn Wand rechts
    +			    speedWishLeft  = -BOT_SPEED_MEDIUM;
    +			    speedWishRight = BOT_SPEED_MEDIUM;
    +			}
    +
    +			 // solange drehen bis Zeit in ms ueberschritten wird; ist dann genug Abstand bei beiden Sensoren
    +			 // zur Wand vorhanden ist Drehung beendet
    +			 // Durch die Zeit kommt der bot den Wandecken weniger nah, da er sich dadurch nicht genau parallel ausrichtet
    +			 // und mit Drehen aufhoert wenn er ueber die Ecke schielt sondern sich wieder etwas von wegdreht; bei Abgrund dreht er
    +			 // sich damit auch sicher weg mit hoeherer Drehzeit
    +			 // Wartezeit hier nicht init. da dies dann noch zufaelliger wird
    +  	         if (timer_ms_passed(&lastmsTime, delay_time_turn)) {
    +			  delay_time_turn = DELAY_NORMAL + TIMER_GET_TICKCOUNT_8;  // wieder mit normalen Pseudo-Zufallswert belegen
    +
    +			  if(sensDistL > COL_NEAR && sensDistR > COL_NEAR ) {  // keine Wand mehr in Sichtweite
    +			    state=CHECK_FOR_BACK;                    // Abgrund-/ Abstandscheck und dann los
    +			    laststate=0;                             // Initialwert
    +			    break;
    +               }
    + 			 }      // Check auf Ablauf der Wartezeit
    +
    +			break;
    +
    +		default:
    +		        state=CHECK_FOR_BACK;
    +	            laststate=0;
    +				return_from_behaviour(data);
    +				break;
    +	}
    +}
    +
    +
    +
    +/*! Faehrt vorwaerts bis zu einer Wand, von die er sich wegdreht
    + *  @param check Abbruchfunktion; wenn diese True liefert wird das Verhalten beendet sonst endlos
    + *         einfach 0 uebergeben, wenn keine definiert ist
    + *  @param caller Verhaltensdatensatz
    + */
    +void bot_follow_wall(Behaviour_t *caller,int8 (*check)(void)) {
    +
    +	 // bei Aufruf von anderem Verhalten aus ist dies die Abbruchfunktion, d.h. es wird
    +	 // wieder zum aufrufenden Verhalten zurueckgekehrt
    +	 check_function = check;
    +
    +	 #ifdef BEHAVIOUR_AVOID_COL_AVAILABLE
    +	    // verwaltet selbst Abstand zur Wand
    +		deactivateBehaviour(bot_avoid_col_behaviour);
    +	 #endif
    +
    +	 #ifdef BEHAVIOUR_AVOID_BORDER_AVAILABLE
    +	   // falls durch anderes Verhalten vorher ausgeschaltet wurde
    +	   activateBehaviour(bot_avoid_border_behaviour);
    +	 #endif
    +
    +	// nach Notaus stehen diese Vars sonst undefiniert rum, also init.
    +	state=CHECK_FOR_BACK;
    +	laststate=0;
    +
    +	// und Umschalten zum eigentlichen Verhalten
    +	switch_to_behaviour(caller, bot_follow_wall_behaviour,NOOVERRIDE);
    +}
    +
    +/*! Botenverhalten zum Aufruf via Remotecall ohne weitere params, d.h. da kein Abbruchverhalten
    + *  uebergeben wird, ist dies dann ein Endlos-Explorerverhalten
    + *  @param caller Verhaltensdatensatz
    + */
    +void bot_do_wall_explore(Behaviour_t *caller) {
    +	bot_follow_wall(caller,0);
    +}
    +
    +#endif
    +
    +
    Index: C:/t/patch/ct-Bot/bot-logic/bot-logik.c
    ===================================================================
    --- C:/t/patch/ct-Bot/bot-logic/bot-logik.c	(revision 1225)
    +++ C:/t/patch/ct-Bot/bot-logic/bot-logik.c	(working copy)
    @@ -71,7 +71,7 @@
     #endif

    -#define MAX_PROCS 3					/*!< Maximale Anzahl der registrierbaren Funktionen */
    +#define MAX_PROCS 6					/*!< Maximale Anzahl der registrierbaren Funktionen */
     static int8_t count_arr_emerg = 0;	/*!< Anzahl der zurzeit registrierten Notfallfunktionen */
     /*! hier liegen die Zeiger auf die auszufuehrenden Abgrund Notfall-Funktionen */
     static void (* emerg_functions[MAX_PROCS])(void) = {NULL};
    @@ -195,7 +195,14 @@
      	    // Registrierung zur Behandlung des Notfallverhaltens zum Rueckwaertsfahren
      	    register_emergency_proc(&border_mapgo_handler);
         #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 Rueckwaertsfahren
    +	  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));
    Index: C:/t/patch/ct-Bot/bot-logic/behaviour_remotecall.c
    ===================================================================
    --- C:/t/patch/ct-Bot/bot-logic/behaviour_remotecall.c	(revision 1225)
    +++ C:/t/patch/ct-Bot/bot-logic/behaviour_remotecall.c	(working copy)
    @@ -136,6 +136,9 @@
     	#ifdef BEHAVIOUR_TURN_TEST_AVAILABLE
     		PREPARE_REMOTE_CALL(bot_turn_test,0,""),
     	#endif
    +	#ifdef BEHAVIOUR_FOLLOW_WALL_AVAILABLE
    +		PREPARE_REMOTE_CALL(bot_do_wall_explore,0,""),
    +	#endif
     };

     #define STORED_CALLS (sizeof(calls)/sizeof(call_t)) /*!< Anzahl der Remote calls im Array */
    Index: C:/t/patch/ct-Bot/include/bot-logic/available_behaviours.h
    ===================================================================
    --- C:/t/patch/ct-Bot/include/bot-logic/available_behaviours.h	(revision 1225)
    +++ C:/t/patch/ct-Bot/include/bot-logic/available_behaviours.h	(working copy)
    @@ -36,6 +36,8 @@

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

    +#define BEHAVIOUR_FOLLOW_WALL_AVAILABLE /*!< Follow Wall Explorer Verhalten */
    +
     #define BEHAVIOUR_REMOTECALL_AVAILABLE /*!< Nehmen wir Remote-kommandos entgegen?*/

     //#define BEHAVIOUR_CALIBRATE_PID_AVAILABLE	/*!< Kalibrierungsverhalten fuer Motorregelung vorhanden? */
    @@ -149,6 +151,8 @@

     #include "bot-logic/remote_calls.h"

    +#include "bot-logic/behaviour_follow_wall.h"
    +
     #include "bot-logic/behaviour_calibrate_pid.h"
     #include "bot-logic/behaviour_calibrate_sharps.h"

    Index: C:/t/patch/ct-Bot/include/bot-logic/behaviour_follow_wall.h
    ===================================================================
    --- C:/t/patch/ct-Bot/include/bot-logic/behaviour_follow_wall.h	(revision 0)
    +++ C:/t/patch/ct-Bot/include/bot-logic/behaviour_follow_wall.h	(revision 0)
    @@ -0,0 +1,58 @@
    +/*
    + * 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_follow_line.h
    + * @brief 	Wandfolger, der sich an Wand gewisse Zeit dreht; solange bis kein Hindernis mehr sichtbar ist
    + *
    + * @author 	Frank Menzel(Menzelfr@xxxxxxx)
    + * @date 	03.11.06
    +*/
    +
    +#include "bot-logic/bot-logik.h"
    +
    +#ifndef BEHAVIOUR_FOLLOW_WALL_H_
    +#define BEHAVIOUR_FOLLOW_WALL_H_
    +
    +#ifdef BEHAVIOUR_FOLLOW_WALL_AVAILABLE
    +
    +
    +void border_follow_wall_handler(void);
    +
    +/*  Faehrt vorwaerts bis zu einer Wand, von die er sich wegdreht
    + *  @param data Verhaltensdatensatz
    + */
    +void bot_follow_wall_behaviour(Behaviour_t *data);
    +
    +/*! Botenfunktion
    + *  Faehrt vorwaerts bis zu einer Wand, von die er sich wegdreht
    + *  @param check Abbruchfunktion; wenn diese True liefert wird das Verhalten beendet sonst endlos
    + *         einfach 0 uebergeben, wenn keine definiert ist
    + *  @param caller Verhaltensdatensatz
    + */
    +void bot_follow_wall(Behaviour_t *caller,int8 (*check)(void));
    +
    +/*! Botenverhalten zum Aufruf via Remotecall ohne weitere params, d.h. da kein Abbruchverhalten
    + *  uebergeben wird, ist dies dann ein Endlos-Explorerverhalten
    + *  @param caller Verhaltensdatensatz
    + */
    +void bot_do_wall_explore(Behaviour_t *caller);
    +
    +#endif
    +#endif /*BEHAVIOUR_FOLLOW_WALL_H_*/
    +
    Index: C:/t/patch/ct-Bot/include/sensor.h
    ===================================================================
    --- C:/t/patch/ct-Bot/include/sensor.h	(revision 1225)
    +++ C:/t/patch/ct-Bot/include/sensor.h	(working copy)
    @@ -124,6 +124,15 @@
      */
     void sensor_dist_lookup(int16_t *const p_sens, uint8_t *const p_toggle, const distSens_t *ptr, int16_t volt_16);

    +/*!
    + * Die Funktion gibt aus, ob sich innerhalb einer gewissen Entfernung ein Objekt-Hindernis befindet.
    + * @param distance Entfernung in mm, bis zu welcher ein Objekt gesichtet wird.
    + * @return Gibt False (0) zurueck, wenn kein Objekt innerhalb von distance gesichtet wird. Ansonsten die Differenz
    + * zwischen dem linken und rechten Sensor. Negative Werte besagen, dass das Objekt naeher am linken, positive, dass
    + * es naeher am rechten Sensor ist. Sollten beide Sensoren den gleichen Wert haben, gibt die Funktion 1 zurueck, um
    + * von False unterscheiden zu koennen. */
    +int16 is_obstacle_ahead(int16 distance);
    +
     #ifdef DISPLAY_AVAILABLE
     	/*!
     	 * @brief	Displayhandler fuer Sensoranzeige
    Index: C:/t/patch/ct-Bot/sensor.c
    ===================================================================
    --- C:/t/patch/ct-Bot/sensor.c	(revision 1225)
    +++ C:/t/patch/ct-Bot/sensor.c	(working copy)
    @@ -435,6 +435,19 @@
     	}
     }

    +/*!
    + * Die Funktion gibt aus, ob sich innerhalb einer gewissen Entfernung ein Objekt-Hindernis befindet.
    + * @param distance Entfernung in mm, bis zu welcher ein Objekt gesichtet wird.
    + * @return Gibt False (0) zurueck, wenn kein Objekt innerhalb von distance gesichtet wird. Ansonsten die Differenz
    + * zwischen dem linken und rechten Sensor. Negative Werte besagen, dass das Objekt naeher am linken, positive, dass
    + * es naeher am rechten Sensor ist. Sollten beide Sensoren den gleichen Wert haben, gibt die Funktion 1 zurueck, um
    + * von False unterscheiden zu koennen. */
    +int16 is_obstacle_ahead(int16 distance){
    +	if(sensDistL > distance && sensDistR > distance) return False;
    +	if(sensDistL - sensDistR == 0) return 1;
    +	else return (sensDistL - sensDistR);
    +}
    +
     #ifdef SENSOR_DISPLAY_AVAILABLE
     	/*!
     	 * @brief	Displayhandler fuer Sensoranzeige
    Index: C:/t/patch/ct-Bot/Changelog.txt
    ===================================================================
    --- C:/t/patch/ct-Bot/Changelog.txt	(revision 1225)
    +++ C:/t/patch/ct-Bot/Changelog.txt	(working copy)
    @@ -1,5 +1,7 @@
     CHANGELOG fuer c't-Bot
     ======================
    +2007-08-26 Frank Menzel  [Menzelfr@xxxxxxx]: Explorer-Verhalten bot_follow_wall_behaviour zugefuegt
    +
     2007-08-25 Timo Sandmann [mail@xxxxxxxxxxxxxxx]: Syntaxfehler in behaviour_remotecall.c korrigiert.

     2007-08-21 Frank Menzel  [Menzelfr@xxxxxxx]: Entladeverhalten bot_unload_pillar_behaviour und Aenderungen catch_pillar
    Index: C:/t/patch/ct-Bot/.settings/org.eclipse.cdt.core.prefs
    ===================================================================
    --- C:/t/patch/ct-Bot/.settings/org.eclipse.cdt.core.prefs	(revision 0)
    +++ C:/t/patch/ct-Bot/.settings/org.eclipse.cdt.core.prefs	(revision 0)
    @@ -0,0 +1,3 @@
    +#Tue Aug 28 20:32:04 CEST 2007
    +eclipse.preferences.version=1
    +indexerId=org.eclipse.cdt.core.fastIndexer
Antworten: Re: AW: [ct-bot] Neues wall_explorer-Verhalten... From: Timo Sandmann Re: AW: [ct-bot] Neues wall_explorer-Verhalten... From: Timo Sandmann Referenzen: Re: [ct-bot] Neues wall_explorer-Verhalten... From: Timo Sandmann Voriger (Datum): Re: [ct-bot] Neues wall_explorer-Verhalten..., Timo Sandmann Nächster (Datum): Re: AW: [ct-bot] Neues wall_explorer-Verhalten..., Timo Sandmann Voriger (Thread): Re: [ct-bot] Neues wall_explorer-Verhalten..., Timo Sandmann Nächster (Thread): Re: AW: [ct-bot] Neues wall_explorer-Verhalten..., Timo Sandmann Indizes: Datum Thread |

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