PID updates to allow clean compile
This commit is contained in:
parent
db09629eec
commit
64d0196787
|
@ -54,7 +54,7 @@ bool PID::Compute()
|
|||
/*Compute all the working error variables*/
|
||||
long input = *myInput;
|
||||
long error = *mySetpoint - input;
|
||||
ITerm+= (ki * error)/100;
|
||||
ITerm += (ki * error)/100;
|
||||
if(ITerm > outMax) ITerm= outMax;
|
||||
else if(ITerm < outMin) ITerm= outMin;
|
||||
long dInput = (input - lastInput);
|
||||
|
@ -201,19 +201,27 @@ int PID::GetDirection(){ return controllerDirection;}
|
|||
* 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.
|
||||
***************************************************************************/
|
||||
/**
|
||||
* @brief A standard integer PID controller.
|
||||
*
|
||||
* @param Input Pointer to the variable holding the current value that is to be controlled. Eg In an idle control this would point to RPM
|
||||
* @param Output The address in the page that should be returned. This is as per the page definition in the ini
|
||||
*
|
||||
* @return byte The current target advance value in degrees
|
||||
*/
|
||||
integerPID::integerPID(long* Input, long* Output, long* Setpoint,
|
||||
byte Kp, byte Ki, byte Kd, byte ControllerDirection)
|
||||
{
|
||||
|
||||
myOutput = Output;
|
||||
myInput = (long*)Input;
|
||||
myInput = Input;
|
||||
mySetpoint = Setpoint;
|
||||
inAuto = false;
|
||||
|
||||
integerPID::SetOutputLimits(0, 255); //default output limit corresponds to
|
||||
//the arduino pwm limits
|
||||
|
||||
SampleTime = 100; //default Controller Sample Time is 0.1 seconds
|
||||
SampleTime = 250; //default Controller Sample Time is 0.25 seconds. This is the 4Hz control time for Idle and VVT
|
||||
|
||||
integerPID::SetControllerDirection(ControllerDirection);
|
||||
integerPID::SetTunings(Kp, Ki, Kd);
|
||||
|
@ -228,7 +236,7 @@ integerPID::integerPID(long* Input, long* Output, long* Setpoint,
|
|||
* pid Output needs to be computed. returns true when the output is computed,
|
||||
* false when nothing has been done.
|
||||
**********************************************************************************/
|
||||
bool integerPID::Compute()
|
||||
bool integerPID::Compute(bool pOnE)
|
||||
{
|
||||
if(!inAuto) return false;
|
||||
unsigned long now = millis();
|
||||
|
@ -239,13 +247,42 @@ bool integerPID::Compute()
|
|||
/*Compute all the working error variables*/
|
||||
long input = *myInput;
|
||||
long error = *mySetpoint - input;
|
||||
ITerm += (ki * error)/1000; //Note that ki is multiplied by 1000 rather than 100, so it must be divided by 1000 here
|
||||
if(ITerm > outMax) { ITerm = outMax; }
|
||||
else if(ITerm < outMin) { ITerm = outMin; }
|
||||
long dInput = (input - lastInput);
|
||||
|
||||
outputSum += (ki * error)/1024; //Note that ki is multiplied by 1024 so it must be divided by 1024 here
|
||||
if(outputSum > outMax) { outputSum = outMax; }
|
||||
else if(outputSum < outMin) { outputSum = outMin; }
|
||||
|
||||
/*Compute PID Output*/
|
||||
long output = (kp * error)/100 + ITerm - (kd * dInput)/100;
|
||||
long output;
|
||||
|
||||
if(pOnE)
|
||||
{
|
||||
output = (kp * error) + outputSum - ((kd * dInput)/128);
|
||||
}
|
||||
else
|
||||
{
|
||||
outputSum -= kp * dInput;
|
||||
if(outputSum > outMax) { outputSum = outMax; }
|
||||
else if(outputSum < outMin) { outputSum = outMin; }
|
||||
|
||||
output = outputSum - ((kd * dInput)/128);
|
||||
}
|
||||
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
if(output > outMax) output = outMax;
|
||||
else if(output < outMin) output = outMin;
|
||||
|
@ -277,10 +314,10 @@ void integerPID::SetTunings(byte Kp, byte Ki, byte Kd)
|
|||
ki = Ki * SampleTimeInSec;
|
||||
kd = Kd / SampleTimeInSec;
|
||||
*/
|
||||
long InverseSampleTimeInSec = 100000 / SampleTime;
|
||||
long InverseSampleTimeInSec = 1000 / SampleTime;
|
||||
kp = Kp;
|
||||
ki = (long)((long)Ki * 1000) / InverseSampleTimeInSec;
|
||||
kd = ((long)Kd * InverseSampleTimeInSec) / 100;
|
||||
ki = (long)((long)Ki * 1024) / InverseSampleTimeInSec;
|
||||
kd = ((long)Kd * InverseSampleTimeInSec);
|
||||
|
||||
if(controllerDirection == REVERSE)
|
||||
{
|
||||
|
@ -293,17 +330,15 @@ void integerPID::SetTunings(byte Kp, byte Ki, byte Kd)
|
|||
/* SetSampleTime(...) *********************************************************
|
||||
* sets the period, in Milliseconds, at which the calculation is performed
|
||||
******************************************************************************/
|
||||
void integerPID::SetSampleTime(int NewSampleTime)
|
||||
void integerPID::SetSampleTime(uint16_t NewSampleTime)
|
||||
{
|
||||
if (SampleTime == (unsigned long)NewSampleTime) return; //If new value = old value, no action required.
|
||||
if (NewSampleTime > 0)
|
||||
{
|
||||
unsigned long ratioX1000 = (unsigned long)(NewSampleTime * 1000) / (unsigned long)SampleTime;
|
||||
ki = ((unsigned long)ki * ratioX1000) / 1000;
|
||||
//kd /= ratio;
|
||||
kd = ((unsigned long)kd * 1000) / ratioX1000;
|
||||
SampleTime = (unsigned long)NewSampleTime;
|
||||
}
|
||||
SampleTime = NewSampleTime;
|
||||
|
||||
//This resets the tuning values with the appropriate new scaling
|
||||
//The +1/-1 is there just so that this doesn't trip the check at the beginning of the SetTunings() function
|
||||
SetTunings(dispKp+1, dispKi+1, dispKd+1);
|
||||
SetTunings(dispKp-1, dispKi-1, dispKd-1);
|
||||
}
|
||||
|
||||
/* SetOutputLimits(...)****************************************************
|
||||
|
@ -325,8 +360,8 @@ void integerPID::SetOutputLimits(long Min, long Max)
|
|||
if(*myOutput > outMax) *myOutput = outMax;
|
||||
else if(*myOutput < outMin) *myOutput = outMin;
|
||||
|
||||
if(ITerm > outMax) ITerm= outMax;
|
||||
else if(ITerm < outMin) ITerm= outMin;
|
||||
if(outputSum > outMax) { outputSum = outMax; }
|
||||
else if(outputSum < outMin) { outputSum = outMin; }
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -351,10 +386,11 @@ void integerPID::SetMode(int Mode)
|
|||
******************************************************************************/
|
||||
void integerPID::Initialize()
|
||||
{
|
||||
ITerm = *myOutput;
|
||||
outputSum = *myOutput;
|
||||
lastInput = *myInput;
|
||||
if(ITerm > outMax) ITerm = outMax;
|
||||
else if(ITerm < outMin) ITerm = outMin;
|
||||
lastMinusOneInput = *myInput;
|
||||
if(outputSum > outMax) { outputSum = outMax; }
|
||||
else if(outputSum < outMin) { outputSum = outMin; }
|
||||
}
|
||||
|
||||
/* SetControllerDirection(...)*************************************************
|
||||
|
@ -379,9 +415,6 @@ void integerPID::SetControllerDirection(byte Direction)
|
|||
* 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
|
||||
******************************************************************************/
|
||||
byte integerPID::GetKp(){ return dispKp; }
|
||||
byte integerPID::GetKi(){ return dispKi;}
|
||||
byte integerPID::GetKd(){ return dispKd;}
|
||||
int integerPID::GetMode(){ return inAuto ? AUTOMATIC : MANUAL;}
|
||||
int integerPID::GetDirection(){ return controllerDirection;}
|
||||
|
||||
|
@ -541,7 +574,4 @@ void integerPID_ideal::SetControllerDirection(byte Direction)
|
|||
* 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
|
||||
******************************************************************************/
|
||||
byte integerPID_ideal::GetKp(){ return dispKp; }
|
||||
byte integerPID_ideal::GetKi(){ return dispKi;}
|
||||
byte integerPID_ideal::GetKd(){ return dispKd;}
|
||||
int integerPID_ideal::GetDirection(){ return controllerDirection;}
|
||||
|
|
|
@ -95,7 +95,7 @@ class integerPID
|
|||
|
||||
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(bool pOnE); // * performs the PID calculation. it should be
|
||||
// called every time loop() cycles. ON/OFF and
|
||||
// calculation frequency can be set using SetMode
|
||||
// SetSampleTime respectively
|
||||
|
@ -114,25 +114,22 @@ class integerPID
|
|||
// 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(uint16_t); // * sets the frequency, in Milliseconds, with which
|
||||
// the PID calculation is performed. default is 100
|
||||
|
||||
|
||||
|
||||
//Display functions ****************************************************************
|
||||
byte GetKp(); // These functions query the pid for interal values.
|
||||
byte GetKi(); // they were created mainly for the pid front-end,
|
||||
byte GetKd(); // where it's important to know what is actually
|
||||
int GetMode(); // inside the PID.
|
||||
int GetDirection(); //
|
||||
void Initialize();
|
||||
|
||||
private:
|
||||
void Initialize();
|
||||
|
||||
byte dispKp; // * we'll hold on to the tuning parameters in user-entered
|
||||
byte dispKi; // format for display purposes
|
||||
byte dispKd; //
|
||||
|
||||
byte dispKp;
|
||||
byte dispKi;
|
||||
byte dispKd;
|
||||
uint16_t kp; // * (P)roportional Tuning Parameter
|
||||
uint16_t ki; // * (I)ntegral Tuning Parameter
|
||||
uint16_t kd; // * (D)erivative Tuning Parameter
|
||||
|
@ -145,9 +142,10 @@ class integerPID
|
|||
// what these values are. with pointers we'll just know.
|
||||
|
||||
unsigned long lastTime;
|
||||
long ITerm, lastInput;
|
||||
long outputSum, lastInput, lastMinusOneInput;
|
||||
int16_t lastError;
|
||||
|
||||
unsigned long SampleTime;
|
||||
uint16_t SampleTime;
|
||||
long outMin, outMax;
|
||||
bool inAuto;
|
||||
};
|
||||
|
@ -191,9 +189,6 @@ class integerPID_ideal
|
|||
|
||||
|
||||
//Display functions ****************************************************************
|
||||
byte GetKp(); // These functions query the pid for interal values.
|
||||
byte GetKi(); // they were created mainly for the pid front-end,
|
||||
byte GetKd(); // where it's important to know what is actually
|
||||
int GetMode(); // inside the PID.
|
||||
int GetDirection(); //
|
||||
void Initialize();
|
||||
|
|
Loading…
Reference in New Issue