bhfinger.h

Go to the documentation of this file.

// ***************************************************************************
//                           bhfinger.h
//
//    copyright            : (C) 2004 by tbaier
//    email                : tbaier@informatik.uni-hamburg.de
// ***************************************************************************
#ifndef BHFINGER_H
#define BHFINGER_H

#include <iostream>
#include <string>
#include "bhcontroller.h"
#include "bhmotorext.h"
#include "zlog.h"

#define MAX_FINGER_POS 17000

#define MIN_FINGER_POS 0

#define DEFAULT_FINGER_SPEED 60

#define MAX_FINGER_SPEED 124

//#define MIN_FINGER_SPEED 10

#define MIN_FINGER_SPEED 9
//#define MIN_FINGER_SPEED 10

#define MAX_FINGER_FORCE 255

#define MIN_FINGER_FORCE 0

#define INIT_FORCE_MIN 100

#define INIT_FORCE_MAX 140

#define DEFAULT_GAIN 0

#define MAX_FORCE_LOG 8



// order of this strings is important (used by checkError)
static const char* BHFingerException_info[] = {
        "Value out of range",
        "Speed out of range",
        "Position out of range.",
        "Init forces out of range.",
        "Force out of Range.",
        "Force to high.",
        "Force to low.",
        "UNDEF"};


class BHFingerException : public BHMotorException
{
 public:

  enum FingerError
    {
      EXCP_VALUE_OUT_OF_RANGE,       
      EXCP_SPEED_OUT_OF_RANGE,       
      EXCP_POSITION_OUT_OF_RANGE,    
      EXCP_INTIT_FORCE_OUT_OF_RANGE, 
      EXCP_FORCE_OUT_OF_RANGE,       
      EXCP_FORCE_TO_HIGH,            
      EXCP_FORCE_TO_LOW,             
      EXCP_UNDEF
    };


  BHFingerException(const FingerError e);

 protected:
  FingerError Err;

};

//****************************//
//**                        **//
//****************************//
inline BHFingerException::BHFingerException(const FingerError e)
{
  Msg = BHFingerException_info[e];
  Err = e;
}




//***********************************************//
//**                                           **//
//**  BHFinger                                 **//
//**                                           **//
//***********************************************//

class BHFinger : public BHMotorExt
{
 public:


  BHFinger(MotorFeedback *mf);

  BHFinger(MotorFeedback *mf, int speed);

  BHFinger(MotorFeedback *mf, int speed, int minForce, int maxForce);

  ~BHFinger();

  void setPos(const unsigned int pos) throw (BHMotorException);

  void setMaxForce(short force) throw (BHFingerException);

  void setMinForce(short force) throw (BHFingerException);


  void setMaxForceAbs(short force) throw (BHFingerException);

  void setMinForceAbs(short force) throw (BHFingerException);



  int getMaxForce() const ;

  int getMinForce() const;

  int getMaxForceAbs() const ;

  int getMinForceAbs() const;


  void resetMinForce();

  void resetMaxForce();

  void resetForce();


  void initForce(const short initForce) throw (BHFingerException);

  void initForce() throw (BHFingerException);

  int getInitForce() const;

  int forceInRange(const short force);

  int forceInRange();

  int getForce() const;

  int getForceAbs() const;


  void setDForce(const short force) throw (BHFingerException);

  short getDForce() const;


   void log();


  bool positionInRange();

  BHPIDController *ForceCtr;


 protected:


  short MaxForce;

  short MinForce;

  short ZeroForce;

  short DForce;

  ZLog *ForceLog;


};



// ****************************
// **                        **
// ****************************
inline void BHFinger::setMaxForce(short force) throw (BHFingerException)
{
  if(force+ZeroForce > MAX_FINGER_FORCE){
        std::cerr << " ** void BHFinger::setMaxForce(" << force << "): force to high" << std::endl;
    throw BHFingerException(BHFingerException::EXCP_FORCE_TO_HIGH);
  }
  else if(force+ZeroForce < MIN_FINGER_FORCE){
    throw BHFingerException(BHFingerException::EXCP_FORCE_TO_LOW);
  }
  else{
    MaxForce = force+ZeroForce;
  }
}


// ****************************
// **                        **
// ****************************
inline void BHFinger::setMinForce(short force)throw (BHFingerException)
{
  if(force+ZeroForce > MAX_FINGER_FORCE){
    throw BHFingerException(BHFingerException:: EXCP_FORCE_TO_HIGH);
  }
  else if(force+ZeroForce < MIN_FINGER_FORCE){
    throw BHFingerException(BHFingerException:: EXCP_FORCE_TO_LOW);
  }
  else{
    MinForce = force+ZeroForce;
  }
}


// ****************************
// **                        **
// ****************************
inline void BHFinger::setMaxForceAbs(short force) throw (BHFingerException)
{
  if(ZeroForce > MAX_FINGER_FORCE){
    throw BHFingerException(BHFingerException:: EXCP_FORCE_TO_HIGH);
  }
  else if(ZeroForce < MIN_FINGER_FORCE){
    throw BHFingerException(BHFingerException:: EXCP_FORCE_TO_LOW);
  }
  else{
    MaxForce = force;
  }
}


// ****************************
// **                        **
// ****************************
inline void BHFinger::setMinForceAbs(short force)throw (BHFingerException)
{
  if(force > MAX_FINGER_FORCE){
    throw BHFingerException(BHFingerException:: EXCP_FORCE_TO_HIGH);
  }
  else if(force < MIN_FINGER_FORCE){
    throw BHFingerException(BHFingerException:: EXCP_FORCE_TO_LOW);
  }
  else{
    MinForce = force;
  }
}


// ****************************
// **                        **
// ****************************
inline void BHFinger::resetMinForce()
{
  MinForce = MIN_FINGER_FORCE;
}

// ****************************
// **                        **
// ****************************
inline void BHFinger::resetMaxForce()
{
  MaxForce = MAX_FINGER_FORCE;
}


// ****************************
// **                        **
// ****************************
inline void BHFinger::resetForce()
{
  MaxForce = MAX_FINGER_FORCE;
  MinForce = MIN_FINGER_FORCE;
}


// ****************************
// **                        **
// ****************************
inline int BHFinger::getMaxForce() const
{
  return MaxForce-ZeroForce;
}

// ****************************
// **                        **
// ****************************
inline int BHFinger::getMinForce() const
{
  return MinForce-ZeroForce;
}


// ****************************
// **                        **
// ****************************
inline int BHFinger::getMaxForceAbs() const
{
  return MaxForce;
}

// ****************************
// **                        **
// ****************************
inline int BHFinger::getMinForceAbs() const
{
  return MinForce;
}


// ****************************
// **                        **
// ****************************
inline void BHFinger::initForce(const short initForce) throw (BHFingerException)
{
  if(initForce < INIT_FORCE_MIN || initForce > INIT_FORCE_MAX) {
    std::cerr << "\n\t ** Initilisation forces out of range!! \n"
              << "\t ** Look at users manual for maintainance and \n"
              << "\t ** adjust force sensor!!\n " << std::endl;

    ZeroForce = initForce;
    ForceLog->setLog(initForce);
    throw BHFingerException(BHFingerException::EXCP_INTIT_FORCE_OUT_OF_RANGE);
  }
  else{
    ZeroForce = initForce;
    ForceLog->setLog(initForce);
  }
}


// ****************************
// **                        **
// ****************************
inline void BHFinger::initForce() throw (BHFingerException)
{
  int initForce = (int)FeedBack->loopFeedbackStrain;
  if(initForce < INIT_FORCE_MIN || initForce > INIT_FORCE_MAX) {
    std::cerr << "\n\t ** Initilisation forces out of range!! \n"
              << "\t ** Look at users manual for maintainance and \n"
              << "\t ** adjust force sensor!!\n " << std::endl;

    ZeroForce = initForce;
    ForceLog->setLog((short)FeedBack->loopFeedbackStrain);
    throw BHFingerException(BHFingerException::EXCP_INTIT_FORCE_OUT_OF_RANGE);
  }
  else{
    ForceLog->setLog((short)FeedBack->loopFeedbackStrain);
    ZeroForce = initForce;
  }
}


// ****************************
// **                        **
// ****************************
inline int BHFinger::getInitForce() const
{
  return ZeroForce;
}

// ****************************
// **                        **
// ****************************
inline int BHFinger::forceInRange(const short force)
{
  if(force > MinForce-1 && force < MaxForce+1)
    return 0;

  else if (force < MinForce-1)
    return -1;

  else
    return 1;
}

// ****************************
// **                        **
// ****************************
inline int BHFinger::getForce() const
{
  return (int)FeedBack->loopFeedbackStrain - ZeroForce;
}


// ****************************
// **                        **
// ****************************
inline int BHFinger::getForceAbs() const
{
  return (int)FeedBack->loopFeedbackStrain;
}


// ****************************
// **                        **
// ****************************
inline int BHFinger::forceInRange()
{
  int dummy = (int)FeedBack->loopFeedbackStrain;

  //std::cout << " Actual force : " << dummy  << " min : " << MinForce-1 << " max " << MaxForce << std::endl;

  if(dummy >= MinForce && dummy <= MaxForce){
    //    std::cout << " returning 0 " << std::endl;
    return 0;
  }
  else if (dummy < MinForce-1)
    return -1;

  else
    return 1;

}

// ****************************
// **                        **
// ****************************
inline void BHFinger::setDForce(const short force) throw (BHFingerException)
{
  if(force < MinForce || force > MaxForce){
    throw BHFingerException(BHFingerException:: EXCP_FORCE_OUT_OF_RANGE);
  }
  else
    DForce = force;
}


// ****************************
// **                        **
// ****************************
inline short BHFinger::getDForce() const
{
  return DForce;
}


// ****************************
// **                        **
// ****************************
inline void BHFinger::log()
{
  ForceLog->writeLog((short)FeedBack->loopFeedbackStrain);
}



// ****************************
// **                        **
// ****************************
inline bool BHFinger::positionInRange()
{
    if( ((int)FeedBack->loopFeedbackAbsPos > MIN_FINGER_POS) &&
        ((int)FeedBack->loopFeedbackAbsPos < MAX_FINGER_POS) )
      return true;
    else
      return false;
}


// ****************************
// **                        **
// ****************************
inline void BHFinger::setPos(const unsigned int pos) throw (BHMotorException)
{
  //std::cout << " ** ::setPos(const unsigned int pos) throw (BHMotorException)" << std::endl;

  if(pos > MaxPos){
    throw BHMotorException(BHMotorException::EXCP_POSITION_OUT_OF_RANGE);
  }
  else{
    DPos = (pos < MinPos) ? MinPos : pos;
    //std::cout << " ** set DPOS to : " << DPos << std::endl;
  }
}


#endif //BHFINGER_H

---

Tim Baier bhandlib v0.25

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