diff --git a/PID_v1.cpp b/PID_v1.cpp index 86222c7..7bba81c 100644 --- a/PID_v1.cpp +++ b/PID_v1.cpp @@ -14,19 +14,19 @@ #include /*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 @@ -34,16 +34,16 @@ PID::PID(double* Input, double* Output, double* Setpoint, 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; @@ -58,14 +58,14 @@ 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; - + if(output > outMax) output = outMax; else if(output < outMin) output = outMin; *myOutput = output; - + /*Remember some variables for next time*/ lastInput = input; lastTime = now; @@ -76,21 +76,21 @@ 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); @@ -98,9 +98,9 @@ void PID::SetTunings(double Kp, double Ki, double Kd) 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) { @@ -113,7 +113,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 @@ -127,12 +127,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; } @@ -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) * when the transition from manual to auto occurs, the controller is * automatically initialized - ******************************************************************************/ + ******************************************************************************/ void PID::SetMode(int Mode) { bool newAuto = (Mode == AUTOMATIC); @@ -152,11 +152,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; @@ -166,7 +166,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. @@ -178,13 +178,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; } @@ -192,4 +192,3 @@ double PID::GetKi(){ return dispKi;} double PID::GetKd(){ return dispKd;} int PID::GetMode(){ return inAuto ? AUTOMATIC : MANUAL;} int PID::GetDirection(){ return controllerDirection;} - diff --git a/PID_v1.h b/PID_v1.h index 77b3e4b..5000738 100644 --- a/PID_v1.h +++ b/PID_v1.h @@ -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 @@ -28,36 +28,36 @@ 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(); // 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 @@ -65,10 +65,10 @@ class PID 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; @@ -77,4 +77,3 @@ class PID bool inAuto; }; #endif -