ArDPPTU.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 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:
  ArDPPTUPacket(ArTypes::UByte2 bufferSize = 30);
  virtual ~ArDPPTUPacket();

  virtual void byte2ToBuf(int val);

  virtual void finalizePacket(void);

protected:
};

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

  bool init(void);

  bool canZoom(void) const { return 0; }

  bool blank(void);

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

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

  bool panTilt(int pdeg, int tdeg);

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

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

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

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

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

  bool panAccel(int deg);
  bool tiltAccel(int deg);

  bool basePanSlew(int deg);
  bool baseTiltSlew(int deg);

  bool upperPanSlew(int deg);
  bool lowerPanSlew(int deg);
  bool upperTiltSlew(int deg);
  bool lowerTiltSlew(int deg);

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

  bool panSlew(int deg);
  bool tiltSlew(int deg);

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

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

  int getPanSlew(void) { return myPanSlew; }
  int getTiltSlew(void) { return myTiltSlew; }
  int getBasePanSlew(void) { return myBasePanSlew; }
  int getBaseTiltSlew(void) { return myBaseTiltSlew; }
  int getPanAccel(void) { return myPanAccel; }
  int 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); 
  int myPan;
  int myTilt;
  int myPanSlew;
  int myTiltSlew;
  int myBasePanSlew;
  int myBaseTiltSlew;
  int myPanAccel;
  int myTiltAccel;
  static const double CONVERT; 
};

#endif // ARDPPTU_H

---