bhand.h

Go to the documentation of this file.

/***************************************************************************
                          bhand.h  -  description
                             -------------------
    begin                : Die Okt 15 2002
    copyright            : (C) 2002 by Bernd Roessler
    email                : roessler@informatik.uni-hamburg.de
 ***************************************************************************/

/*
*       @section install Installation
*       <i>./configure</i> followed by <i>make install</i>
*/

#ifndef BHAND_H
#define BHAND_H

#include <string>
#include <SerialInterface.h>
#include <lexcast.h>
#include <configfile.h>
#include <csignal>

#define NUM_MOTORS 4

#define DEFAULT_MAX_TEMP 700



// order of this strings is important (used by checkError)
static const char* BHandException_info[] = {
        "No motor board found.",
        "No motor found.",
        "Motor not initialized.",
        "Undefined Exception.",
        "Couldn't reach position.",
        "Unknown command.",
        "Unknown parameter name.",
        "Invalid value.",
        "Tried to write a read only parameter.",
        "Timeout.",
        "Too many arguments for this command.",
        "Invalid RealTime control block header.",
        "Command can't have motor prefix.",
        "BarrettHand was not correctly initialized (use BHand::init() to initialize the hand).",
        "BarrettHand is allready initialized.",
        "There was no answer from the BarrettHand. Check the connection.",
        "The BarrettHand is to hot!"
        //      "Could Not Reach Position",
        //      "Force To High"
};

static const char* BHandMotorParams[][2] = {
  {"DEFAULT_POS","DP"}, {"DEFAULT_STEP","DS"}, {"MAX_STRAIN","HSG"}, {"MIN_STRAIN","LSG"}, {"MAX_OPEN_VEL","MOV"}, {"MAX_CLOSE_VEL","MCV"},
  {"LOOP_CTRL_VEL","LCV"}, {"LOOP_CTRL_VEL_COEFF","LCVC"}, {"LOOP_CTRL_PROP_GAIN","LCPG"}, {"LOOP_FEEDBACK_VEL","LFV"},
  {"LOOP_FEEDBACK_VEL_COEFF","LFVC"}, {"LOOP_FEEDBACK_STRAIN","LFS"}, {"LOOP_FEEDBACK_ABS_POS","LFAP"}, {"LOOP_FEEDBACK_DELTA_POS","LFDP"},
  {"LOOP_FEEDBACK_DELTA_POS_COEFF","LFDPC"},
  {"","OD"}, {"","P"}, {"","S"}, {"","SG"}
};

static const char* BHandGlobalParams[][2] = {
  {"LOOP_FEEDBACK_TEMP","LFT"}, {"OVER_TEMP","OTEMP"}, {"LOOP_FEEDBACK_DELTA_POS_DISCARD","LFDPD"},
  {"","TEMP"}, {"","PTEMP"}, {"","UPSECS"}, {"","SN"}
};

enum Motors
{
  F1 = 1,      
  F2 = 2,      
  F3 = 4,      
  FINGERS = 7, 
  SPREAD = 8,  
  ALL = 15,    
  F12 = 3,     
  F13 = 5,     
  F23 = 6      
};

enum MParameter
{
  DEFAULT_POS,
  DEFAULT_STEP,
  MAX_STRAIN,

  MIN_STRAIN,
  MAX_OPEN_VEL,
  MAX_CLOSE_VEL,

  /*
  * NOT IMPLEMENTED:
  *
  * MSG - because HSG(MAX_STRAIN) is the preferred alias to MSG <HR>
  */

  LOOP_CTRL_VEL,
  LOOP_CTRL_VEL_COEFF,
  LOOP_CTRL_PROP_GAIN,
  LOOP_FEEDBACK_VEL,
  LOOP_FEEDBACK_VEL_COEFF,
  LOOP_FEEDBACK_STRAIN,
  LOOP_FEEDBACK_ABS_POS,
  LOOP_FEEDBACK_DELTA_POS,
  LOOP_FEEDBACK_DELTA_POS_COEFF,

  ODOMETER,
  POSITION,
  STATUS,
  STRAIN
};

enum GParameter
{
  LOOP_FEEDBACK_TEMP,
  OVER_TEMP,
  LOOP_FEEDBACK_DELTA_POS_DISCARD,
  TEMP,
  PEAK_TEMP,
  UPTIME_SECS,
  SERIAL_NR
};

class BHandException
{
 public:
  enum error
    {
      EXCP_NO_MOTOR_BOARD,         
      EXCP_NO_MOTOR,               
      EXCP_MOTOR_NOT_INITIALIZED,  
      EXCP_UNDEF,                  
      EXCP_POSITION_UNREACHABLE,   
      EXCP_UNKNOWN_COMMAND,        
      EXCP_UNKNOWN_PARAMETER,      
      EXCP_INVALID_VALUE,          
      EXCP_READ_ONLY_PARAM,        
      EXCP_TIMEOUT,                
      EXCP_TO_MANY_ARGS,           
      EXCP_INVALID_HEADER,         
      EXCP_NO_MOTOR_PREFIX,        
      EXCP_NOT_INITIALIZED,        
      EXCP_ALLREADY_INITIALIZED,   
      EXCP_READ,                   
      EXCP_TO_HOT                  
    } err; 
 private:
  std::string msg;

 public:
  BHandException (const error e)
    {
      msg = BHandException_info[e];
      err = e;
    };

  const void show ()
    {
      std::cout << msg << std::endl;
    };

  friend std::ostream& operator<<(std::ostream& os,const BHandException& e)
    {
      os << e.msg << std::endl;
      return os;
    }

  bool operator==(error e)
    {
      return (err == e);
    }
};


class BHand
{
 public:
  BHand(const std::string devName);

  ~BHand();


  void init () throw (BHandException);

  void calib (const Motors motors = ALL) throw (BHandException)
    {
      //++tbaier 2004.09.01 bug fixed : set timout higer 
      send (mtos(motors)+"HI", 40);
    };

  void close (const Motors motors) throw (BHandException) {
    send (mtos(motors)+std::string("C"));
  };

  void home (const Motors motors) throw (BHandException)
    {
      send (mtos(motors)+"HOME");
    };

  void openInc (const Motors motors, const unsigned int distance) throw (BHandException)
    {
      send (mtos(motors)+"IO"+lexical_cast<std::string,unsigned int>(distance));
    };

  void closeInc (const Motors motors, const unsigned int distance) throw (BHandException)
    {
      send (mtos(motors)+"IC "+lexical_cast<std::string,unsigned int>(distance));
    };

  void move (const Motors motors, const int distance) throw (BHandException)
    {
      distance < 0 ?
        send (mtos(motors)+"IO "+lexical_cast<std::string,unsigned int>(-distance)) :
        send (mtos(motors)+"IC"+lexical_cast<std::string,unsigned int>(distance));
    };

  void rtMode(const Motors motors) throw (BHandException)
    {
      if(!RtModeEnabled){
        std::cout << " ENABLING RT MODE! " << std::endl;
        RtModeEnabled = true;
        send (mtos(motors)+"LOOP");
      }
      else{
        std::cout << "\t ** RT Mode already set!! " << std::endl;
      }
    };

  bool getRtModeEnabled()
    {
      return RtModeEnabled;
    };


  void movePos (const Motors motors, const unsigned int pos) throw (BHandException)
    {
#if 0
      if(getParam(motors,MAX_OPEN_VEL) < 100 || getParam(motors,MAX_CLOSE_VEL) < 100){
        std::cout << " ## SPEED to low using other timeout " << std::endl;
        send (mtos(motors)+"M "+lexical_cast<std::string,unsigned int>(pos), 1000);
      }
      else
#endif
        send (mtos(motors)+"M "+lexical_cast<std::string,unsigned int>(pos));
    };

  void open (const Motors motors) throw (BHandException)
    {
      send (mtos(motors)+std::string("O"));
    };

  void powerOff (const Motors motors) throw (BHandException)
    {
      send (mtos(motors)+std::string("T"));
    };

  void torqueClose (const Motors motors) throw (BHandException)
    {
      send (mtos(motors)+std::string("TC"));
    };

  void torqueOpen (const Motors motors) throw (BHandException)
    {
      send (mtos(motors)+std::string("TO"));
    };



  void setParam (const Motors motors, const MParameter param, const unsigned int value) throw (BHandException)
    {
      send (mtos(motors)+std::string("FSET ")+mparam(param)+" "+lexical_cast<std::string,unsigned int>(value));
    };

  unsigned int getParam (const int motor, const MParameter param) throw (BHandException);

  void saveParams () throw (BHandException);

  void loadParams () throw (BHandException);

  void setFactoryParams (const Motors motors) throw (BHandException)
    {
      send (mtos(motors)+std::string("FDEF"));
    };

  /*
   * NOT IMPLEMENTED:
   *
   * FLOAD, FSAVE:
   * - because filemanagement is used for saving parameters due to the fact that non-volatile memory can only be
   *   used about 5000 times.
   *
   * FLIST, FLISTV:
   * - because these are only informative commands about the available parameters.
   */



  void setGlobalParam (const GParameter param, const unsigned int value) throw (BHandException)
    {
      send (std::string("PSET ")+gparam(param)+" "+lexical_cast<std::string,unsigned int>(value));
    };

  unsigned int getGlobalParam (const GParameter param) throw (BHandException);

  void saveGlobalParams () throw (BHandException);

  void loadGlobalParams () throw (BHandException);

  void setFactoryParams () throw (BHandException)
    {
      send (std::string("PDEF"));
    };

  /*
   * NOT IMPLEMENTED:
   *
   * PLOAD, PSAVE:
   * - because filemanagement is used for saving parameters due to the fact that non-volatile memory can only be
   *   used about 5000 times.
   *
   * PLIST, PLISTV:
   * - because these are only informative commands about the available parameters.
   */



  void reset () throw (BHandException)
    {
      send (std::string("RESET"));
    };

  /*
   * NOT IMPLEMENTED:
   *
   * ?, ERR, VERSION:
   * - because these are only informative commands about commands, errors and firmware
   */


  /*
   * NOT IMPLEMENTED: Advanced Commands
   * Users do not generally need these commands and should avoid using them.
   * They are not listed by the  ?" command; they are only listed by the "A?" command.
   *
   * A?, FLISTA, FLISTAV, PLISTA, PLISTAV:
   * - because these are only informative commands about all available commands
   */

  void stop()
    {
      char c=3; com->Write(std::string("")+c);errorCheck(3);
      RtModeEnabled = false;
    };


  //void run();


 protected:
  std::string read(int timeout) throw (BHandException);
  std::string mtos(int fingers);
  std::string send(std::string s, int timeout=3) throw (BHandException);
  
  void loadConfigFile();        


  bool tempOk(const int temp);

  // VARS****************************************************

  SerialInterface* com;

  bool RtModeEnabled;

  int MaxTemp;
  int SerialNumber;

 private:
  std::string errorCheck(int timeout) throw (BHandException);

  // Returns the string representing a MParameter enumeration type to send to BarrettHand.
  std::string mparam (MParameter param)
    {
      return std::string(BHandMotorParams[param][1]);
    };

  // Returns the string representing a GParameter enumeration type to send to BarrettHand.
  std::string gparam (GParameter param)
    {
      return std::string(BHandGlobalParams[param][1]);
    };

  ConfigFile* cfgFile;


};

//****************************//
//**                        **//
//****************************//
inline bool BHand::tempOk(const int temp)
{
  return (temp < MaxTemp);
}

#endif

---

Tim Baier bhandlib v0.25

Generated Wed Aug 16 14:57:08 2006 by 1.4.7