ArModes.h

/*
ActivMedia Robotics Interface for Applications (ARIA)
Copyright (C) 2004,2005 ActivMedia Robotics, LLC


     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

If you wish to redistribute ARIA under different terms, contact 
ActivMedia Robotics for information about a commercial version of ARIA at 
robots@activmedia.com or 
ActivMedia Robotics, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481

*/

#ifndef ARMODES_H
#define ARMODES_H

#include "ariaTypedefs.h"
#include "ArMode.h"
#include "ArActionGroups.h"
#include "ArGripper.h"
#include "ArTcpConnection.h"
#include "ArSerialConnection.h"
#include "ArPTZ.h"
#include "ArTCM2.h"

class ArTCM2;
class ArACTS_1_2;
class ArRobotPacket;
class ArSick;
class ArAnalogGyro;

class ArModeTeleop : public ArMode
{
public:
  ArModeTeleop(ArRobot *robot, const char *name, char key, char key2);
  virtual ~ArModeTeleop();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void help(void);
  virtual void userTask(void);
protected:
  //ArActionGroupTeleop myGroup;
  // use our new ratio drive instead
  ArActionGroupRatioDrive myGroup;
};

class ArModeUnguardedTeleop : public ArMode
{
public:
  ArModeUnguardedTeleop(ArRobot *robot, const char *name, char key, char key2);
  virtual ~ArModeUnguardedTeleop();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void help(void);
  virtual void userTask(void);
protected:
  //ArActionGroupUnguardedTeleop myGroup;
  // use our new ratio drive instead
  ArActionGroupRatioDriveUnsafe myGroup;
};

class ArModeWander : public ArMode
{
public:
  ArModeWander(ArRobot *robot, const char *name, char key, char key2);
  virtual ~ArModeWander();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void help(void);
  virtual void userTask(void);
protected:
  ArActionGroupWander myGroup;
};

class ArModeGripper : public ArMode
{
public:
  ArModeGripper(ArRobot *robot, const char *name, char key,
                         char key2);
  virtual ~ArModeGripper();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void userTask(void);
  virtual void help(void);
  void open(void);
  void close(void);
  void up(void);
  void down(void);
  void stop(void);
  void exercise(void);
protected:
  enum ExerState {
    UP_OPEN,
    UP_CLOSE,
    DOWN_CLOSE,
    DOWN_OPEN
  };
  ArGripper myGripper;
  bool myExercising;
  ExerState myExerState;
  ArTime myLastExer;
  ArFunctorC<ArModeGripper> myOpenCB;
  ArFunctorC<ArModeGripper> myCloseCB;
  ArFunctorC<ArModeGripper> myUpCB;
  ArFunctorC<ArModeGripper> myDownCB;
  ArFunctorC<ArModeGripper> myStopCB;
  ArFunctorC<ArModeGripper> myExerciseCB;
  
};

class ArModeCamera : public ArMode
{
public:
  ArModeCamera(ArRobot *robot, const char *name, char key,
                         char key2);
  virtual ~ArModeCamera();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void userTask(void);
  virtual void help(void);
  void up(void);
  void down(void);
  void left(void);
  void right(void);
  void center(void);
  void zoomIn(void);
  void zoomOut(void);
  void exercise(void);
  void sony(void);
  void canon(void);
  void dpptu(void);
  void amptu(void);
  void canonInverted(void);
  void sonySerial(void);
  void canonSerial(void);
  void dpptuSerial(void);
  void amptuSerial(void);
  void canonInvertedSerial(void);
  void com1(void);
  void com2(void);
  void com3(void);
  void com4(void);
  void aux1(void);
  void aux2(void);
protected:
  void takeCameraKeys(void);
  void giveUpCameraKeys(void);
  void helpCameraKeys(void);
  void takePortKeys(void);
  void giveUpPortKeys(void);
  void helpPortKeys(void);
  void takeAuxKeys(void);
  void giveUpAuxKeys(void);
  void helpAuxKeys(void);
  void takeMovementKeys(void);
  void giveUpMovementKeys(void);
  void helpMovementKeys(void);
  enum State {
    STATE_CAMERA,
    STATE_PORT,
    STATE_MOVEMENT
  };
  void cameraToMovement(void);
  void cameraToPort(void);
  void cameraToAux(void);
  void portToMovement(void);
  void auxToMovement(void);
  enum ExerState {
    CENTER,
    UP_LEFT,
    UP_RIGHT,
    DOWN_RIGHT,
    DOWN_LEFT
  };

  bool myExercising;
  State myState;
  ExerState myExerState;
  ArTime myLastExer;
  bool myExerZoomedIn;
  ArTime myLastExerZoomed;
  ArSerialConnection myConn;
  ArPTZ *myCam;
  ArFunctorC<ArModeCamera> myUpCB;
  ArFunctorC<ArModeCamera> myDownCB;
  ArFunctorC<ArModeCamera> myLeftCB;
  ArFunctorC<ArModeCamera> myRightCB;
  ArFunctorC<ArModeCamera> myCenterCB;
  ArFunctorC<ArModeCamera> myZoomInCB;
  ArFunctorC<ArModeCamera> myZoomOutCB;
  ArFunctorC<ArModeCamera> myExerciseCB;
  ArFunctorC<ArModeCamera> mySonyCB;
  ArFunctorC<ArModeCamera> myCanonCB;
  ArFunctorC<ArModeCamera> myDpptuCB;
  ArFunctorC<ArModeCamera> myAmptuCB;
  ArFunctorC<ArModeCamera> myCanonInvertedCB;
  ArFunctorC<ArModeCamera> mySonySerialCB;
  ArFunctorC<ArModeCamera> myCanonSerialCB;
  ArFunctorC<ArModeCamera> myDpptuSerialCB;
  ArFunctorC<ArModeCamera> myAmptuSerialCB;
  ArFunctorC<ArModeCamera> myCanonInvertedSerialCB;
  ArFunctorC<ArModeCamera> myCom1CB;
  ArFunctorC<ArModeCamera> myCom2CB;
  ArFunctorC<ArModeCamera> myCom3CB;
  ArFunctorC<ArModeCamera> myCom4CB;
  ArFunctorC<ArModeCamera> myAux1CB;
  ArFunctorC<ArModeCamera> myAux2CB;
  
};

class ArModeSonar : public ArMode
{
public:
  ArModeSonar(ArRobot *robot, const char *name, char key, char key2);
  virtual ~ArModeSonar();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void userTask(void);
  virtual void help(void);
  void allSonar(void);
  void firstSonar(void);
  void secondSonar(void);
  void thirdSonar(void);
  void fourthSonar(void);
protected:
  enum State 
  {
    STATE_ALL,
    STATE_FIRST,
    STATE_SECOND,
    STATE_THIRD,
    STATE_FOURTH
  };
  State myState;
  ArFunctorC<ArModeSonar> myAllSonarCB;
  ArFunctorC<ArModeSonar> myFirstSonarCB;
  ArFunctorC<ArModeSonar> mySecondSonarCB;
  ArFunctorC<ArModeSonar> myThirdSonarCB;
  ArFunctorC<ArModeSonar> myFourthSonarCB;
};

class ArModeBumps : public ArMode
{
public:
  ArModeBumps(ArRobot *robot, const char *name, char key, char key2);
  ~ArModeBumps();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void userTask(void);
  virtual void help(void);
};

class ArModePosition : public ArMode
{
public:
  ArModePosition(ArRobot *robot, const char *name, char key,
                          char key2, ArAnalogGyro *gyro = NULL);
  ~ArModePosition();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void userTask(void);
  virtual void help(void);
  void up(void);
  void down(void);
  void left(void);
  void right(void);
  void stop(void);
  void reset(void);
  void mode(void);
  void gyro(void);
  void incDistance(void);
  void decDistance(void);
protected:
  enum Mode { MODE_BOTH, MODE_EITHER };
  ArAnalogGyro *myGyro;
  double myGyroZero;
  double myRobotZero;
  Mode myMode;
  std::string myModeString;
  bool myInHeadingMode;
  double myHeading;
  double myDistance;
  ArFunctorC<ArModePosition> myUpCB;
  ArFunctorC<ArModePosition> myDownCB;
  ArFunctorC<ArModePosition> myLeftCB;
  ArFunctorC<ArModePosition> myRightCB;
  ArFunctorC<ArModePosition> myStopCB;  
  ArFunctorC<ArModePosition> myResetCB;  
  ArFunctorC<ArModePosition> myModeCB;
  ArFunctorC<ArModePosition> myGyroCB;
  ArFunctorC<ArModePosition> myIncDistCB;
  ArFunctorC<ArModePosition> myDecDistCB;
};

class ArModeIO : public ArMode
{
public:
  ArModeIO(ArRobot *robot, const char *name, char key,
                          char key2);
  ~ArModeIO();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void userTask(void);
  virtual void help(void);
protected:
  bool myExplanationReady;
  bool myExplained;
  ArTime myLastPacketTime;
  char myExplanation[1024];
  char myOutput[1024];
  ArFunctorC<ArModeIO> myProcessIOCB;
};

class ArModeLaser : public ArMode
{
public:
  ArModeLaser(ArRobot *robot, const char *name, char key,
                       char key2, ArSick *sick);
  ~ArModeLaser();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void userTask(void);
  virtual void help(void);
  void failedConnect(void);
protected:
  enum State {
    STATE_UNINITED,
    STATE_CONNECTING,
    STATE_CONNECTED
  };
  State myState;
  ArSick *mySick;
  bool myInitializedLaser;
  bool myConnectingLaser;
  ArFunctorC<ArModeLaser> myFailedConnectCB;
};

class ArModeActs : public ArMode
{
public:
  ArModeActs(ArRobot *robot, const char *name, char key, char key2,
                      ArACTS_1_2 *acts = NULL);
  virtual ~ArModeActs();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void help(void);
  virtual void userTask(void);
  virtual void channel1(void);
  virtual void channel2(void);
  virtual void channel3(void);
  virtual void channel4(void);
  virtual void channel5(void);
  virtual void channel6(void);
  virtual void channel7(void);
  virtual void channel8(void);
  virtual void stop(void);
  virtual void start(void);
  virtual void toggleAcquire(void);
  
protected:
  ArActionGroupColorFollow *myGroup;
  ArPTZ *camera;
  ArACTS_1_2 *myActs;
  ArRobot *myRobot;

  ArFunctorC<ArModeActs> myChannel1CB;
  ArFunctorC<ArModeActs> myChannel2CB;
  ArFunctorC<ArModeActs> myChannel3CB;
  ArFunctorC<ArModeActs> myChannel4CB;
  ArFunctorC<ArModeActs> myChannel5CB;
  ArFunctorC<ArModeActs> myChannel6CB;
  ArFunctorC<ArModeActs> myChannel7CB;
  ArFunctorC<ArModeActs> myChannel8CB;
  ArFunctorC<ArModeActs> myStopCB;
  ArFunctorC<ArModeActs> myStartCB;
  ArFunctorC<ArModeActs> myToggleAcquireCB;
};

class ArModeCommand : public ArMode
{
public:
  ArModeCommand(ArRobot *robot, const char *name, char key,
                          char key2);
  ~ArModeCommand();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void help(void);
protected:
  void takeKeys(void);
  void giveUpKeys(void);
  void addChar(int ch);
  void finishParsing(void);
  void reset(bool print = true);
  char myCommandString[70];
  ArFunctor1C<ArModeCommand, int> my0CB;
  ArFunctor1C<ArModeCommand, int> my1CB;
  ArFunctor1C<ArModeCommand, int> my2CB;
  ArFunctor1C<ArModeCommand, int> my3CB;
  ArFunctor1C<ArModeCommand, int> my4CB;
  ArFunctor1C<ArModeCommand, int> my5CB;
  ArFunctor1C<ArModeCommand, int> my6CB;
  ArFunctor1C<ArModeCommand, int> my7CB;
  ArFunctor1C<ArModeCommand, int> my8CB;
  ArFunctor1C<ArModeCommand, int> my9CB;
  ArFunctor1C<ArModeCommand, int> myMinusCB;
  ArFunctor1C<ArModeCommand, int> myBackspaceCB;
  ArFunctor1C<ArModeCommand, int> mySpaceCB;
  ArFunctorC<ArModeCommand> myEnterCB;

};

class ArModeTCM2 : public ArMode
{
public:
  ArModeTCM2(ArRobot *robot, const char *name, char key, char key2,
                      ArTCM2 *tcm2 = NULL);
  virtual ~ArModeTCM2();
  virtual void activate(void);
  virtual void deactivate(void);
  virtual void help(void);
  virtual void userTask(void);
  
protected:
  ArTCM2 *myTCM2;
  ArRobot *myRobot;
  ArFunctorC<ArTCM2> *myOffCB;
  ArFunctorC<ArTCM2> *myCompassCB;
  ArFunctorC<ArTCM2> *myOnePacketCB;
  ArFunctorC<ArTCM2> *myContinuousPacketsCB;
  ArFunctorC<ArTCM2> *myUserCalibrationCB;
  ArFunctorC<ArTCM2> *myAutoCalibrationCB;
  ArFunctorC<ArTCM2> *myStopCalibrationCB;
  ArFunctorC<ArTCM2> *myResetCB;

};


#endif // ARMODES_H

---