ArP2Arm.h

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     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 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/

#ifndef ARP2ARM_H
#define ARP2ARM_H

#include "ArRobot.h"
#include "ariaTypedefs.h"
#include "ArSerialConnection.h"
#include "ariaOSDef.h"

// P2 Arm classes: ArP2Arm for control and ArP2ArmJoints for P2 Arm joint data

class P2ArmJoint
{
public:

  AREXPORT P2ArmJoint();
  AREXPORT virtual ~P2ArmJoint();

  ArTypes::UByte myPos;
  ArTypes::UByte myVel;
  ArTypes::UByte myHome;
  ArTypes::UByte myMin;
  ArTypes::UByte myCenter;
  ArTypes::UByte myMax;
  ArTypes::UByte myTicksPer90;
};


class ArP2Arm
{
public:

  typedef enum {
    SUCCESS, 
    ALREADY_INITED, 
    NOT_INITED, 
    ROBOT_NOT_SETUP, 
    NO_ARM_FOUND, 
    COMM_FAILED, 
    COULD_NOT_OPEN_PORT, 
    COULD_NOT_SET_UP_PORT, 
    ALREADY_CONNECTED, 
    NOT_CONNECTED, 
    INVALID_JOINT, 
    INVALID_POSITION 
    } State;

  typedef enum {
    StatusPacket, 
    InfoPacket 
  } PacketType;

  typedef enum
  {
    StatusOff=0, 
    StatusSingle=1, 
    StatusContinuous=2 
  } StatusType;

  AREXPORT static const int ArmJoint1;
  AREXPORT static const int ArmJoint2;
  AREXPORT static const int ArmJoint3;
  AREXPORT static const int ArmJoint4;
  AREXPORT static const int ArmJoint5;
  AREXPORT static const int ArmJoint6;
  AREXPORT static const int ArmGood;
  AREXPORT static const int ArmInited;
  AREXPORT static const int ArmPower;
  AREXPORT static const int ArmHoming;
  AREXPORT static int NumJoints;

  AREXPORT ArP2Arm();

  AREXPORT virtual ~ArP2Arm();

  AREXPORT void setRobot(ArRobot *robot) {myRobot=robot;}

  AREXPORT virtual State init();

  AREXPORT virtual State uninit();

  AREXPORT virtual State powerOn(bool doWait=true);

  AREXPORT virtual State powerOff();

  AREXPORT virtual State requestInfo();

  AREXPORT virtual State requestStatus(StatusType status);

  AREXPORT virtual State requestInit();

  AREXPORT virtual State checkArm(bool waitForResponse=true);

  AREXPORT virtual State home(int joint=-1);

  AREXPORT virtual State park();

  AREXPORT virtual State moveTo(int joint, float pos, unsigned char vel=0);

  AREXPORT virtual State moveToTicks(int joint, unsigned char pos);

  AREXPORT virtual State moveStep(int joint, float pos, unsigned char vel=0);

  AREXPORT virtual State moveStepTicks(int joint, signed char pos);

  AREXPORT virtual State moveVel(int joint, int vel);

  AREXPORT virtual State stop();

  AREXPORT virtual State setAutoParkTimer(int waitSecs);

  AREXPORT virtual State setGripperParkTimer(int waitSecs);

  AREXPORT virtual void setStoppedCB(ArFunctor *func) {myStoppedCB=func;}

  AREXPORT virtual void setPacketCB(ArFunctor1<PacketType> *func)
    {myPacketCB=func;}

  AREXPORT virtual std::string getArmVersion() {return(myVersion);}

  AREXPORT virtual float getJointPos(int joint);

  AREXPORT virtual unsigned char getJointPosTicks(int joint);

  AREXPORT virtual bool getMoving(int joint=-1);

  AREXPORT virtual bool isPowered();

  AREXPORT virtual bool isGood();

  AREXPORT virtual int getStatus() {return(myStatus);}

  AREXPORT virtual ArTime getLastStatusTime() {return(myLastStatusTime);}

  AREXPORT virtual ArRobot * getRobot() {return(myRobot);}

  AREXPORT virtual P2ArmJoint * getJoint(int joint);

  AREXPORT virtual bool convertDegToTicks(int joint, float pos,
                      unsigned char *ticks);

  AREXPORT virtual bool convertTicksToDeg(int joint, unsigned char pos,
                      float *degrees);


protected:

  // AROS/P2OS parameters
  static const unsigned int ARMpac;
  static const unsigned int ARMINFOpac;
  static const unsigned char ComArmInfo;
  static const unsigned char ComArmStats;
  static const unsigned char ComArmInit;
  static const unsigned char ComArmCheckArm;
  static const unsigned char ComArmPower;
  static const unsigned char ComArmHome;
  static const unsigned char ComArmPark;
  static const unsigned char ComArmPos;
  static const unsigned char ComArmSpeed;
  static const unsigned char ComArmStop;
  static const unsigned char ComArmAutoPark;
  static const unsigned char ComArmGripperPark;

  bool comArmInfo();
  bool comArmStats(StatusType stats=StatusSingle);
  bool comArmInit();
  bool comArmCheckArm();
  bool comArmPower(bool on);
  bool comArmHome(unsigned char joint=0xff);
  bool comArmPark();
  bool comArmPos(unsigned char joint, unsigned char pos);
  bool comArmSpeed(unsigned char joint, unsigned char speed);
  bool comArmStop(unsigned char joint=0xff);
  bool comArmAutoPark(int waitSecs);
  bool comArmGripperPark(int waitSecs);

  bool armPacketHandler(ArRobotPacket *packet);

  bool myInited;
  ArRobot *myRobot;
  //  ArmP2Model myModel;
  ArTime myLastStatusTime;
  ArTime myLastInfoTime;
  std::string myVersion;
  StatusType myStatusRequest;
  ArTypes::UByte2 myLastStatus;
  ArTypes::UByte2 myStatus;
  ArSerialConnection myCon;
  ArRetFunctorC<State, ArP2Arm> myAriaUninitCB;
  ArRetFunctor1C<bool, ArP2Arm, ArRobotPacket*> myArmPacketHandler;
  ArFunctor1<PacketType> *myPacketCB;
  ArFunctor *myStoppedCB;

  // We have 6 joints. Including the gripper. It's here so that we can
  // store its position even though its not really a joint.
  P2ArmJoint myJoints[6];
};

#endif // _ARP2ARM_H

---