Representations/WLan/TeamMessageCollection.h

Go to the documentation of this file.

/**
 * @file Representations/WLan/TeamMessageCollection.h
 *
 * Declaration of class TeamMessageCollection
 *
 * @author <A href=mailto:roefer@tzi.de>Thomas Röfer</A>
 * @author <A href=mailto:sebastian.schmidt@udo.edu>Sebastian Schmidt</A>
 * @author <A href=mailto:m_wachter@gmx.de>Michael Wachter</A>
 */ 

#ifndef __TeamMessageCollection_h_
#define __TeamMessageCollection_h_

#include "TeamMessage.h"

#include "Tools/RingBuffer.h"

/** 
 * @class TeamMessageCollection
 *
 * Represents a collection of all actual team messages received from other robots 
 * and has the ability to send to them too.
 *
 */
class TeamMessageMessage;
class TeamMessageCollection
{
  public:
   
    /**
     * Timeout-constants for the processMasterSync method
     */
    enum {robotTimeoutTime = 4000, masterTimeoutTime = 2000, masterClaimTimeoutTime = 1500};
    /**
     * the maximum number of team-messages
     */
    enum {maxNumberOfTeamMessages = Player::numOfPlayerNumbers-1};

    int numberOfTeamMessages; /**< count of actual TeamMessages */
  

    /**
     * Constructor.
     */
    TeamMessageCollection() ;

    /**
     * Constant access operator to a certain team message. Only
     * actual team-messages are given back. (TeamMessage.isActual() == true)
     * @param index The index of the team message.
     * @return The team message with the requested index.
     */
    const TeamMessage& operator[](int index) const 
    {
      return *teamMessages[teamMessagesForActualTeamMessages[index]];
    }
                                                                              
    /**
     * This method processes the incomming messages to calculate time-offsets for
     * the time syncronisation, to find out which Robot is Master and to find out
     * if one robot is missing.
     */
    void processMessages();

    /**
     * The function sets the internal references to the outgoing TeamMessages
     * @param tm the outgoing teammessage
     */
    void setOutTeamMessages(TeamMessage& tm);

    /**
     * The function sets an internal reference to an incoming TeamMessage
     * @param tm The TeamMessage
     */
    void setInTeamMessages(TeamMessage& tm);

    /**
     * This function sets the robotPose field in the outgoing TeamMessage 
     * that is represented by the target
     * @param robotPose The RobotPose to be sent
     * @param sendNow bool o indicate that the message needs to be sent now (default = false)
     */
    void send(const RobotPose& robotPose, bool sendNow = false) const;

    /**
     * This function sets the BehaviorTeamMessage field in the outgoing TeamMessage 
     * that is represented by the target
     * @param behaviorTeamMessage The BehaviorTeamMessage to be sent
     * @param sendNow bool o indicate that the message needs to be sent now
     */
    void send(const BehaviorTeamMessage& behaviorTeamMessage, bool sendNow = false) const;

    /**
     * This function sets the BehaviorTeamMessage field in the outgoing TeamMessage 
     * that is represented by the target
     * @param seenBallPosition The SeenBallPosition to be sent
       * @param sendNow bool o indicate that the message needs to be sent now
    */
    void send(const PlayersPercept& playersPercept, bool sendNow = false) const;

    /**
     * This function sets the PlayersPercept in the outgoing TeamMessage
     * @param playersPercept The PlayersPercept to be sent
     * @param sendNow bool o indicate that the message needs to be sent now
    */
    void send(const SeenBallState& seenBallState, bool sendNow = false) const;

    /**
    * This function sets the SensorBehaviorTeamMessage in the outgoing TeamMessage
    * @param sensorBehaviorTeamMessage The SensorBehaviorTeamMessage to be sent
    * @param sendNow bool to indicate that the message needs to be sent now
    */
    void send(const SensorBehaviorTeamMessage& sensorBehaviorTeamMessage, bool sendNow = false) const;

    /**
    * This function sets the SensorBehaviorTeamMessage in the outgoing TeamMessage
    * @param odometryData The OdometryData to be sent
    * @param sendNow bool to indicate that the message needs to be sent now
    */
    void send(const OdometryData& odometryData, bool sendNow = false) const;

    /**
    * This function sets the SensorBehaviorTeamMessage in the outgoing TeamMessage
    * @param multipleBallPerceptList The MultipleBallPerceptList to be sent
    * @param sendNow bool to indicate that the message needs to be sent now
    */
    void send(const MultipleBallPerceptList& multipleBallPerceptList, bool sendNow = false) const;

    /**
    * This function sets the SensorBehaviorTeamMessage in the outgoing TeamMessage
    * @param gt2005ParticleContainerSend The GT2005ParticleContainerSend to be sent
    * @param sendNow bool to indicate that the message needs to be sent now
    */
    void send(const GT2005ParticleContainerSend& gt2005ParticleContainerSend, bool sendNow = false) const;

    /**
    * This function sets the SensorBehaviorTeamMessage in the outgoing TeamMessage
    * @param robotPoseCollection The RobotPoseCollection to be sent
    * @param sendNow bool to indicate that the message needs to be sent now
    */
    void send(const RobotPoseCollection& robotPoseCollection, bool sendNow = false) const;
 
    /**
     * This function sets the ObstaclesModel in the outgoing TeamMessage
     * @param obstaclesModel The obstaclesModel to be sent
     * @param sendNow bool to indicate that the message needs to be sent now
    */
    void send(const ObstaclesModel& obstaclesModel, bool sendNow = false) const;

    /**
     * This function processes the outgoing messages.
     * @return A bool that is true when the messages should be send. 
     */
    bool processOutMessages();

    /**
     * get the delay between two subsequent sends
     */
    int getDelay() const ;
    
    /**
     * set the delay between two subsequent sends
     */
    void setDelay(int delay);

//    void send(TeamMessageMessage*) const;
//    void stop(TeamMessageMessage*) const;
    void set(TeamMessageMessageCollection*);

  protected:
  int delay; /**< the delay between two subsequent sends */
    const TeamMessage* teamMessages[maxNumberOfTeamMessages]; /**< pointer to the incomming teamMessages */
    TeamMessage* outTeamMessages[maxNumberOfTeamMessages]; /**< pointer to outgoing teamMessages */
    int teamMessagesForActualTeamMessages[maxNumberOfTeamMessages]; /**< Array to translate teamMessage number for backwards compability */
  
    unsigned lastSendingTimeStamp;    /**< TimeStamp when sending the last TeamMessage */
    unsigned teamMessageTimeStamp[maxNumberOfTeamMessages]; /**< TimeStamps of the latest incoming TeamMessages */
    unsigned incomingTimeStamp[maxNumberOfTeamMessages];    /**< Local TimeStamp of the latest incoming TeamMessages */
    
    // Attrributes for time sync
    RingBuffer<signed long,100> offsets[maxNumberOfTeamMessages]  ; /**< Ringbuffer to save the last 100 time offsets for the 3 TeamMessages */
    signed long timeOffsetSum[maxNumberOfTeamMessages];     /**< Sum of all the values in the ringBuffers */

    // Attribute for better streaming of TeamMessage
    bool messagesSent;    /**< set true if the messages have been sent */
    mutable bool sendNow;        /**< pointer to a bool which shows that the robot has to send the messages */
    long lastSendTime;    /**< time when *sendNow was last true. Used to send after a delay */

  // Count of TeamMessages for initializing

  int numberOfInTeamMessages;
  int numberOfOutTeamMessages;

    /** 
     * This method is called by processMessages() to find out the time-offsets between the robots.
     * It saves the time-difference in the corresponding TeamMessage accesed by operator[]
     */
    void processTimeStamps();

    /**
     * This method is calls by processMessages() to set the fields of the teamMessageForTarget[] array.
     * This array is used by the send-methods to find out which teamMessages send to a target.
     */
    void processMessagePlayerRole();
};

#endif //__TeamMessageCollection_h_

---