bhcontroller.h

Go to the documentation of this file.

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


#include <math.h>
#include <iostream>

// ***********************************************
// **                                           **
// **                                           **
// ***********************************************
class BHController
{
 public:
  BHController(const double factor);

  virtual ~BHController() ;

  void setFactor(const double factor);

  double getFactor();

  virtual double getOutput(const double error) = 0;

 protected:

  double Factor;
};

// ****************************
// **                        **
// ****************************
inline BHController::BHController(const double factor)
{
  Factor = factor;
}

// ****************************
// **                        **
// ****************************
inline void BHController::setFactor(const double factor)
{
  Factor = factor;
}

// ****************************
// **                        **
// ****************************
inline double BHController::getFactor()
{
  return Factor;
}

// ****************************
// **                        **
// ****************************
inline BHController::~BHController()
{}


// ***********************************************
// **                                           **
// **  P-CONTROLLER                             **
// **                                           **
// ***********************************************
class BHPController : public BHController
{
 public:
   BHPController(const double factor);

   double getOutput(const double error);
};


// ****************************
// **                        **
// ****************************
inline  BHPController::BHPController(const double factor)
  : BHController(factor)
{
}

// ****************************
// **                        **
// ****************************
inline double BHPController::getOutput(const double error)
{
  return Factor * error;
}




// ***********************************************
// **                                           **
// **  D-CONTROLLER                             **
// **                                           **
// ***********************************************
class BHDController : public BHController
{
 public:
   BHDController(const double factor);

   double getOutput(const double error);

 protected:

  double LastValue;
};


// ****************************
// **                        **
// ****************************
inline  BHDController::BHDController(const double factor)
  :BHController(factor)
{
  LastValue = 0.0;
}

// ****************************
// **                        **
// ****************************
inline double BHDController::getOutput(const double error)
{
  double last = LastValue;

  LastValue = error;

  return (error - last) * Factor;
}





// ***********************************************
// **                                           **
// **  I-CONTROLLER                             **
// **                                           **
// ***********************************************

class BHIController : public BHController
{
 public:
   BHIController(const double factor, const unsigned int size = 1);

   ~BHIController();

   double getOutput(const double error);

   void setISize(const unsigned int size);

   int getISize();

   void reset();

 protected:

   int IntPointer;

   int IntSize;

  double *IntArray;

};


// ****************************
// **                        **
// ****************************
inline  BHIController::BHIController(const double factor, const unsigned int size)
  :BHController(factor)
{
  IntPointer = 0;
  IntSize = size;
  IntArray = new double[size];

  memset(IntArray, 0, IntSize*sizeof(double));
}


// ****************************
// **                        **
// ****************************
inline void BHIController::setISize(const unsigned int size)
{
  if(IntArray)
    delete IntArray;

  IntSize = size;
  IntArray = new double[size];

  IntPointer = 0;
  memset(IntArray, 0, IntSize*sizeof(double));
}


// ****************************
// **                        **
// ****************************
inline double BHIController::getOutput(const double error)
{
  double result = 0.0;

  IntArray[IntPointer++] = error;

  IntPointer = (IntPointer > IntSize-1) ? 0 : IntPointer;

  for(int i = IntSize-1; i >= 0; i--)
    result += IntArray[i];

  return result *= Factor;
}


// ****************************
// **                        **
// ****************************
inline int BHIController::getISize()
{
  return IntSize;
}


// ****************************
// **                        **
// ****************************
inline void BHIController::reset()
{
  IntPointer = 0;
  memset(IntArray, 0, IntSize*sizeof(double));
}


// ****************************
// **                        **
// ****************************
inline BHIController::~BHIController()
{
   if(IntArray)
      delete []IntArray;
}


// ***********************************************
// **                                           **
// **  PD-CONTROLLER                           **
// **                                           **
// ***********************************************
class BHPDController : public BHPController,
                        public BHDController
{
 public:
   BHPDController(const double pfactor, const double dfactor);

   //  ~BHPDController();

   double getOutput(const double error);

   void setPFactor(const double factor);

   void setDFactor(const double factor);

 
   double getPFactor();

   double getDFactor();

 
   void showValues();

};


// ****************************
// **                        **
// ****************************
inline BHPDController::BHPDController(const double pfactor,
                                      const double dfactor) :
  BHPController(pfactor),
     BHDController(dfactor)
{
}


// ****************************
// **                        **
// ****************************
inline double BHPDController::getOutput(const double error)
{
  double result =  BHPController::getOutput(error);
  result += BHDController::getOutput(error);

  return result;
}

// ****************************
// **                        **
// ****************************
inline void BHPDController::setPFactor(const double factor)
{
  BHPController::setFactor(factor);
}


// ****************************
// **                        **
// ****************************
inline void BHPDController::setDFactor(const double factor)
{
  BHDController::setFactor(factor);
}


// ****************************
// **                        **
// ****************************
inline double BHPDController::getPFactor()
{
  return BHPController::getFactor();
}

// ****************************
// **                        **
// ****************************
inline double BHPDController::getDFactor()
{
  return BHDController::getFactor();
}

// ****************************
// **                        **
// ****************************
inline void BHPDController::showValues()
{
  std::cout << "\n\t ** P-Factor: " << getPFactor() << "\n"
            << "\t ** D-Factor: "   << getDFactor() << "\n" << std::endl;

}



// ***********************************************
// **                                           **
// **  PID-CONTROLLER                           **
// **                                           **
// ***********************************************
class BHPIDController : public BHPController,
                        public BHDController,
                        public BHIController
{
 public:
   BHPIDController(const double pfactor, const double dfactor, const double ifactor, const int size = 1);

   //  ~BHPIDController();

   double getOutput(const double error);

   void setPFactor(const double factor);

   void setDFactor(const double factor);

   void setIFactor(const double factor);

   double getPFactor();

   double getDFactor();

   double getIFactor();

   void showValues();

};


// ****************************
// **                        **
// ****************************
inline BHPIDController::BHPIDController(const double pfactor,
                                        const double dfactor,
                                        const double ifactor, const int isize) :
  BHPController(pfactor),
     BHDController(dfactor),
     BHIController(ifactor, isize)
{
}


// ****************************
// **                        **
// ****************************
inline double BHPIDController::getOutput(const double error)
{
  double result =  BHPController::getOutput(error);
  result += BHDController::getOutput(error);
  result += BHIController::getOutput(error);

  return result;
}

// ****************************
// **                        **
// ****************************
inline void BHPIDController::setPFactor(const double factor)
{
  BHPController::setFactor(factor);
}


// ****************************
// **                        **
// ****************************
inline void BHPIDController::setDFactor(const double factor)
{
  BHDController::setFactor(factor);
}

// ****************************
// **                        **
// ****************************
inline void BHPIDController::setIFactor(const double factor)
{
  BHIController::setFactor(factor);
}


// ****************************
// **                        **
// ****************************
inline double BHPIDController::getPFactor()
{
  return BHPController::getFactor();
}

// ****************************
// **                        **
// ****************************
inline double BHPIDController::getDFactor()
{
  return BHDController::getFactor();
}


// ****************************
// **                        **
// ****************************
inline double BHPIDController::getIFactor()
{
  return BHIController::getFactor();
}


// ****************************
// **                        **
// ****************************
inline void BHPIDController::showValues()
{
  std::cout << "\n\t ** P-Factor: " << getPFactor() << "\n"
            << "\t ** D-Factor: "   << getDFactor() << "\n"
            << "\t ** I-Factor: "   << getIFactor() << "\n"
            << "\t ** I-Size  : "   << getISize()   << "\n" << std::endl;
}


#endif //BHCONTROLLER

---

Tim Baier bhandlib v0.25

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