diff --git a/PID_AutoTune_v0.cpp b/PID_AutoTune_v0.cpp deleted file mode 100644 index 43decdc..0000000 --- a/PID_AutoTune_v0.cpp +++ /dev/null @@ -1,196 +0,0 @@ -#if ARDUINO >= 100 - #include "Arduino.h" -#else - #include "WProgram.h" -#endif - -#include "PID_AutoTune_v0.h" - - -PID_ATune::PID_ATune(double* Input, double* Output) -{ - input = Input; - output = Output; - controlType =0 ; //default to PI - noiseBand = 0.5; - running = false; - oStep = 30; - SetLookbackSec(10); - lastTime = millis(); - -} - - - -void PID_ATune::Cancel() -{ - running = false; -} - -int PID_ATune::Runtime() -{ - //~ justevaled=false; - if(peakCount>9 && running) - { - running = false; - FinishUp(); - return 1; - } - unsigned long now = millis(); - - if((now-lastTime)absMax)absMax=refVal; - if(refValsetpoint+noiseBand) *output = outputStart-oStep; - else if (refVal=0;i--) - { - double val = lastInputs[i]; - if(isMax) isMax = refVal>val; - if(isMin) isMin = refVal2) - { //we've transitioned. check if we can autotune based on the last peaks - double avgSeparation = (abs(peaks[peakCount-1]-peaks[peakCount-2])+abs(peaks[peakCount-2]-peaks[peakCount-3]))/2; - if( avgSeparation < 0.05*(absMax-absMin)) - { - FinishUp(); - running = false; - return 1; - - } - } - atune_peak_change=false; - return 0; -} -void PID_ATune::FinishUp() -{ - *output = outputStart; - //we can generate tuning parameters! - Ku = 4*(2*oStep)/((absMax-absMin)*3.14159); - Pu = (double)(peak1-peak2) / 1000; -} - -double PID_ATune::GetKp() -{ - return controlType==1 ? 0.6 * Ku : 0.4 * Ku; -} - -double PID_ATune::GetKi() -{ - return controlType==1? 1.2*Ku / Pu : 0.48 * Ku / Pu; // Ki = Kc/Ti -} - -double PID_ATune::GetKd() -{ - return controlType==1? 0.075 * Ku * Pu : 0; //Kd = Kc * Td -} - -void PID_ATune::SetOutputStep(double Step) -{ - oStep = Step; -} - -double PID_ATune::GetOutputStep() -{ - return oStep; -} - -void PID_ATune::SetControlType(int Type) //0=PI, 1=PID -{ - controlType = Type; -} -int PID_ATune::GetControlType() -{ - return controlType; -} - -void PID_ATune::SetNoiseBand(double Band) -{ - noiseBand = Band; -} - -double PID_ATune::GetNoiseBand() -{ - return noiseBand; -} - -void PID_ATune::SetLookbackSec(int value) -{ - if (value<1) value = 1; - - if(value<25) - { - nLookBack = value * 4; - sampleTime = 250; - } - else - { - nLookBack = 100; - sampleTime = value*10; - } -} - -int PID_ATune::GetLookbackSec() -{ - return nLookBack * sampleTime / 1000; -} diff --git a/PID_AutoTune_v0.h b/PID_AutoTune_v0.h deleted file mode 100644 index 6e8ff19..0000000 --- a/PID_AutoTune_v0.h +++ /dev/null @@ -1,55 +0,0 @@ -#ifndef PID_AutoTune_v0 -#define PID_AutoTune_v0 -#define LIBRARY_VERSION 0.0.1 - -class PID_ATune -{ - - - public: - //commonly used functions ************************************************************************** - PID_ATune(double*, double*); // * Constructor. links the Autotune to a given PID - int Runtime(); // * Similar to the PID Compue function, returns non 0 when done - void Cancel(); // * Stops the AutoTune - - void SetOutputStep(double); // * how far above and below the starting value will the output step? - double GetOutputStep(); // - - void SetControlType(int); // * Determies if the tuning parameters returned will be PI (D=0) - int GetControlType(); // or PID. (0=PI, 1=PID) - - void SetLookbackSec(int); // * how far back are we looking to identify peaks - int GetLookbackSec(); // - - void SetNoiseBand(double); // * the autotune will ignore signal chatter smaller than this value - double GetNoiseBand(); // this should be acurately set - - double GetKp(); // * once autotune is complete, these functions contain the - double GetKi(); // computed tuning parameters. - double GetKd(); // - - private: - void FinishUp(); - bool isMax, isMin; - double *input, *output; - double setpoint; - double noiseBand; - int controlType; - bool running; - unsigned long peak1, peak2, lastTime; - int sampleTime; - int nLookBack; - int peakType; - double lastInputs[101]; - double peaks[10]; - int peakCount; - bool atune_peak_change; - //~ bool justevaled; - double absMax, absMin; - double oStep; - double outputStart; - double Ku, Pu; - -}; -#endif - diff --git a/PID_v1.cpp b/PID_v1.cpp index 4c963b9..517d28d 100644 --- a/PID_v1.cpp +++ b/PID_v1.cpp @@ -1,397 +1,338 @@ /********************************************************************************************** - * Arduino PID Library - Version 1.2.1 - * by Brett Beauregard brettbeauregard.com - * - * This Library is licensed under the MIT License - **********************************************************************************************/ +* Arduino PID Library - Version 1.2.1 +* by Brett Beauregard brettbeauregard.com +* +* This Library is licensed under the MIT License +**********************************************************************************************/ #if ARDUINO >= 100 #include "Arduino.h" -#else + #else #include "WProgram.h" #endif #include "PID_v1.h" /*Constructor (...)********************************************************* - * 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. - ***************************************************************************/ +* 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 POn, int ControllerDirection) -{ - myOutput = Output; - myInput = Input; - mySetpoint = Setpoint; - inAuto = false; - //Tuner = new PID_ATune(Input, Output); - PID::SetOutputLimits(0, 100); //Arduino PWM limits 0-255 + double Kp, double Ki, double Kd, int POn, int ControllerDirection) { + myOutput = Output; + myInput = Input; + mySetpoint = Setpoint; + inAuto = false; + //Tuner = new PID_ATune(Input, Output); + PID::OutputLimits(0, 100); + PID::Direction(ControllerDirection); + PID::SetTunings(Kp, Ki, Kd, POn); - SampleTime = 100; //default Controller Sample Time is 0.1 seconds + // Autotune defaults + noise_band = 0.5; + autotune_running = false; + oStep = 30; + LookbackSec(10); - PID::SetControllerDirection(ControllerDirection); - PID::SetTunings(Kp, Ki, Kd, POn); - - lastTime = millis()-SampleTime; + SampleTime = 100; //default Controller Sample Time is 0.1 seconds + lastTime = millis()-SampleTime; } /*Constructor (...)********************************************************* - * To allow backwards compatability for v1.1, or for people that just want - * to use Proportional on Error without explicitly saying so - ***************************************************************************/ +* To allow backwards compatability for v1.1, or for people that just want +* to use Proportional on Error without explicitly saying so +***************************************************************************/ PID::PID(double* Input, double* Output, double* Setpoint, - double Kp, double Ki, double Kd, int ControllerDirection) - :PID::PID(Input, Output, Setpoint, Kp, Ki, Kd, P_ON_E, ControllerDirection) -{ +double Kp, double Ki, double Kd, int ControllerDirection) +:PID::PID(Input, Output, Setpoint, Kp, Ki, Kd, P_ON_E, ControllerDirection) { } /* 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; - unsigned long now = millis(); - unsigned long timeChange = (now - lastTime); - if(timeChange>=SampleTime) - { - /*Compute all the working error variables*/ - double input = *myInput; - double error = *mySetpoint - input; - double dInput = (input - lastInput); - outputSum+= (ki * error); +* 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; + unsigned long now = millis(); + unsigned long timeChange = (now - lastTime); + if(timeChange>=SampleTime) { + /*Compute all the working error variables*/ + double input = *myInput; + double error = *mySetpoint - input; + double dInput = (input - lastInput); + outputSum+= (ki * error); - /*Add Proportional on Measurement, if P_ON_M is specified*/ - if(!pOnE) outputSum-= kp * dInput; + /*Add Proportional on Measurement, if P_ON_M is specified*/ + if(!pOnE) outputSum-= kp * dInput; - if(outputSum > outMax) outputSum= outMax; - else if(outputSum < outMin) outputSum= outMin; + if(outputSum > outMax) outputSum= outMax; + else if(outputSum < outMin) outputSum= outMin; - /*Add Proportional on Error, if P_ON_E is specified*/ - double output; - if(pOnE) output = kp * error; - else output = 0; + /*Add Proportional on Error, if P_ON_E is specified*/ + double output; + if(pOnE) output = kp * error; + else output = 0; - /*Compute Rest of PID Output*/ - output += outputSum - kd * dInput; + /*Compute Rest of PID Output*/ + output += outputSum - kd * dInput; - if(output > outMax) output = outMax; - else if(output < outMin) output = outMin; - *myOutput = output; + if(output > outMax) output = outMax; + else if(output < outMin) output = outMin; + *myOutput = output; - /*Remember some variables for next time*/ - lastInput = input; - lastTime = now; - return true; - } - else return false; + /*Remember some variables for next time*/ + lastInput = input; + lastTime = now; + return true; + } + else return false; } int PID::ComputeTune() { - //~ justevaled=false; - if(peakCount>9 && running) - { - running = false; - FinishUp(); - return 1; - } - unsigned long now = millis(); + //~ justevaled=false; + if(peakCount>9 && autotune_running) { + autotune_running = false; + FinishUp(); + return 1; + } + unsigned long now = millis(); + + if((now-lastTime)absMax)absMax=refVal; + if(refValabsMax)absMax=refVal; + if(refVal*mySetpoint+noise_band) *myOutput = outputStart-oStep; + else if (refVal<*mySetpoint-noise_band) *myOutput = outputStart+oStep; - if((now-lastTime)absMax)absMax=refVal; - if(refVal*mySetpoint+noiseBand) *myOutput = outputStart-oStep; - else if (refVal<*mySetpoint-noiseBand) *myOutput = outputStart+oStep; - - //bool isMax=true, isMin=true; isMax=true;isMin=true; //id peaks - for(int i=nLookBack-1;i>=0;i--) - { + for(int i=nLookBack-1;i>=0;i--) { double val = lastInputs[i]; if(isMax) isMax = refVal>val; if(isMin) isMin = refVal2) - { //we've transitioned. check if we can autotune based on the last peaks + + if(atune_peak_change && peakCount>2) { + //we've transitioned. check if we can autotune based on the last peaks double avgSeparation = (abs(peaks[peakCount-1]-peaks[peakCount-2])+abs(peaks[peakCount-2]-peaks[peakCount-3]))/2; - if( avgSeparation < 0.05*(absMax-absMin)) - { - FinishUp(); - running = false; - return 1; - + if( avgSeparation < 0.05*(absMax-absMin)){ + FinishUp(); + autotune_running = false; + return 1; + } } - atune_peak_change=false; - return 0; + atune_peak_change=false; + return 0; } -void PID::FinishUp() -{ - *myOutput = outputStart; - //we can generate tuning parameters! - Ku = 4*(2*oStep)/((absMax-absMin)*3.14159); - Pu = (double)(peak1-peak2) / 1000; +void PID::FinishUp(){ + *myOutput = outputStart; + //we can generate tuning parameters! + Ku = 4*(2*oStep)/((absMax-absMin)*3.14159); + Pu = (double)(peak1-peak2) / 1000; } /* SetTunings(...)************************************************************* - * 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, int POn) -{ - if (Kp<0 || Ki<0 || Kd<0) return; +* 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, int POn){ + if (Kp<0 || Ki<0 || Kd<0) return; - pOn = POn; - pOnE = POn == P_ON_E; + pOn = POn; + pOnE = POn == P_ON_E; - dispKp = Kp; dispKi = Ki; dispKd = Kd; + double SampleTimeInSec = ((double)SampleTime)/1000; + kp = Kp; + ki = Ki * SampleTimeInSec; + kd = Kd / SampleTimeInSec; - 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); - } + if(controllerDirection ==REVERSE){ + kp = (0 - kp); + ki = (0 - ki); + kd = (0 - kd); + } } /* SetTunings(...)************************************************************* - * Set Tunings using the last-rembered POn setting - ******************************************************************************/ +* Set Tunings using the last-rembered POn setting +******************************************************************************/ void PID::SetTunings(double Kp, double Ki, double Kd){ - SetTunings(Kp, Ki, Kd, pOn); + SetTunings(Kp, Ki, Kd, pOn); } /* SetSampleTime(...) ********************************************************* - * sets the period, in Milliseconds, at which the calculation is performed - ******************************************************************************/ -void PID::SetSampleTime(int NewSampleTime) -{ - if (NewSampleTime > 0) - { - double ratio = (double)NewSampleTime - / (double)SampleTime; - ki *= ratio; - kd /= ratio; - SampleTime = (unsigned long)NewSampleTime; - } +* sets the period, in Milliseconds, at which the calculation is performed +******************************************************************************/ +void PID::SampleTime(int NewSampleTime){ + if (NewSampleTime > 0){ + double ratio = (double)NewSampleTime + / (double)SampleTime; + ki *= ratio; + kd /= ratio; + 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 - * the default already,) the output will be a little different. maybe they'll - * be doing a time window and will need 0-8000 or something. or maybe they'll - * want to clamp it from 0-125. who knows. at any rate, that can all be done - * here. - **************************************************************************/ -void PID::SetOutputLimits(double Min, double Max) -{ - if(Min >= Max) return; - outMin = Min; - outMax = Max; +/* OutputLimits(...)******************************************************* +* 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 default already,) the output will be a little different. maybe they'll +* be doing a time window and will need 0-8000 or something. or maybe they'll +* want to clamp it from 0-125. who knows. at any rate, that can all be done +* here. +**************************************************************************/ +void PID::OutputLimits(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(inAuto){ + if(*myOutput > outMax) *myOutput = outMax; + else if(*myOutput < outMin) *myOutput = outMin; - if(outputSum > outMax) outputSum= outMax; - else if(outputSum < outMin) outputSum= outMin; - } + if(outputSum > outMax) outputSum= outMax; + else if(outputSum < outMin) outputSum= outMin; + } } -/* SetMode(...)**************************************************************** - * 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::Mode(int Mode) -{ - bool newAuto = (Mode == 1); - if(newAuto && !inAuto) - { /*we just went from manual to auto*/ - PID::Initialize(); - } - inAuto = newAuto; - OpMode = Mode; +/* Mode(...)******************************************************************* +* 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::Mode(int Mode){ + bool newAuto = (Mode == 1); + if(newAuto && !inAuto){ /*we just went from manual to auto*/ + PID::Initialize(); + } + inAuto = newAuto; + OpMode = Mode; } int PID::CycleMode() { if (OpMode + 1 == 3) { PID::Mode(0); - } else { + } else { PID::Mode(OpMode + 1); } - + return OpMode; } /* Initialize()**************************************************************** - * does all the things that need to happen to ensure a bumpless transfer - * from manual to automatic mode. - ******************************************************************************/ -void PID::Initialize() -{ - outputSum = *myOutput; - lastInput = *myInput; - if(outputSum > outMax) outputSum = outMax; - else if(outputSum < outMin) outputSum = outMin; +* does all the things that need to happen to ensure a bumpless transfer +* from manual to automatic mode. +******************************************************************************/ +void PID::Initialize(){ + outputSum = *myOutput; + lastInput = *myInput; + if(outputSum > outMax) outputSum = outMax; + else if(outputSum < outMin) outputSum = outMin; } -/* SetControllerDirection(...)************************************************* - * 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. - ******************************************************************************/ -void PID::SetControllerDirection(int Direction) -{ - if(inAuto && Direction !=controllerDirection) - { - kp = (0 - kp); - ki = (0 - ki); - kd = (0 - kd); - } - controllerDirection = Direction; +/* Direction(...)************************************************************** +* 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. +******************************************************************************/ +void PID::Direction(int Direction){ + if(inAuto && Direction !=controllerDirection){ + 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 - * purposes. this are the functions the PID Front-end uses for example - ******************************************************************************/ -double PID::GetKp(){ return dispKp; } -double PID::GetKi(){ return dispKi;} -double PID::GetKd(){ return dispKd;} +* 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 +* purposes. this are the functions the PID Front-end uses for example +******************************************************************************/ +double PID::Kp(){ return Kp; } +double PID::Ki(){ return Ki;} +double PID::Kd(){ return Kd;} int PID::Mode(){ return OpMode;} -int PID::GetDirection(){ return controllerDirection;} -void PID::Cancel() -{ - running = false; -} +int PID::Direction(){ return controllerDirection;} +void PID::Cancel(){ autotune_running = false;} +double PID::TunedKp(){ return 0.6 * Ku;} +double PID::TunedKi(){ return 1.2*Ku / Pu ; // Ki = Kc/Ti} + double PID::TunedKd(){ return 0.075 * Ku * Pu; //Kd = Kc * Td} + void PID::SetOutputStep(double Step){ oStep = Step;} + double PID::GetOutputStep(){ return oStep;} + void PID::SetNoiseBand(double Band){ noise_band = Band;} + double PID::GetNoiseBand(){ return noise_band;} -double PID::TunedKp() -{ - return 0.6 * Ku; -} + void PID::LookbackSec(int value){ + if (value<1) value = 1; -double PID::TunedKi() -{ - return 1.2*Ku / Pu ; // Ki = Kc/Ti -} + if(value<25) { + nLookBack = value * 4; + sampleTime = 250; + } else { + nLookBack = 100; + sampleTime = value*10; + } + } -double PID::TunedKd() -{ - return 0.075 * Ku * Pu; //Kd = Kc * Td -} - -void PID::SetOutputStep(double Step) -{ - oStep = Step; -} - -double PID::GetOutputStep() -{ - return oStep; -} - -void PID::SetNoiseBand(double Band) -{ - noiseBand = Band; -} - -double PID::GetNoiseBand() -{ - return noiseBand; -} - -void PID::SetLookbackSec(int value) -{ - if (value<1) value = 1; - - if(value<25) - { - nLookBack = value * 4; - sampleTime = 250; - } - else - { - nLookBack = 100; - sampleTime = value*10; - } -} - -int PID::GetLookbackSec() -{ - return nLookBack * sampleTime / 1000; -} + int PID::LookbackSec(){ return nLookBack * sampleTime / 1000;} diff --git a/PID_v1.h b/PID_v1.h index e4e8603..5a93d32 100644 --- a/PID_v1.h +++ b/PID_v1.h @@ -1,7 +1,8 @@ #ifndef PID_v1_h #define PID_v1_h -#define LIBRARY_VERSION 1.2.1 +#define LIBRARY_VERSION 1.2.1 +enum modes : uint8_t {OFF, AUTOMATIC, MANUAL, OVERFLOW}; class PID { @@ -20,103 +21,97 @@ class PID 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 Mode(int Mode); // * sets PID to either Manual or Auto + + void Mode(int Mode); // * sets PID to either Manual or Auto int CycleMode(); bool Compute(); // * performs the PID calculation. it should be // called every time loop() cycles. ON/OFF and // calculation frequency can be set using SetMode // SetSampleTime respectively int ComputeTune(); - 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 - + void OutputLimits(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 - 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 void SetTunings(double, double, // * overload for specifying proportional mode - double, int); + double, int); - 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 Direction(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 SampleTime(int); // * sets the frequency, in Milliseconds, with which // the PID calculation is performed. default is 100 - void AutoTune(); - - + //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 - int Mode(); // inside the PID. - int GetDirection(); // + double Kp(); // These functions query the pid for interal values. + double Ki(); // they were created mainly for the pid front-end, + double Kd(); // where it's important to know what is actually + modes Mode(); // inside the PID. + int Direction(); // // Auto Tune Public - void Cancel(); // * Stops the AutoTune - - void SetOutputStep(double); // * how far above and below the starting value will the output step? - double GetOutputStep(); // + void Cancel(); // * Stops the AutoTune + + void SetOutputStep(double); // * how far above and below the starting value will the output step? + double GetOutputStep(); // - void SetLookbackSec(int); // * how far back are we looking to identify peaks - int GetLookbackSec(); // - - void SetNoiseBand(double); // * the autotune will ignore signal chatter smaller than this value - double GetNoiseBand(); // this should be acurately set - - double TunedKp(); // * once autotune is complete, these functions contain the - double TunedKi(); // computed tuning parameters. - double TunedKd(); + void LookbackSec(int); // * how far back are we looking to identify peaks + int LookbackSec(); // + + void SetNoiseBand(double); // * the autotune will ignore signal chatter smaller than this value + double GetNoiseBand(); // this should be acurately set + + double TunedKp(); // * once autotune is complete, these functions contain the + double TunedKi(); // computed tuning parameters. + double TunedKd(); private: - void Initialize(); - - double dispKp; // * we'll hold on to the tuning parameters in user-entered - double dispKi; // format for display purposes - double dispKd; // + void Initialize(); - double kp; // * (P)roportional Tuning Parameter - double ki; // * (I)ntegral Tuning Parameter - double kd; // * (D)erivative Tuning Parameter + double kp; // * (P)roportional Tuning Parameter + double ki; // * (I)ntegral Tuning Parameter + double kd; // * (D)erivative Tuning Parameter - int controllerDirection; - int pOn; + int controllerDirection; + int pOn; - double *myInput; // * Pointers to the Input, Output, and Setpoint variables - 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 outputSum, lastInput; + double *myInput; // * Pointers to the Input, Output, and Setpoint variables + 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 outputSum, lastInput; - unsigned long SampleTime; - double outMin, outMax; - bool inAuto, pOnE; - int OpMode; + unsigned long SampleTime; + double outMin, outMax; + bool inAuto, pOnE; + modes OpMode; // Autotune stuff void FinishUp(); - bool isMax, isMin; - double noiseBand; - bool running; - unsigned long peak1, peak2; - int sampleTime; - int nLookBack; - int peakType; - double lastInputs[101]; + bool isMax, isMin; + double noise_band; + bool autotune_running; + unsigned long peak1, peak2; + int sampleTime; + int nLookBack; + int peakType; + double lastInputs[101]; double peaks[10]; - int peakCount; - bool atune_peak_change; - double absMax, absMin; - double oStep; - double outputStart; - double Ku, Pu; + int peakCount; + bool atune_peak_change; + double absMax, absMin; + double oStep; + double outputStart; + double Ku, Pu; }; #endif