Representations/Motion/MotionRequest.h

Go to the documentation of this file.

/**
* @file MotionRequest.h
*
* This file contains the MotionRequest class as well as SpecialActionRequest and WalkingRequest classes.
*
* @author <A href=mailto:brunn@sim.informatik.tu-darmstadt.de>Ronnie Brunn</A>
* @author <A href=mailto:kuntze@sim.informatik.tu-darmstadt.de>Nicolai Kuntze</A>
* @author <A href=mailto:kunz@sim.informatik.tu-darmstadt.de>Michael Kunz</A>
* @author Max Risler
* @author Michael Spranger
*/

#ifndef __MOTIONREQUEST_H__
#define __MOTIONREQUEST_H__

#include "Tools/Streams/InOut.h"
#include "Tools/Math/Pose2D.h"


/**@name walking max speeds
*@{
* @attention These values are implementation independent maximum speeds.
* They dont reflect speeds reached with current walking engine implementations.
*
* They should be used e.g. for the Motion Tester and for the behavior to walk with
* maximum speed.
*/
/** the maximum forward speed for walk in mm/s */
static const double walkMaxForwardSpeed = 450.0;
/** the maximum backward speed for walk in mm/s */
static const double walkMaxBackwardSpeed = 350.0;
/** the maximum sideward left/right speed for walk in mm/s */
static const double walkMaxLeftRightSpeed = 400.0;
/** the maximum rotation speed for walk in rad/s */
static const double walkMaxRotationSpeed = fromDegrees(250);
/**
*@} */

/*
 *  @class
 */
class SpecialActionRequest{
public:
    /** ids for all special actions */
  enum SpecialActionID {
    //please sort alphabetically, but only these IDs here:
    anyLeft,
    armLeft,
    armRight,
    anyRight,
    backKickLeft,
    backKickRight,
    bash,
    bbHeadLeftSoft,
    bbHeadLeftStrong,
    bbHeadRightSoft,
    bbHeadRightStrong,
    block,
    blockLeft,
    blockRight,
    cheerAssShake,
    cheerHappy1,
    cheerHappy2,
    cheerHappy3,
    cheerHappy4,
    cheerHappy5,
    cheerHappy6,
    cheerHeadStand,
    cheerHowl,
    cheerLegTrick,
    cheerNodHead,
    cheerSad1,
    cheerSad2,
    cheerSad3,
    cheerSad5,
    cheerSad4,
    cheerWaveLeft,
    cheerWaveRight,
    chestHard,
    chestSoft,
    dddBlock,
    dddBlockLeft,
    dddBlockMiddleLeft,
    dddBlockMiddleRight,
    dddBlockRight,
    dddGetUpLeft,
    dddGetUpMiddleLeft,
    dddGetUpMiddleRight,
    dddGetUpMiddle,
    dddGetUpRight,
    dddDribbleLeft,
    dddDribbleRight,
    dddPushModerate,
    dddTurnLeft,
    dddTurnRight,
    demoBallOnBack1,
    demoBallOnBack2,
    demoPackHeadStand,
    demoRemoveEars,
    demoRollLeft,
    demoRollRight,
    demoScratchHead,
    demoSit,
    demoStandUpsideDown,
    forwardKickFast,
    forwardKickHard,
    headLeft,
    headLeftSoft,
    headRight,
    headRightSoft,
    hookLeft,
    hookRight,
    kickAlongArmLeft,
    kickAlongArmRight,
    kickWithBackLegLeft,
    kickWithBackLegRight,
    leftPaw,
    mshAssBomb,
    mshNeckKick,
    penaltyBlockLeft,
    penaltyBlockRight,
    pushSoft,
    pushStrong,
    putLeft,
    putRight,
    rightPaw,
    slapLeft,
    slapRight,
    snowPlow,
    swing,
    tunnelKick,
    pushFromGrab,
    bashFromGrab,
    headKickFromGrab,
    numOfSpecialAction
  };

  SpecialActionRequest():specialActionType(swing){}

  SpecialActionID specialActionType;


  /** returns names for special action ids */
  static const char* getSpecialActionIDName(SpecialActionID id)
  {
    switch (id)
    {
    case anyLeft: return "anyLeft";
    case armLeft: return "armLeft";
    case armRight: return "armRight";
    case anyRight: return "anyRight";
    case backKickLeft: return "backKickLeft";
    case backKickRight: return "backKickRight";
    case bash: return "bash";
    case bbHeadLeftSoft: return "bbHeadLeftSoft";
    case bbHeadLeftStrong: return "bbHeadLeftStrong";
    case bbHeadRightSoft: return "bbHeadRightSoft";
    case bbHeadRightStrong: return "bbHeadRightStrong";
    case block: return "block";
    case blockLeft: return "blockLeft";
    case blockRight: return "blockRight";
    case cheerAssShake: return "cheerAssShake";
    case cheerHappy1: return "cheerHappy1";
    case cheerHappy2: return "cheerHappy2";
    case cheerHappy3: return "cheerHappy3";
    case cheerHappy4: return "cheerHappy4";
    case cheerHappy5: return "cheerHappy5";
    case cheerHappy6: return "cheerHappy6";
    case cheerHeadStand: return "cheerHeadStand";
    case cheerHowl: return "cheerHowl";
    case cheerLegTrick: return "cheerLegTrick";
    case cheerNodHead: return "cheerNodHead";
    case cheerSad1: return "cheerSad1";
    case cheerSad2: return "cheerSad2";
    case cheerSad3: return "cheerSad3";
    case cheerSad5: return "cheerSad5";
    case cheerSad4: return "cheerSad4";
    case cheerWaveLeft: return "cheerWaveLeft";
    case cheerWaveRight: return "cheerWaveRight";
    case chestHard: return "chestHard";
    case chestSoft: return "chestSoft";
    case dddBlock: return "dddBlock";
    case dddBlockLeft: return "dddBlockLeft";
    case dddBlockMiddleLeft: return "dddBlockMiddleLeft";
    case dddBlockMiddleRight: return "dddBlockMiddleRight";
    case dddBlockRight: return "dddBlockRight";
    case dddGetUpLeft: return "dddGetUpLeft";
    case dddGetUpMiddleLeft: return "dddGetUpMiddleLeft";
    case dddGetUpMiddleRight: return "dddGetUpMiddleRight";
    case dddGetUpMiddle: return "dddGetUpMiddle";
    case dddGetUpRight: return "dddGetUpRight";
    case dddDribbleLeft: return "dddDribbleLeft";
    case dddDribbleRight: return "dddDribbleRight";
    case dddPushModerate: return "dddPushModerate";
    case dddTurnLeft: return "dddTurnLeft";
    case dddTurnRight: return "dddTurnRight";
    case demoBallOnBack1: return "demoBallOnBack1";
    case demoBallOnBack2: return "demoBallOnBack2";
    case demoPackHeadStand: return "demoPackHeadStand";
    case demoRemoveEars: return "demoRemoveEars";
    case demoRollLeft: return "demoRollLeft";
    case demoRollRight: return "demoRollRight";
    case demoScratchHead: return "demoScratchHead";
    case demoSit: return "demoSit";
    case demoStandUpsideDown: return "demoStandUpsideDown";
    case forwardKickFast: return "forwardKickFast";
    case forwardKickHard: return "forwardKickHard";
    case headLeft: return "headLeft";
    case headLeftSoft: return "headLeftSoft";
    case headRight: return "headRight";
    case headRightSoft: return "headRightSoft";
    case hookLeft: return "hookLeft";
    case hookRight: return "hookRight";
    case kickAlongArmLeft: return "kickAlongArmLeft";
    case kickAlongArmRight: return "kickAlongArmRight";
    case kickWithBackLegLeft: return "kickWithBackLegLeft";
    case kickWithBackLegRight: return "kickWithBackLegRight";
    case leftPaw: return "leftPaw";
    case mshAssBomb: return "mshAssBomb";
    case mshNeckKick: return "mshNeckKick";
    case penaltyBlockLeft: return "penaltyBlockLeft";
    case penaltyBlockRight: return "penaltyBlockRight";
    case pushSoft: return "pushSoft";
    case pushStrong: return "pushStrong";
    case putLeft: return "putLeft";
    case putRight: return "putRight";
    case rightPaw: return "rightPaw";
    case slapLeft: return "slapLeft";
    case slapRight: return "slapRight";
    case snowPlow: return "snowPlow";
    case swing: return "swing";
    case tunnelKick: return "tunnelKick";
    case pushFromGrab: return "pushFromGrab";
    case bashFromGrab: return "bashFromGrab";
    case headKickFromGrab: return "headKickFromGrab";

    default: return "please edit MotionRequest::getSpecialActionName";
    }
  }

  /**
  * Returns the special action id for a name
  */
  static SpecialActionRequest::SpecialActionID getSpecialActionIDFromName(const char* name);
};

class WalkRequest{
public:
    /** ids for all walking types */
  enum WalkType {
      normal,
      upsideDown,
      turnWithBall,
      turnKick,
      dash,
      debug,
      boost,
      walkWithBall,
      gt2004mode,
      numOfWalkType
  };

  WalkRequest():walkType(normal) {}

  /** walking type */
  WalkType walkType;

  /** walk parameters, in mm/s / rad/s */
  Pose2D walkParams;

  /** returns names for walking types */
  static const char* getWalkTypeName(WalkType id)
  {
    switch (id)
    {
    case normal: return "normal";
    case upsideDown: return "upsideDown";
    case turnWithBall: return "turnWithBall";
    case turnKick: return "turnKick";
    case dash: return "dash";
    case debug: return "debug";
    case boost: return "boost";
    case walkWithBall: return "walkWithBall";
    case gt2004mode: return "gt2004mode";
    default: return "Unknown motion name, please edit MotionRequest::getWalkTypeName";
    }
  }
};

class TailRequest{
public:
    enum TailRequestID
  {
      wagHorizontal,
      wagVertical,
      wagLeftRightHorizontal,
      wagLeftRightVertical,
      wagUpDownLeft,
      wagUpDownRight,
      stayAsForced,
      stayAsForcedPan,
      stayAsForcedTilt,
      tailFollowsHead,
      tailParallelToGround,
      noTailWag,
      wagHorizontalFast,
      wagVerticalFast,
      twoPositionSwitchVertical,
      twoPositionSwitchHorizontal,
      threePositionSwitchVertical,
      threePositionSwitchHorizontal,
      fourPositionSwitchUpDownLeftRight,
      fourPositionSwitchCorners,
      fivePositionSwitch,
      eightPositionSwitch,
      tailLeftTop,    tailCenterTop,    tailRightTop,
      tailLeftCenter, tailCenterCenter, tailRightCenter,
      tailLeftBottom, tailCenterBottom, tailRightBottom,
      numOfTailRequests
  };

  TailRequest():tailRequestID(wagHorizontal){}

  /** tail request */
  TailRequestID tailRequestID;



  /** ids for tail request */
  /** returns names for tail requests */
  static const char* getTailRequestIDName(TailRequestID id)
  {
    switch (id)
    {
    case wagHorizontal: return "wagHorizontal";
    case wagVertical: return "wagVertical";
    case wagLeftRightHorizontal: return "wagLeftRightHorizontal";
    case wagLeftRightVertical: return "wagLeftRightVertical";
    case wagUpDownLeft: return "wagUpDownLeft";
    case wagUpDownRight: return "wagUpDownRight";
    case stayAsForced: return "stayAsForced";
    case stayAsForcedPan: return "stayAsForcedPan";
    case stayAsForcedTilt: return "stayAsForcedTilt";
    case tailFollowsHead: return "tailFollowsHead";
    case tailParallelToGround: return "tailParallelToGround";
    case noTailWag: return "noTailWag";
    case wagHorizontalFast: return "wagHorizontalFast";
    case wagVerticalFast: return "wagVerticalFast";
    case twoPositionSwitchVertical: return "twoPositionSwitchVertical";
    case twoPositionSwitchHorizontal: return "twoPositionSwitchHorizontal";
    case threePositionSwitchVertical: return "threePositionSwitchVertical";
    case threePositionSwitchHorizontal: return "threePositionSwitchHorizontal";
    case fourPositionSwitchUpDownLeftRight: return "fourPositionSwitchUpDownLeftRight";
    case fourPositionSwitchCorners: return "fourPositionSwitchCorners";
    case fivePositionSwitch: return "fivePositionSwitch";
    case eightPositionSwitch: return "eightPositionSwitch";
    case tailLeftTop: return "tailLeftTop";
    case tailCenterTop: return "tailCenterTop";
    case tailRightTop: return "tailRightTop";
    case tailLeftCenter: return "tailLeftCenter";
    case tailCenterCenter: return "tailCenterCenter";
    case tailRightCenter: return "tailRightCenter";
    case tailLeftBottom: return "tailLeftBottom";
    case tailCenterBottom: return "tailCenterBottom";
    case tailRightBottom: return "tailRightBottom";

    default: return "Unknown tail request, please edit MotionRequest::getTailRequestName";
    }
  }

};
/**
* This describes the MotionRequest
*/
class MotionRequest : public Streamable
{
public:
  virtual void serialize( In* in, Out* out)
  {  
    STREAM_REGISTER_BEGIN( );
    STREAM( frameNumber);
    STREAM_ENUM( motionType, numOfMotion, MotionRequest::getMotionName);
    STREAM_ENUM( walkRequest.walkType, walkRequest.numOfWalkType, WalkRequest::getWalkTypeName);
    STREAM( walkRequest.walkParams);
    STREAM_ENUM( specialActionRequest.specialActionType, specialActionRequest.numOfSpecialAction, SpecialActionRequest::getSpecialActionIDName);
    STREAM_ENUM( tailRequest.tailRequestID, tailRequest.numOfTailRequests, TailRequest::getTailRequestIDName);
    STREAM( stabilize);
    STREAM( padding);
    STREAM_REGISTER_FINISH();
  }

  unsigned long frameNumber;

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


  /** ids for all motion types */
  enum MotionID {
    stand,
    walk,
    specialAction,
    getup,
    playDead,
    numOfMotion
  };

  /** returns names for motion ids */
  static const char* getMotionName(MotionID id)
  {
    switch (id)
    {
    case playDead: return "playDead";
    case stand: return "stand";
    case walk: return "walk";
    case specialAction: return "specialAction";
    case getup: return "getup";

    default: return "Unknown motion name, please edit MotionRequest::getMotionName";
    }
  }

  /** motion type */
  MotionID motionType;

  /** SpecialActionRequest */
  SpecialActionRequest specialActionRequest;

  TailRequest tailRequest;

  WalkRequest walkRequest;





  /** constructor, startup motion defined here */
  MotionRequest():motionType(playDead),stabilize(false),updateRP(true),frameNumber(0) {}

  /** == operator */
  bool operator==(const MotionRequest& other) const
  {
    switch (motionType)
    {
    case stand:
    case getup:
    default:
      return (
        motionType == other.motionType &&
        stabilize == other.stabilize);
    case walk:
      return (walkRequest.walkParams == other.walkRequest.walkParams &&
        stabilize == other.stabilize &&
        motionType == other.motionType &&
        walkRequest.walkType == other.walkRequest.walkType);
    case specialAction:
      return (
        stabilize == other.stabilize &&
        motionType == other.motionType &&
        specialActionRequest.specialActionType == other.specialActionRequest.specialActionType);
    }
  }

  /** = operator */
  void operator=(const MotionRequest& other);

  /** determines if the motion is being stabilized */
  bool stabilize;

  /** turns on or off the propagation (by odometry) of the "robot pose"
  in the "motion" process */
  bool updateRP;

  /** returns name of current motion */
  const char* getMotionName() const {return getMotionName(motionType);};

  /** returns name of current special action if any */
  const char* getSpecialActionName() const
  {
    if (motionType == specialAction)
      return specialActionRequest.getSpecialActionIDName(specialActionRequest.specialActionType);
    else
      return "";
  };

  /** return name of current walking type if any */
  const char* getWalkTypeName() const
  {
    if (motionType == walk)
      return walkRequest.getWalkTypeName(walkRequest.walkType);
    else
      return "";
  }

  /**
  * Prints the motion request to a readable string. (E.g. "NormalWalk 100,0,0")
  * @param destination The string to fill
  */
  void printOut(char* destination) const;

  int padding; /**< Without this padding, the gcc-version crashes. */
};

/**
* Streaming operator that reads a MotionRequest from a stream.
* @param stream The stream from which is read.
* @param motionRequest The MotionRequest object.
* @return The stream.
*/
// In& operator>>(In& stream,MotionRequest& motionRequest);

/**
* Streaming operator that writes a MotionRequest to a stream.
* @param stream The stream to write on.
* @param motionRequest The MotionRequest object.
* @return The stream.
*/
// Out& operator<<(Out& stream, const MotionRequest& motionRequest);

#endif // __MOTIONREQUEST_H__

---