#include <PIDController.h>

Collaboration diagram for PIDController:

Public Member Functions
double	getCommand () const

double	getEDerivative () const

double	getEIntegral () const

double	getEPrevious () const

double	getError () const

double	getGain () const

double	getOutput () const

double	getSaturation () const

double	getSensed () const

double	getTauD () const

double	getTauI () const

	PIDController ()

void	process (const Eref &e, ProcPtr process)

void	reinit (const Eref &e, ProcPtr process)

void	setCommand (double command)

void	setGain (double gain)

void	setSaturation (double saturation)

void	setSensed (double sensed)

void	setTauD (double tau_d)

void	setTauI (double tau_i)

Static Public Member Functions
static const Cinfo *	initCinfo ()

Private Attributes
double	command_

double	e_derivative_

double	e_integral_

double	e_previous_

double	error_

double	gain_

double	output_

double	saturation_

double	sensed_

double	tau_d_

double	tau_i_

Detailed Description

Definition at line 44 of file PIDController.h.

Constructor & Destructor Documentation

PIDController::PIDController ( )

Definition at line 186 of file PIDController.cpp.

                             :
         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
 }

Member Function Documentation

double PIDController::getCommand ( ) const

Definition at line 207 of file PIDController.cpp.

References command_.

Referenced by initCinfo().

 {
     return command_;
 }

Here is the caller graph for this function:

double PIDController::getEDerivative ( ) const

Definition at line 281 of file PIDController.cpp.

References e_derivative_.

Referenced by initCinfo().

 {
     return e_derivative_;
 }

Here is the caller graph for this function:

double PIDController::getEIntegral ( ) const

Definition at line 276 of file PIDController.cpp.

References e_integral_.

Referenced by initCinfo().

 {
     return e_integral_;
 }

Here is the caller graph for this function:

double PIDController::getEPrevious ( ) const

Definition at line 286 of file PIDController.cpp.

References e_previous_.

Referenced by initCinfo().

 {
     return e_previous_;
 }

Here is the caller graph for this function:

double PIDController::getError ( ) const

Definition at line 271 of file PIDController.cpp.

References error_.

Referenced by initCinfo().

 {
     return error_;
 }

Here is the caller graph for this function:

double PIDController::getGain ( ) const

Definition at line 232 of file PIDController.cpp.

References gain_.

Referenced by initCinfo().

 {
     return gain_;
 }

Here is the caller graph for this function:

double PIDController::getOutput ( ) const

Definition at line 222 of file PIDController.cpp.

References output_.

Referenced by initCinfo().

 {
     return output_;
 }

Here is the caller graph for this function:

double PIDController::getSaturation ( ) const

Definition at line 266 of file PIDController.cpp.

References saturation_.

Referenced by initCinfo().

 {
     return saturation_;
 }

Here is the caller graph for this function:

double PIDController::getSensed ( ) const

Definition at line 217 of file PIDController.cpp.

References sensed_.

Referenced by initCinfo().

 {
     return sensed_;
 }

Here is the caller graph for this function:

double PIDController::getTauD ( ) const

Definition at line 252 of file PIDController.cpp.

References tau_d_.

Referenced by initCinfo().

 {
     return tau_d_;
 }

Here is the caller graph for this function:

double PIDController::getTauI ( ) const

Definition at line 242 of file PIDController.cpp.

References tau_i_.

Referenced by initCinfo().

 {
     return tau_i_;
 }

Here is the caller graph for this function:

const Cinfo * PIDController::initCinfo ( )

static

Definition at line 54 of file PIDController.cpp.

References moose::error, getCommand(), getEDerivative(), getEIntegral(), getEPrevious(), getError(), getGain(), getOutput(), getSaturation(), getSensed(), getTauD(), getTauI(), Neutral::initCinfo(), outputOut(), pidCinfo, process(), reinit(), setCommand(), setGain(), setSaturation(), setSensed(), setTauD(), and setTauI().

 {
        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;
 }

Here is the call graph for this function:

void PIDController::process	(	const Eref &	e,
		ProcPtr	process
	)

Definition at line 291 of file PIDController.cpp.

References command_, ProcInfo::dt, e_derivative_, e_integral_, e_previous_, error_, gain_, output_, outputOut(), saturation_, sensed_, tau_d_, and tau_i_.

Referenced by initCinfo().

 {
     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_);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PIDController::reinit	(	const Eref &	e,
		ProcPtr	process
	)

Definition at line 310 of file PIDController.cpp.

References ProcInfo::dt, e_derivative_, e_integral_, e_previous_, error_, output_, outputOut(), sensed_, tau_d_, and tau_i_.

Referenced by initCinfo().

 {
     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_);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PIDController::setCommand ( double command )

Definition at line 202 of file PIDController.cpp.

References command_.

Referenced by initCinfo().

 {
     command_ = command;
 }

Here is the caller graph for this function:

void PIDController::setGain ( double gain )

Definition at line 227 of file PIDController.cpp.

References gain_.

Referenced by initCinfo().

 {
     gain_ = gain;
 }

Here is the caller graph for this function:

void PIDController::setSaturation ( double saturation )

Definition at line 257 of file PIDController.cpp.

References saturation_.

Referenced by initCinfo().

 {
     if (saturation <= 0) {
         cout << "Error: PIDController::setSaturation - saturation must be positive." << endl;
     } else {
         saturation_ = saturation;
     }
 }