Representations/Cognition/RobotState.h

Go to the documentation of this file.

/**
 * @file RobotState.h
 * 
 * Declaration of class RobotState
 */ 

#ifndef __RobotState_h_
#define __RobotState_h_


#include "Tools/Streams/InOut.h"
#include "Tools/Math/Vector3.h"
#include "Representations/Perception/BodyPercept.h"

/**
 * A class describing detected button messages and whether robot is crashed
 */
class RobotState
{
public:
  enum States { undefined, standing, crashed, rollLeft, rollRight, pickedUp };
  enum MouthStates { mouthOpen, mouthClosed };
  
  Vector3<double> acceleration;

  RobotState();
  ~RobotState();

  unsigned long frameNumber;
  void setFrameNumber(unsigned long frameNumber) {this->frameNumber = frameNumber;}

  void setState(const States s) {state = s;}
  States getState() const {return state;}

  void setMouthState(const MouthStates t) {mouthState = t;}
  MouthStates getMouthState() const {return mouthState;}

  void setSomethingInFrontOfChest(bool value) {somethingInFrontOfChest = value;}
  bool getSomethingInFrontOfChest() const {return somethingInFrontOfChest;}

  void setDistanceToSIFOC(double value) {distanceToSIFOC = value;}
  double getDistanceToSIFOC() const {return distanceToSIFOC;}

  void setTimeWhenSomethingWasInFrontOfChestLast(unsigned long int time) {timeWhenSomethingWasInFrontOfChestLast = time;}
  unsigned long int getTimeWhenSomethingWasInFrontOfChestLast() const {return timeWhenSomethingWasInFrontOfChestLast;}

  void setButtonPressed(bool* buttonPressed)
  {
    for(int i = 0; i < BodyPercept::numOfSwitches; i++)
    {
      this->buttonPressed[i] = buttonPressed[i];
    }
  }
  bool getButtonPressed(BodyPercept::Switches button) const 
  {
    return buttonPressed[button];
  }

  void setButtonTime(long* buttonTime)
  {
    for(int i = 0; i < BodyPercept::numOfSwitches; i++)
    {
      this->buttonTime[i] = buttonTime[i];
    }
  }
  long getButtonTime(BodyPercept::Switches button) const 
  {
    return buttonTime[button];
  }

  void setButtonPressedTime(long* buttonPressedTime)
  {
    for(int i = 0; i < BodyPercept::numOfSwitches; i++)
    {
      this->buttonPressedTime[i] = buttonPressedTime[i];
    }
  }
  long getButtonPressedTime(BodyPercept::Switches button) const
  {
    return buttonPressedTime[button];
  }

  void setButtonDuration(long* buttonDuration)
  {
    for(int i = 0; i < BodyPercept::numOfSwitches; i++)
    {
      this->buttonDuration[i] = buttonDuration[i];
    }
  }
  long getButtonDuration(BodyPercept::Switches button) const
  {
    return buttonDuration[button];
  }

  void setAnyBackButtonPressed(bool anyBackButtonPressed)
  {
    this->anyBackButtonPressed = anyBackButtonPressed;
  }
  bool getAnyBackButtonPressed() const 
  {
    return anyBackButtonPressed;
  }

  void setAnyBackButtonTime(long anyBackButtonTime)
  {
    this->anyBackButtonTime = anyBackButtonTime;
  }
  long getAnyBackButtonTime() const 
  {
    return anyBackButtonTime;
  }

  void setAnyBackButtonPressedTime(long anyBackButtonPressedTime)
  {
    this->anyBackButtonPressedTime = anyBackButtonPressedTime;
  }
  long getAnyBackButtonPressedTime() const
  {
    return anyBackButtonPressedTime;
  }

  void setAnyBackButtonDuration(long anyBackButtonDuration)
  {
    this->anyBackButtonDuration = anyBackButtonDuration;
  }
  long getAnyBackButtonDuration() const
  {
    return anyBackButtonDuration;
  }

  /** copies another RobotState to this one */
  void operator = (const RobotState& other);

  static const char* getStateName(States s)
  {
    switch(s)
    {
      case undefined: return "undefined";
      case standing: return "standing";
      case crashed: return "crashed";
      case rollLeft: return "rollLeft";
      case rollRight: return "rollRight";
      case pickedUp: return "pickedUp";
      default: return "please edit RobotState::getStateName";
    }
  }

  void setCollisionFrontLeft(bool c) {collisionFrontLeft = c;}
  bool getCollisionFrontLeft() const {return collisionFrontLeft;}

  void setCollisionFrontRight(bool c) {collisionFrontRight = c;}
  bool getCollisionFrontRight() const {return collisionFrontRight;}

  void setCollisionHindLeft(bool c) {collisionHindLeft = c;}
  bool getCollisionHindLeft() const {return collisionHindLeft;}

  void setCollisionHindRight(bool c) {collisionHindRight = c;}
  bool getCollisionHindRight() const {return collisionHindRight;}

  void setCollisionHead(bool c) {collisionHead = c;}
  bool getCollisionHead() const {return collisionHead;}

  void setCollisionAggregate(bool c) {collisionAggregate = c;}
  bool getCollisionAggregate() const {return collisionAggregate;}

  void setOdometryDisturbance(double c) {odometryDisturbance = c;}
  double getOdometryDisturbance() const {return odometryDisturbance;}

  void setConsecutiveCollisionTimeFrontLeft(long c) {consecutiveCollisionTimeFrontLeft = c;}
  long getConsecutiveCollisionTimeFrontLeft() const {return consecutiveCollisionTimeFrontLeft;}

  void setConsecutiveCollisionTimeFrontRight(long c) {consecutiveCollisionTimeFrontRight = c;}
  long getConsecutiveCollisionTimeFrontRight() const {return consecutiveCollisionTimeFrontRight;}

  void setConsecutiveCollisionTimeHindLeft(long c) {consecutiveCollisionTimeHindLeft = c;}
  long getConsecutiveCollisionTimeHindLeft() const {return consecutiveCollisionTimeHindLeft;}

  void setConsecutiveCollisionTimeHindRight(long c) {consecutiveCollisionTimeHindRight = c;}
  long getConsecutiveCollisionTimeHindRight() const {return consecutiveCollisionTimeHindRight;}

  void setConsecutiveCollisionTimeHead(long c) {consecutiveCollisionTimeHead = c;}
  long getConsecutiveCollisionTimeHead() const {return consecutiveCollisionTimeHead;}

  void setConsecutiveCollisionTimeAggregate(long c) {consecutiveCollisionTimeAggregate = c;}
  long getConsecutiveCollisionTimeAggregate() const {return consecutiveCollisionTimeAggregate;}

  void setCollisionSide(int s) {collisionSide = s;}
  long getCollisionSide() const {return collisionSide;}


private:

  /**
   * current state of robot position
   * if crashed or standing
   */
  States state;

  /**
   * current state of the mouth
   */
  MouthStates mouthState;

   /**
   * collision indicator of front left leg
   */
  bool collisionFrontLeft;

  /**
   * collision indicator of front right leg
   */
  bool collisionFrontRight;

  /**
   * collision indicator of hind left leg
   */
  bool collisionHindLeft;

  /**
   * collision indicator of hind right leg
   */
  bool collisionHindRight;

  /**
   * collision indicator of head
   */
  bool collisionHead;

   /**
   * collision indicator of collision occurrence
   */
  bool collisionAggregate;

   /**
   * indicator of odometry disturbance
   */
  double odometryDisturbance;

   /**
   * Time for last consecutive collision on front left leg
   */
  long consecutiveCollisionTimeFrontLeft;

  /**
   * Time for last consecutive collision on front right leg
   */
  long consecutiveCollisionTimeFrontRight;

   /**
   * Time for last consecutive collision on hind left leg
   */
  long consecutiveCollisionTimeHindLeft;

  /**
   * Time for last consecutive collision on hind right leg
   */
  long consecutiveCollisionTimeHindRight;

   /**
   * Time for last consecutive collision on head
   */
  long consecutiveCollisionTimeHead;

   /**
   * Time for last consecutive collision aggregate
   */
  long consecutiveCollisionTimeAggregate;

   /**
   * collision occured on side
   */
  long collisionSide;


  /***/
  bool buttonPressed[BodyPercept::numOfSwitches]; //0 Button not pressed, 1 Button pressed
  unsigned long buttonTime[BodyPercept::numOfSwitches]; // The time as the button was pressed/released
  unsigned long buttonPressedTime[BodyPercept::numOfSwitches]; // How long the last button was pressed (after releasing it)
  unsigned long buttonDuration[BodyPercept::numOfSwitches]; // How long the button is pressed/released
  bool anyBackButtonPressed;  // The same information for any backbutton
  unsigned long anyBackButtonTime;
  unsigned long anyBackButtonPressedTime;
  unsigned long anyBackButtonDuration;
  /***/

  /** Indicates whether something has been measured by the body PSD or not*/
  bool somethingInFrontOfChest;

  /** The distance of objects in front of the body PSD*/
  double distanceToSIFOC;
  
  /** The last time when something has been measured by the body PSD */
  unsigned long int timeWhenSomethingWasInFrontOfChestLast;
};

/**
 * Streaming operator that reads a RobotState from a stream.
 * @param stream The stream from which is read.
 * @param robotState The RobotState object.
 * @return The stream.
 */ 
In& operator>>(In& stream,RobotState& robotState);
 
/**
 * Streaming operator that writes a RobotState to a stream.
 * @param stream The stream to write on.
 * @param robotState The RobotState object.
 * @return The stream.
 */ 
Out& operator<<(Out& stream, const RobotState& robotState);


#endif //__RobotState_h_

---