Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Allow to inspect P/I/D terms before output #71

Open
wants to merge 4 commits into
base: master
Choose a base branch
from
Open

Allow to inspect P/I/D terms before output #71

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
5d68eb9
set library.json to forked repo
egueli May 13, 2017
75dba97
auto-reformat by Atom/PlatformIO
egueli May 13, 2017
d095a43
add methods to inspect individual terms
egueli May 13, 2017
98045ee
fix library.json before PR
egueli Feb 26, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
66 changes: 36 additions & 30 deletions PID_v1.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,36 +14,36 @@
#include <PID_v1.h>

/*Constructor (...)*********************************************************
* The parameters specified here are those for for which we can't set up
* The parameters specified here are those for for which we can't set up
* reliable defaults, so we need to have the user set them.
***************************************************************************/
PID::PID(double* Input, double* Output, double* Setpoint,
double Kp, double Ki, double Kd, int ControllerDirection)
{

myOutput = Output;
myInput = Input;
mySetpoint = Setpoint;
inAuto = false;
PID::SetOutputLimits(0, 255); //default output limit corresponds to

PID::SetOutputLimits(0, 255); //default output limit corresponds to
//the arduino pwm limits

SampleTime = 100; //default Controller Sample Time is 0.1 seconds

PID::SetControllerDirection(ControllerDirection);
PID::SetTunings(Kp, Ki, Kd);

lastTime = millis()-SampleTime;
lastTime = millis()-SampleTime;
}


/* Compute() **********************************************************************
* This, as they say, is where the magic happens. this function should be called
* every time "void loop()" executes. the function will decide for itself whether a new
* pid Output needs to be computed. returns true when the output is computed,
* false when nothing has been done.
**********************************************************************************/
**********************************************************************************/
bool PID::Compute()
{
if(!inAuto) return false;
Expand All @@ -58,14 +58,17 @@ bool PID::Compute()
if(ITerm > outMax) ITerm= outMax;
else if(ITerm < outMin) ITerm= outMin;
double dInput = (input - lastInput);

/*Compute PID Output*/
double output = kp * error + ITerm- kd * dInput;


/*Compute PID Output and store last values*/
lastPTerm = kp * error;
lastITerm = ITerm;
lastDTerm = -kd * dInput;
double output = lastPTerm + lastITerm + lastDTerm;

if(output > outMax) output = outMax;
else if(output < outMin) output = outMin;
*myOutput = output;

/*Remember some variables for next time*/
lastInput = input;
lastTime = now;
Expand All @@ -76,31 +79,31 @@ bool PID::Compute()


/* SetTunings(...)*************************************************************
* This function allows the controller's dynamic performance to be adjusted.
* This function allows the controller's dynamic performance to be adjusted.
* it's called automatically from the constructor, but tunings can also
* be adjusted on the fly during normal operation
******************************************************************************/
******************************************************************************/
void PID::SetTunings(double Kp, double Ki, double Kd)
{
if (Kp<0 || Ki<0 || Kd<0) return;

dispKp = Kp; dispKi = Ki; dispKd = Kd;
double SampleTimeInSec = ((double)SampleTime)/1000;

double SampleTimeInSec = ((double)SampleTime)/1000;
kp = Kp;
ki = Ki * SampleTimeInSec;
kd = Kd / SampleTimeInSec;

if(controllerDirection ==REVERSE)
{
kp = (0 - kp);
ki = (0 - ki);
kd = (0 - kd);
}
}

/* SetSampleTime(...) *********************************************************
* sets the period, in Milliseconds, at which the calculation is performed
* sets the period, in Milliseconds, at which the calculation is performed
******************************************************************************/
void PID::SetSampleTime(int NewSampleTime)
{
Expand All @@ -113,7 +116,7 @@ void PID::SetSampleTime(int NewSampleTime)
SampleTime = (unsigned long)NewSampleTime;
}
}

/* SetOutputLimits(...)****************************************************
* This function will be used far more often than SetInputLimits. while
* the input to the controller will generally be in the 0-1023 range (which is
Expand All @@ -127,12 +130,12 @@ void PID::SetOutputLimits(double Min, double Max)
if(Min >= Max) return;
outMin = Min;
outMax = Max;

if(inAuto)
{
if(*myOutput > outMax) *myOutput = outMax;
else if(*myOutput < outMin) *myOutput = outMin;

if(ITerm > outMax) ITerm= outMax;
else if(ITerm < outMin) ITerm= outMin;
}
Expand All @@ -142,7 +145,7 @@ void PID::SetOutputLimits(double Min, double Max)
* Allows the controller Mode to be set to manual (0) or Automatic (non-zero)
* when the transition from manual to auto occurs, the controller is
* automatically initialized
******************************************************************************/
******************************************************************************/
void PID::SetMode(int Mode)
{
bool newAuto = (Mode == AUTOMATIC);
Expand All @@ -152,11 +155,11 @@ void PID::SetMode(int Mode)
}
inAuto = newAuto;
}

/* Initialize()****************************************************************
* does all the things that need to happen to ensure a bumpless transfer
* from manual to automatic mode.
******************************************************************************/
******************************************************************************/
void PID::Initialize()
{
ITerm = *myOutput;
Expand All @@ -166,7 +169,7 @@ void PID::Initialize()
}

/* SetControllerDirection(...)*************************************************
* The PID will either be connected to a DIRECT acting process (+Output leads
* The PID will either be connected to a DIRECT acting process (+Output leads
* to +Input) or a REVERSE acting process(+Output leads to -Input.) we need to
* know which one, because otherwise we may increase the output when we should
* be decreasing. This is called from the constructor.
Expand All @@ -178,13 +181,13 @@ void PID::SetControllerDirection(int Direction)
kp = (0 - kp);
ki = (0 - ki);
kd = (0 - kd);
}
}
controllerDirection = Direction;
}

/* Status Funcions*************************************************************
* Just because you set the Kp=-1 doesn't mean it actually happened. these
* functions query the internal state of the PID. they're here for display
* functions query the internal state of the PID. they're here for display
* purposes. this are the functions the PID Front-end uses for example
******************************************************************************/
double PID::GetKp(){ return dispKp; }
Expand All @@ -193,3 +196,6 @@ double PID::GetKd(){ return dispKd;}
int PID::GetMode(){ return inAuto ? AUTOMATIC : MANUAL;}
int PID::GetDirection(){ return controllerDirection;}

double PID::GetLastPTerm() { return lastPTerm; }
double PID::GetLastITerm() { return lastITerm; }
double PID::GetLastDTerm() { return lastDTerm; }
35 changes: 20 additions & 15 deletions PID_v1.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,9 +15,9 @@ class PID
#define REVERSE 1

//commonly used functions **************************************************************************
PID(double*, double*, double*, // * constructor. links the PID to the Input, Output, and
PID(double*, double*, double*, // * constructor. links the PID to the Input, Output, and
double, double, double, int); // Setpoint. Initial tuning parameters are also set here

void SetMode(int Mode); // * sets PID to either Manual (0) or Auto (non-0)

bool Compute(); // * performs the PID calculation. it should be
Expand All @@ -28,53 +28,58 @@ class PID
void SetOutputLimits(double, double); //clamps the output to a specific range. 0-255 by default, but
//it's likely the user will want to change this depending on
//the application



//available but not commonly used functions ********************************************************
void SetTunings(double, double, // * While most users will set the tunings once in the
void SetTunings(double, double, // * While most users will set the tunings once in the
double); // constructor, this function gives the user the option
// of changing tunings during runtime for Adaptive control
void SetControllerDirection(int); // * Sets the Direction, or "Action" of the controller. DIRECT
// means the output will increase when error is positive. REVERSE
// means the opposite. it's very unlikely that this will be needed
// once it is set in the constructor.
void SetSampleTime(int); // * sets the frequency, in Milliseconds, with which
void SetSampleTime(int); // * sets the frequency, in Milliseconds, with which
// the PID calculation is performed. default is 100



//Display functions ****************************************************************
double GetKp(); // These functions query the pid for interal values.
double GetKi(); // they were created mainly for the pid front-end,
double GetKd(); // where it's important to know what is actually
double GetKd(); // where it's important to know what is actually
int GetMode(); // inside the PID.
int GetDirection(); //

double GetLastPTerm();
double GetLastITerm();
double GetLastDTerm();

private:
void Initialize();
double dispKp; // * we'll hold on to the tuning parameters in user-entered

double dispKp; // * we'll hold on to the tuning parameters in user-entered
double dispKi; // format for display purposes
double dispKd; //

double kp; // * (P)roportional Tuning Parameter
double ki; // * (I)ntegral Tuning Parameter
double kd; // * (D)erivative Tuning Parameter

int controllerDirection;

double *myInput; // * Pointers to the Input, Output, and Setpoint variables
double *myOutput; // This creates a hard link between the variables and the
double *myOutput; // This creates a hard link between the variables and the
double *mySetpoint; // PID, freeing the user from having to constantly tell us
// what these values are. with pointers we'll just know.

unsigned long lastTime;
double ITerm, lastInput;

double lastPTerm, lastITerm, lastDTerm; // last P/I/D terms calculated

unsigned long SampleTime;
double outMin, outMax;
bool inAuto;
};
#endif