ArRobotParams.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 ARROBOTPARAMS_H
#define ARROBOTPARAMS_H

#include "ariaTypedefs.h"
#include "ArConfig.h"

class ArRobotParams : public ArConfig
{
public:
  ArRobotParams();
  virtual ~ArRobotParams();
  const char *getClassName(void) const { return myClass; }
  const char *getSubClassName(void) const { return mySubClass; }
  double getRobotRadius(void) const { return myRobotRadius; }
  double getRobotDiagonal(void) const { return myRobotDiagonal; }
  double getRobotWidth(void) const { return myRobotWidth; }
  double getRobotLength(void) const { return myRobotLength; }
  bool isHolonomic(void) const { return myHolonomic; }
  bool hasMoveCommand(void) const { return myHaveMoveCommand; }
  int getAbsoluteMaxVelocity(void) const { return myAbsoluteMaxVelocity; }
  int getAbsoluteMaxRotVelocity(void) const { return myAbsoluteMaxRVelocity; }
  bool getRequestIOPackets(void) const { return myRequestIOPackets; }
  bool getRequestEncoderPackets(void) const { return myRequestEncoderPackets; }
  int getSwitchToBaudRate(void) { return mySwitchToBaudRate; }
  double getAngleConvFactor(void) const { return myAngleConvFactor; }
  double getDistConvFactor(void) const { return myDistConvFactor; }
  double getVelConvFactor(void) const { return myVelConvFactor; }
  double getRangeConvFactor(void) const { return myRangeConvFactor; }
  double getDiffConvFactor(void) const { return myDiffConvFactor; }
  double getVel2Divisor(void) const { return myVel2Divisor; }
  double getGyroScaler(void) const { return myGyroScaler; }
  bool haveTableSensingIR(void) const { return myTableSensingIR; }
  bool haveNewTableSensingIR(void) const { return myNewTableSensingIR; }
  bool haveFrontBumpers(void) const { return myFrontBumpers; }
  int numFrontBumpers(void) const { return myNumFrontBumpers; }
  bool haveRearBumpers(void) const { return myRearBumpers; }
  int numRearBumpers(void) const { return myNumRearBumpers; }
  int getNumIR(void) const { return myNumIR; }
  bool haveIR(int number)
    {
      if (myIRMap.find(number) != myIRMap.end())
        return true;
      else
        return false;
    }
  int getIRX(int number)
    {
      std::map<int, std::map<int, int> >::iterator it;
      std::map<int, int>::iterator it2;
      if ((it = myIRMap.find(number)) == myIRMap.end())
        return 0;
      if ((it2 = (*it).second.find(IR_X)) == (*it).second.end())

        return 0;
      return (*it2).second;
    }
  int getIRY(int number)
    {
      std::map<int, std::map<int, int> >::iterator it;
      std::map<int, int>::iterator it2;
      if ((it = myIRMap.find(number)) == myIRMap.end())
        return 0;
      if ((it2 = (*it).second.find(IR_Y)) == (*it).second.end())
        return 0;
      return (*it2).second;
    }
  int getIRType(int number)
    {
      std::map<int, std::map<int, int> >::iterator it;
      std::map<int, int>::iterator it2;
      if ((it = myIRMap.find(number)) == myIRMap.end())
        return 0;
      if ((it2 = (*it).second.find(IR_TYPE)) == (*it).second.end())
        return 0;
      return (*it2).second;
    }
  int getIRCycles(int number)
    {
      std::map<int, std::map<int, int> >::iterator it;
      std::map<int, int>::iterator it2;
      if ((it = myIRMap.find(number)) == myIRMap.end())
        return 0;
      if ((it2 = (*it).second.find(IR_CYCLES)) == (*it).second.end())
        return 0;
      return (*it2).second;
    }
  int getNumSonar(void) const { return myNumSonar; }
  bool haveSonar(int number)
    {
      if (mySonarMap.find(number) != mySonarMap.end())
        return true;
      else
        return false;
    }
  int getSonarX(int number)
    {
      std::map<int, std::map<int, int> >::iterator it;
      std::map<int, int>::iterator it2;
      if ((it = mySonarMap.find(number)) == mySonarMap.end())
        return 0;
      if ((it2 = (*it).second.find(SONAR_X)) == (*it).second.end())
        return 0;
      return (*it2).second;
    }
  int getSonarY(int number)
    {
      std::map<int, std::map<int, int> >::iterator it;
      std::map<int, int>::iterator it2;
      if ((it = mySonarMap.find(number)) == mySonarMap.end())
        return 0;
      if ((it2 = (*it).second.find(SONAR_Y)) == (*it).second.end())
        return 0;
      return (*it2).second;
    }
  int getSonarTh(int number)
    {
      std::map<int, std::map<int, int> >::iterator it;
      std::map<int, int>::iterator it2;
      if ((it = mySonarMap.find(number)) == mySonarMap.end())
        return 0;
      if ((it2 = (*it).second.find(SONAR_TH)) == (*it).second.end())
        return 0;
      return (*it2).second;
    }
  bool getLaserPossessed(void) const { return myLaserPossessed; }
  const char *getLaserPort(void) const { return myLaserPort; }
  bool getLaserPowerControlled(void) const { return myLaserPowerControlled; }
  bool getLaserFlipped(void) const { return myLaserFlipped; }
  int getLaserX(void) const { return myLaserX; }
  int getLaserY(void) const { return myLaserY; }
  double getLaserTh(void) const { return myLaserTh; }
  const char *getLaserIgnore(void) const { return myLaserIgnore; }
  bool hasSettableVelMaxes(void) const { return mySettableVelMaxes; }
  int getTransVelMax(void) const { return myTransVelMax; }
  int getRotVelMax(void) const { return myRotVelMax; }
  bool hasSettableAccsDecs(void) const { return mySettableAccsDecs; }
  int getTransAccel(void) const { return myTransAccel; }
  int getTransDecel(void) const { return myTransDecel; }
  int getRotAccel(void) const { return myRotAccel; }
  int getRotDecel(void) const { return myRotDecel; }
  bool save(void);
protected:
  char myClass[1024];
  char mySubClass[1024];
  double myRobotRadius;
  double myRobotDiagonal;
  double myRobotWidth;
  double myRobotLength;
  bool myHolonomic;
  int myAbsoluteMaxRVelocity;
  int myAbsoluteMaxVelocity;
  bool myHaveMoveCommand;
  bool myRequestIOPackets;
  bool myRequestEncoderPackets;
  int mySwitchToBaudRate;
  double myAngleConvFactor;
  double myDistConvFactor;
  double myVelConvFactor;
  double myRangeConvFactor;
  double myDiffConvFactor;
  double myVel2Divisor;
  double myGyroScaler;
  bool myTableSensingIR;
  bool myNewTableSensingIR;
  bool myFrontBumpers;
  int myNumFrontBumpers;
  bool myRearBumpers;
  int myNumRearBumpers;
  bool myLaserPossessed;
  char myLaserPort[1024];
  bool myLaserFlipped;
  bool myLaserPowerControlled;
  int myLaserX;
  int myLaserY;
  double myLaserTh;
  char myLaserIgnore[1024];
  
  bool mySettableVelMaxes;
  int myTransVelMax;
  int myRotVelMax;
  bool mySettableAccsDecs;
  int myTransAccel;
  int myTransDecel;
  int myRotAccel;
  int myRotDecel;

  // IRs
  int myNumIR;
  std::map<int, std::map<int, int> > myIRMap;
  enum IRInfo 
  { 
    IR_X, 
    IR_Y,
    IR_TYPE,
    IR_CYCLES
  };
  void internalSetIR(int num, int type, int cycles, int x, int y);
  bool parseIRUnit(ArArgumentBuilder *builder);
  const std::list<ArArgumentBuilder *> *getIRUnits(void);
  std::list<ArArgumentBuilder *> myGetIRUnitList;
  ArRetFunctorC<const std::list<ArArgumentBuilder *> *, ArRobotParams> myIRUnitGetFunctor;
  ArRetFunctor1C<bool, ArRobotParams, ArArgumentBuilder *> myIRUnitSetFunctor;

  // Sonar
  int myNumSonar;
  std::map<int, std::map<int, int> > mySonarMap;
  enum SonarInfo 
  { 
    SONAR_X, 
    SONAR_Y, 
    SONAR_TH
  };
  void internalSetSonar(int num, int x, int y, int th);
  bool parseSonarUnit(ArArgumentBuilder *builder);
  const std::list<ArArgumentBuilder *> *getSonarUnits(void);
  std::list<ArArgumentBuilder *> myGetSonarUnitList;
  ArRetFunctorC<const std::list<ArArgumentBuilder *> *, ArRobotParams> mySonarUnitGetFunctor;
  ArRetFunctor1C<bool, ArRobotParams, ArArgumentBuilder *> mySonarUnitSetFunctor;
};

#endif // ARROBOTPARAMS_H

---