Brewery/Arduino-PID-Library
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

auto-reformat by Atom/PlatformIO

Browse Source
This commit is contained in:
Enrico Gueli 2017-05-13 21:07:19 +02:00
parent 5d68eb9020
commit 75dba97d45
2 changed files with 42 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
PID_v1.cpp
View File

@ -14,19 +14,19 @@
#include <PID_v1.h> #include <PID_v1.h>
/*Constructor (...)********************************************************* /*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. * reliable defaults, so we need to have the user set them.
***************************************************************************/ ***************************************************************************/
PID::PID(double* Input, double* Output, double* Setpoint, PID::PID(double* Input, double* Output, double* Setpoint,
double Kp, double Ki, double Kd, int ControllerDirection) double Kp, double Ki, double Kd, int ControllerDirection)
{ {
myOutput = Output; myOutput = Output;
myInput = Input; myInput = Input;
mySetpoint = Setpoint; mySetpoint = Setpoint;
inAuto = false; inAuto = false;
PID::SetOutputLimits(0, 255); //default output limit corresponds to PID::SetOutputLimits(0, 255); //default output limit corresponds to
//the arduino pwm limits //the arduino pwm limits
SampleTime = 100; //default Controller Sample Time is 0.1 seconds SampleTime = 100; //default Controller Sample Time is 0.1 seconds
@ -34,16 +34,16 @@ PID::PID(double* Input, double* Output, double* Setpoint,
PID::SetControllerDirection(ControllerDirection); PID::SetControllerDirection(ControllerDirection);
PID::SetTunings(Kp, Ki, Kd); PID::SetTunings(Kp, Ki, Kd);
lastTime = millis()-SampleTime; lastTime = millis()-SampleTime;
} }
/* Compute() ********************************************************************** /* Compute() **********************************************************************
* This, as they say, is where the magic happens. this function should be called * 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 * 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, * pid Output needs to be computed. returns true when the output is computed,
* false when nothing has been done. * false when nothing has been done.
**********************************************************************************/ **********************************************************************************/
bool PID::Compute() bool PID::Compute()
{ {
if(!inAuto) return false; if(!inAuto) return false;
@ -58,14 +58,14 @@ bool PID::Compute()
if(ITerm > outMax) ITerm= outMax; if(ITerm > outMax) ITerm= outMax;
else if(ITerm < outMin) ITerm= outMin; else if(ITerm < outMin) ITerm= outMin;
double dInput = (input - lastInput); double dInput = (input - lastInput);
/*Compute PID Output*/ /*Compute PID Output*/
double output = kp * error + ITerm- kd * dInput; double output = kp * error + ITerm- kd * dInput;
if(output > outMax) output = outMax; if(output > outMax) output = outMax;
else if(output < outMin) output = outMin; else if(output < outMin) output = outMin;
*myOutput = output; *myOutput = output;
/*Remember some variables for next time*/ /*Remember some variables for next time*/
lastInput = input; lastInput = input;
lastTime = now; lastTime = now;
@ -76,21 +76,21 @@ bool PID::Compute()
/* SetTunings(...)************************************************************* /* 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 * it's called automatically from the constructor, but tunings can also
* be adjusted on the fly during normal operation * be adjusted on the fly during normal operation
******************************************************************************/ ******************************************************************************/
void PID::SetTunings(double Kp, double Ki, double Kd) void PID::SetTunings(double Kp, double Ki, double Kd)
{ {
if (Kp<0 || Ki<0 || Kd<0) return; if (Kp<0 || Ki<0 || Kd<0) return;
dispKp = Kp; dispKi = Ki; dispKd = Kd; dispKp = Kp; dispKi = Ki; dispKd = Kd;
double SampleTimeInSec = ((double)SampleTime)/1000; double SampleTimeInSec = ((double)SampleTime)/1000;
kp = Kp; kp = Kp;
ki = Ki * SampleTimeInSec; ki = Ki * SampleTimeInSec;
kd = Kd / SampleTimeInSec; kd = Kd / SampleTimeInSec;
if(controllerDirection ==REVERSE) if(controllerDirection ==REVERSE)
{ {
kp = (0 - kp); kp = (0 - kp);
@ -98,9 +98,9 @@ void PID::SetTunings(double Kp, double Ki, double Kd)
kd = (0 - kd); kd = (0 - kd);
} }
} }
/* SetSampleTime(...) ********************************************************* /* 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) void PID::SetSampleTime(int NewSampleTime)
{ {
@ -113,7 +113,7 @@ void PID::SetSampleTime(int NewSampleTime)
SampleTime = (unsigned long)NewSampleTime; SampleTime = (unsigned long)NewSampleTime;
} }
} }
/* SetOutputLimits(...)**************************************************** /* SetOutputLimits(...)****************************************************
* This function will be used far more often than SetInputLimits. while * 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 * the input to the controller will generally be in the 0-1023 range (which is
@ -127,12 +127,12 @@ void PID::SetOutputLimits(double Min, double Max)
if(Min >= Max) return; if(Min >= Max) return;
outMin = Min; outMin = Min;
outMax = Max; outMax = Max;
if(inAuto) if(inAuto)
{ {
if(*myOutput > outMax) *myOutput = outMax; if(*myOutput > outMax) *myOutput = outMax;
else if(*myOutput < outMin) *myOutput = outMin; else if(*myOutput < outMin) *myOutput = outMin;
if(ITerm > outMax) ITerm= outMax; if(ITerm > outMax) ITerm= outMax;
else if(ITerm < outMin) ITerm= outMin; else if(ITerm < outMin) ITerm= outMin;
} }
@ -142,7 +142,7 @@ void PID::SetOutputLimits(double Min, double Max)
* Allows the controller Mode to be set to manual (0) or Automatic (non-zero) * 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 * when the transition from manual to auto occurs, the controller is
* automatically initialized * automatically initialized
******************************************************************************/ ******************************************************************************/
void PID::SetMode(int Mode) void PID::SetMode(int Mode)
{ {
bool newAuto = (Mode == AUTOMATIC); bool newAuto = (Mode == AUTOMATIC);
@ -152,11 +152,11 @@ void PID::SetMode(int Mode)
} }
inAuto = newAuto; inAuto = newAuto;
} }
/* Initialize()**************************************************************** /* Initialize()****************************************************************
* does all the things that need to happen to ensure a bumpless transfer * does all the things that need to happen to ensure a bumpless transfer
* from manual to automatic mode. * from manual to automatic mode.
******************************************************************************/ ******************************************************************************/
void PID::Initialize() void PID::Initialize()
{ {
ITerm = *myOutput; ITerm = *myOutput;
@ -166,7 +166,7 @@ void PID::Initialize()
} }
/* SetControllerDirection(...)************************************************* /* 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 * 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 * know which one, because otherwise we may increase the output when we should
* be decreasing. This is called from the constructor. * be decreasing. This is called from the constructor.
@ -178,13 +178,13 @@ void PID::SetControllerDirection(int Direction)
kp = (0 - kp); kp = (0 - kp);
ki = (0 - ki); ki = (0 - ki);
kd = (0 - kd); kd = (0 - kd);
} }
controllerDirection = Direction; controllerDirection = Direction;
} }
/* Status Funcions************************************************************* /* Status Funcions*************************************************************
* Just because you set the Kp=-1 doesn't mean it actually happened. these * 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 * purposes. this are the functions the PID Front-end uses for example
******************************************************************************/ ******************************************************************************/
double PID::GetKp(){ return dispKp; } double PID::GetKp(){ return dispKp; }
@ -192,4 +192,3 @@ double PID::GetKi(){ return dispKi;}
double PID::GetKd(){ return dispKd;} double PID::GetKd(){ return dispKd;}
int PID::GetMode(){ return inAuto ? AUTOMATIC : MANUAL;} int PID::GetMode(){ return inAuto ? AUTOMATIC : MANUAL;}
int PID::GetDirection(){ return controllerDirection;} int PID::GetDirection(){ return controllerDirection;}

29
PID_v1.h
View File

@ -15,9 +15,9 @@ class PID
#define REVERSE 1 #define REVERSE 1
//commonly used functions ************************************************************************** //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 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) void SetMode(int Mode); // * sets PID to either Manual (0) or Auto (non-0)
bool Compute(); // * performs the PID calculation. it should be bool Compute(); // * performs the PID calculation. it should be
@ -28,36 +28,36 @@ class PID
void SetOutputLimits(double, double); //clamps the output to a specific range. 0-255 by default, but 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 //it's likely the user will want to change this depending on
//the application //the application
//available but not commonly used functions ******************************************************** //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 double); // constructor, this function gives the user the option
// of changing tunings during runtime for Adaptive control // of changing tunings during runtime for Adaptive control
void SetControllerDirection(int); // * Sets the Direction, or "Action" of the controller. DIRECT void SetControllerDirection(int); // * Sets the Direction, or "Action" of the controller. DIRECT
// means the output will increase when error is positive. REVERSE // means the output will increase when error is positive. REVERSE
// means the opposite. it's very unlikely that this will be needed // means the opposite. it's very unlikely that this will be needed
// once it is set in the constructor. // 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 // the PID calculation is performed. default is 100
//Display functions **************************************************************** //Display functions ****************************************************************
double GetKp(); // These functions query the pid for interal values. double GetKp(); // These functions query the pid for interal values.
double GetKi(); // they were created mainly for the pid front-end, 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 GetMode(); // inside the PID.
int GetDirection(); // int GetDirection(); //
private: private:
void Initialize(); 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 dispKi; // format for display purposes
double dispKd; // double dispKd; //
double kp; // * (P)roportional Tuning Parameter double kp; // * (P)roportional Tuning Parameter
double ki; // * (I)ntegral Tuning Parameter double ki; // * (I)ntegral Tuning Parameter
double kd; // * (D)erivative Tuning Parameter double kd; // * (D)erivative Tuning Parameter
@ -65,10 +65,10 @@ class PID
int controllerDirection; int controllerDirection;
double *myInput; // * Pointers to the Input, Output, and Setpoint variables 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 double *mySetpoint; // PID, freeing the user from having to constantly tell us
// what these values are. with pointers we'll just know. // what these values are. with pointers we'll just know.
unsigned long lastTime; unsigned long lastTime;
double ITerm, lastInput; double ITerm, lastInput;
@ -77,4 +77,3 @@ class PID
bool inAuto; bool inAuto;
}; };
#endif #endif