ArDPPTU.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 ARDPPTU_H
#define ARDPPTU_H

#include "ariaTypedefs.h"
#include "ArRobot.h"
#include "ArPTZ.h"


class ArDPPTUCommands
{
public:
  enum {
    DELIM = 0x20, 
    INIT = 0x40, 
    ACCEL = 0x61, 
    BASE = 0x62, 
    CONTROL = 0x63, 
    DISABLE = 0x64, 
    ENABLE = 0x65, 
    FACTORY = 0x66, 
    HALT = 0x68, 
    IMMED = 0x69, 
    LIMIT = 0x6C, 
    MONITOR = 0x6D, 
    OFFSET = 0x6F, 
    PAN = 0x70, 
    RESET = 0x72, 
    SPEED = 0x73, 
    TILT = 0x74, 
    UPPER = 0x75, 
    VELOCITY = 0x76 
  };

};


class ArDPPTUPacket: public ArBasePacket
{
public:
  AREXPORT ArDPPTUPacket(ArTypes::UByte2 bufferSize = 30);
  AREXPORT virtual ~ArDPPTUPacket();

  AREXPORT virtual void byte2ToBuf(int val);

  AREXPORT virtual void finalizePacket(void);

protected:
};

class ArDPPTU : public ArPTZ
{
public:
  AREXPORT ArDPPTU(ArRobot *robot);
  AREXPORT virtual ~ArDPPTU();

  AREXPORT bool init(void);

  AREXPORT bool canZoom(void) const { return 0; }

  AREXPORT bool blank(void);

  AREXPORT bool resetCalib(void);
  AREXPORT bool disableReset(void);
  AREXPORT bool resetTilt(void);
  AREXPORT bool resetPan(void);
  AREXPORT bool resetAll(void);

  AREXPORT bool saveSet(void);
  AREXPORT bool restoreSet(void);
  AREXPORT bool factorySet(void);

  AREXPORT bool panTilt(double pdeg, double tdeg);

  AREXPORT bool pan(double deg) { return panTilt(deg, myTilt); }
  AREXPORT bool panRel(double deg) { return panTilt(myPan+deg, myTilt); }
  AREXPORT bool tilt(double deg) { return panTilt(myPan, deg); }
  AREXPORT bool tiltRel(double deg) { return panTilt(myPan, myTilt+deg); }
  AREXPORT bool panTiltRel(double pdeg, double tdeg) { return panTilt(myPan+pdeg, myTilt+tdeg); }

  AREXPORT bool limitEnforce(bool val);
  AREXPORT bool immedExec(void);
  AREXPORT bool slaveExec(void);
  AREXPORT bool awaitExec(void);
  AREXPORT bool haltAll(void);
  AREXPORT bool haltPan(void);
  AREXPORT bool haltTilt(void);

  AREXPORT virtual double getMaxPosPan(void) const { return MAX_PAN; }
  AREXPORT virtual double getMaxNegPan(void) const { return MIN_PAN; }
  AREXPORT virtual double getMaxPosTilt(void) const { return MAX_TILT; }
  AREXPORT virtual double getMaxNegTilt(void) const { return MIN_TILT; }
  AREXPORT double getMaxPanSlew(void) { return MAX_PAN_SLEW; }
  AREXPORT double getMinPanSlew(void) { return MIN_PAN_SLEW; }
  AREXPORT double getMaxTiltSlew(void) { return MAX_TILT_SLEW; }
  AREXPORT double getMinTiltSlew(void) { return MIN_TILT_SLEW; }
  AREXPORT double getMaxPanAccel(void) { return MAX_PAN_ACCEL; }
  AREXPORT double getMinPanAccel(void) { return MIN_PAN_ACCEL; }
  AREXPORT double getMaxTiltAccel(void) { return MAX_TILT_ACCEL; }
  AREXPORT double getMinTiltAccel(void) { return MIN_TILT_ACCEL; }

  AREXPORT bool initMon(double deg1, double deg2, double deg3, double deg4);
  AREXPORT bool enMon(void);
  AREXPORT bool disMon(void);

  AREXPORT bool offStatPower(void);
  AREXPORT bool regStatPower(void);
  AREXPORT bool lowStatPower(void);
  AREXPORT bool highMotPower(void);
  AREXPORT bool regMotPower(void);
  AREXPORT bool lowMotPower(void);

  AREXPORT bool panAccel(double deg);
  AREXPORT bool tiltAccel(double deg);

  AREXPORT bool basePanSlew(double deg);
  AREXPORT bool baseTiltSlew(double deg);

  AREXPORT bool upperPanSlew(double deg);
  AREXPORT bool lowerPanSlew(double deg);
  AREXPORT bool upperTiltSlew(double deg);
  AREXPORT bool lowerTiltSlew(double deg);

  AREXPORT bool indepMove(void);
  AREXPORT bool velMove(void);

  AREXPORT bool panSlew(double deg);
  AREXPORT bool tiltSlew(double deg);

  AREXPORT bool panSlewRel(double deg) { return panSlew(myPanSlew+deg); }
  AREXPORT bool tiltSlewRel(double deg) { return tiltSlew(myTiltSlew+deg); }

  virtual double getPan(void) const { return myPan; }
  virtual double getTilt(void) const { return myTilt; }

  double getPanSlew(void) { return myPanSlew; }
  double getTiltSlew(void) { return myTiltSlew; }
  double getBasePanSlew(void) { return myBasePanSlew; }
  double getBaseTiltSlew(void) { return myBaseTiltSlew; }
  double getPanAccel(void) { return myPanAccel; }
  double getTiltAccel(void) { return myTiltAccel; }

  enum {
    MAX_PAN = 158, 
    MIN_PAN = -158, 
    MAX_TILT = 30, 
    MIN_TILT = -46, 
    MAX_PAN_SLEW = 149, 
    MIN_PAN_SLEW = 2, 
    MAX_TILT_SLEW = 149, 
    MIN_TILT_SLEW = 2, 
// These aren't correct, because the manual doesn't specify
// the min/max acceleration
    MAX_PAN_ACCEL = 102, 
    MIN_PAN_ACCEL = 2, 
    MAX_TILT_ACCEL = 102, 
    MIN_TILT_ACCEL = 2, 
  };
protected:
  ArRobot *myRobot;
  ArDPPTUPacket myPacket;
  void preparePacket(void); 
  double myPan;
  double myTilt;
  double myPanSlew;
  double myTiltSlew;
  double myBasePanSlew;
  double myBaseTiltSlew;
  double myPanAccel;
  double myTiltAccel;
  static const double CONVERT; 
};

#endif // ARDPPTU_H

---