// PIDController.cpp ---
//
// Filename: PIDController.cpp
// Description:
// Author: subhasis ray
// Maintainer:
// Created: Tue Dec 30 23:36:01 2008 (+0530)
// Version:
// Last-Updated: Tue Jun 11 17:00:51 2013 (+0530)
// By: subha
// Update #: 338
// URL:
// Keywords:
// Compatibility:
//
//
// Commentary:
//
//
//
//
// Change log:
//
//
//
//
/**********************************************************************
** This program is part of 'MOOSE', the
** Messaging Object Oriented Simulation Environment,
** also known as GENESIS 3 base code.
** copyright (C) 2003-2013 Upinder S. Bhalla. and NCBS
** It is made available under the terms of the
** GNU Lesser General Public License version 2.1
** See the file COPYING.LIB for the full notice.
**********************************************************************/
// Code:
#include <cfloat>
#include "PIDController.h"
static SrcFinfo1< double > * outputOut()
{
static SrcFinfo1 <double> outputOut("output",
"Sends the output of the PIDController. This is known as manipulated"
" variable (MV) in control theory. This should be fed into the process"
" which we are trying to control.");
return &outputOut;
}
const Cinfo* PIDController::initCinfo()
{
static DestFinfo process( "process",
"Handle process calls.",
new ProcOpFunc<PIDController>( &PIDController::process));
static DestFinfo reinit( "reinit",
"Reinitialize the object.",
new ProcOpFunc<PIDController>( &PIDController::reinit ));
static Finfo* processShared[] = {
&process, &reinit
};
static ValueFinfo<PIDController, double> gain( "gain",
"This is the proportional gain (Kp). This tuning parameter scales the"
" proportional term. Larger gain usually results in faster response, but"
" too much will lead to instability and oscillation.",
&PIDController::setGain,
&PIDController::getGain);
static ValueFinfo<PIDController, double> saturation("saturation",
"Bound on the permissible range of output. Defaults to maximum double"
" value.",
&PIDController::setSaturation,
&PIDController::getSaturation);
static ValueFinfo<PIDController, double> command("command",
"The command (desired) value of the sensed parameter. In control theory"
" this is commonly known as setpoint(SP).",
&PIDController::setCommand,
&PIDController::getCommand);
static ReadOnlyValueFinfo<PIDController, double> sensed( "sensed",
"Sensed (measured) value. This is commonly known as process variable"
"(PV) in control theory.",
&PIDController::getSensed);
static ValueFinfo<PIDController, double> tauI( "tauI",
"The integration time constant, typically = dt. This is actually"
" proportional gain divided by integral gain (Kp/Ki)). Larger Ki"
" (smaller tauI) usually leads to fast elimination of steady state"
" errors at the cost of larger overshoot.",
&PIDController::setTauI,
&PIDController::getTauI);
static ValueFinfo<PIDController, double> tauD( "tauD",
"The differentiation time constant, typically = dt / 4. This is"
" derivative gain (Kd) times proportional gain (Kp). Larger Kd (tauD)"
" decreases overshoot at the cost of slowing down transient response"
" and may lead to instability.",
&PIDController::setTauD,
&PIDController::getTauD);
static ReadOnlyValueFinfo<PIDController, double> outputValue( "outputValue",
"Output of the PIDController. This is given by:"
" gain * ( error + INTEGRAL[ error dt ] / tau_i + tau_d * d(error)/dt )\n"
"Where gain = proportional gain (Kp), tau_i = integral gain (Kp/Ki) and"
" tau_d = derivative gain (Kd/Kp). In control theory this is also known"
" as the manipulated variable (MV)",
&PIDController::getOutput);
static ReadOnlyValueFinfo<PIDController, double> error( "error",
"The error term, which is the difference between command and sensed"
" value.",
&PIDController::getError);
static ReadOnlyValueFinfo<PIDController, double> integral( "integral",
"The integral term. It is calculated as INTEGRAL(error dt) ="
" previous_integral + dt * (error + e_previous)/2.",
&PIDController::getEIntegral );
static ReadOnlyValueFinfo<PIDController, double> derivative( "derivative",
"The derivative term. This is (error - e_previous)/dt.",
&PIDController::getEDerivative );
static ReadOnlyValueFinfo<PIDController, double> e_previous( "e_previous",
"The error term for previous step.",
&PIDController::getEPrevious);
static DestFinfo commandIn( "commandIn",
"Command (desired value) input. This is known as setpoint (SP) in"
" control theory." ,
new OpFunc1<PIDController, double>( &PIDController::setCommand ));
static DestFinfo sensedIn( "sensedIn",
"Sensed parameter - this is the one to be tuned. This is known as"
" process variable (PV) in control theory. This comes from the process"
" we are trying to control.",
new OpFunc1<PIDController, double>( &PIDController::setSensed ));
static DestFinfo gainDest( "gainDest",
"Destination message to control the PIDController gain dynamically.",
new OpFunc1<PIDController, double>(&PIDController::setGain));
static SharedFinfo proc( "proc",
"This is a shared message to receive Process messages "
"from the scheduler objects."
"The first entry in the shared msg is a MsgDest "
"for the Process operation. It has a single argument, "
"ProcInfo, which holds lots of information about current "
"time, thread, dt and so on. The second entry is a MsgDest "
"for the Reinit operation. It also uses ProcInfo. ",
processShared, sizeof( processShared ) / sizeof( Finfo* )
);
static Finfo* pidFinfos[] = {
&gain,
&saturation,
&command,
&sensed,
&tauI,
&tauD,
&outputValue,
&error,
&integral,
&derivative,
&e_previous,
outputOut(),
&commandIn,
&sensedIn,
&gainDest,
&proc
};
static string doc[] = {
"Name", "PIDController",
"Author", "Subhasis Ray",
"Description", "PID feedback controller."
"PID stands for Proportional-Integral-Derivative. It is used to"
" feedback control dynamical systems. It tries to create a feedback"
" output such that the sensed (measured) parameter is held at command"
" value. Refer to wikipedia (http://wikipedia.org) for details on PID"
" Controller." };
static Dinfo<PIDController> dinfo;
static Cinfo pidCinfo(
"PIDController",
Neutral::initCinfo(),
pidFinfos,
sizeof( pidFinfos ) / sizeof( Finfo* ),
&dinfo,
doc,
sizeof(doc)/sizeof(string));
return &pidCinfo;
}
static const Cinfo* pidCinfo = PIDController::initCinfo();
PIDController::PIDController():
command_(0),
saturation_(DBL_MAX),
gain_(1),
tau_i_(0),
tau_d_(0),
sensed_(0),
output_(0),
error_(0),
e_integral_(0),
e_derivative_(0),
e_previous_(0)
{
; // do nothing else
}
void PIDController::setCommand( double command)
{
command_ = command;
}
double PIDController::getCommand( ) const
{
return command_;
}
void PIDController::setSensed( double sensed )
{
sensed_ = sensed;
}
double PIDController::getSensed( ) const
{
return sensed_;
}
double PIDController::getOutput( ) const
{
return output_;
}
void PIDController::setGain( double gain )
{
gain_ = gain;
}
double PIDController::getGain( ) const
{
return gain_;
}
void PIDController::setTauI( double tau_i )
{
tau_i_ = tau_i;
}
double PIDController::getTauI( ) const
{
return tau_i_;
}
void PIDController::setTauD( double tau_d )
{
tau_d_ = tau_d;
}
double PIDController::getTauD( ) const
{
return tau_d_;
}
void PIDController::setSaturation( double saturation )
{
if (saturation <= 0) {
cout << "Error: PIDController::setSaturation - saturation must be positive." << endl;
} else {
saturation_ = saturation;
}
}
double PIDController::getSaturation( ) const
{
return saturation_;
}
double PIDController::getError( ) const
{
return error_;
}
double PIDController::getEIntegral( ) const
{
return e_integral_;
}
double PIDController::getEDerivative( ) const
{
return e_derivative_;
}
double PIDController::getEPrevious( ) const
{
return e_previous_;
}
void PIDController::process(const Eref& e, ProcPtr proc )
{
double dt = proc->dt;
e_previous_ = error_;
error_ = command_ - sensed_;
e_integral_ += 0.5 * (error_ + e_previous_) * dt;
e_derivative_ = (error_ - e_previous_) / dt;
output_ = gain_ * (error_ + e_integral_ / tau_i_ + e_derivative_ * tau_d_);
if (output_ > saturation_){
output_ = saturation_;
e_integral_ -= 0.5 * (error_ + e_previous_) * dt;
} else if (output_ < -saturation_){
output_ = -saturation_;
e_integral_ -= 0.5 * (error_ + e_previous_) * dt;
}
outputOut()->send(e, output_);
}
void PIDController::reinit(const Eref& e, ProcPtr proc )
{
if ( tau_i_ <= 0.0 ){
tau_i_ = proc->dt;
}
if ( tau_d_ < 0.0 ){
tau_d_ = proc->dt / 4;
}
sensed_ = 0.0;
output_ = 0;
error_ = 0;
e_previous_ = error_;
e_integral_ = 0;
e_derivative_ = 0;
outputOut()->send(e, output_);
}
//
// PIDController.cpp ends here