noisymime
/
speeduino
mirror of https://github.com/noisymime/speeduino.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

New experimental boost control PID

This commit is contained in:
Josh Stewart 2017-07-29 22:38:54 +10:00
parent b9e6d8973a
commit 8db6ef21f8
4 changed files with 314 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
speeduino/auxiliaries.ino
View File

@ -3,7 +3,8 @@ Speeduino - Simple engine management for the Arduino Mega 2560 platform
Copyright (C) Josh Stewart
A full copy of the license may be found in the projects root directory
*/
integerPID boostPID(&MAPx100, &boost_pwm_target_value, &boostTargetx100, configPage3.boostKP, configPage3.boostKI, configPage3.boostKD, DIRECT); //This is the PID object if that algorithm is used. Needs to be global as it maintains state outside of each function call
//integerPID boostPID(&MAPx100, &boost_pwm_target_value, &boostTargetx100, configPage3.boostKP, configPage3.boostKI, configPage3.boostKD, DIRECT); //This is the PID object if that algorithm is used. Needs to be global as it maintains state outside of each function call
integerPIDnew boostPID(&currentStatus.MAP, &boost_pwm_target_value, &boost_cl_target_boost, configPage3.boostKP, configPage3.boostKI, configPage3.boostKD, DIRECT); //This is the PID object if that algorithm is used. Needs to be global as it maintains state outside of each function call
/*
Fan control
@ -67,7 +68,8 @@ void boostControl()
{
MAPx100 = currentStatus.MAP * 100;
boost_cl_target_boost = get3DTableValue(&boostTable, currentStatus.TPS, currentStatus.RPM) * 2; //Boost target table is in kpa and divided by 2
if( (boostCounter & 3) == 1) { boost_cl_target_boost = get3DTableValue(&boostTable, currentStatus.TPS, currentStatus.RPM) * 2; } //Boost target table is in kpa and divided by 2
//If flex fuel is enabled, there can be an adder to the boost target based on ethanol content
if( configPage1.flexEnabled == 1 )
{

9
speeduino/speeduino.ino
View File

@ -944,7 +944,8 @@ void loop()
if ( (timeToLastTooth < MAX_STALL_TIME) || (toothLastToothTime > currentLoopTime) ) //Check how long ago the last tooth was seen compared to now. If it was more than half a second ago then the engine is probably stopped. toothLastToothTime can be greater than currentLoopTime if a pulse occurs between getting the lastest time and doing the comparison
{
currentStatus.RPM = currentStatus.longRPM = getRPM(); //Long RPM is included here
if(fuelPumpOn == false) { digitalWrite(pinFuelPump, HIGH); fuelPumpOn = true; } //Check if the fuel pump is on and turn it on if it isn't.
//if(fuelPumpOn == false) { digitalWrite(pinFuelPump, HIGH); fuelPumpOn = true; } //Check if the fuel pump is on and turn it on if it isn't.
FUEL_PUMP_ON();
}
else
{
@ -1024,10 +1025,13 @@ void loop()
//And check whether the tooth log buffer is ready
if(toothHistoryIndex > TOOTH_LOG_SIZE) { BIT_SET(currentStatus.squirt, BIT_SQUIRT_TOOTHLOG1READY); }
//Most boost tends to run at about 30Hz, so placing it here ensures a new target time is fetched frequently enough
boostControl();
}
if( (mainLoopCount & 63) == 1) //Every 64 loops
{
boostControl(); //Most boost tends to run at about 30Hz, so placing it here ensures a new target time is fetched frequently enough
//Nothing here currently
}
//The IAT and CLT readings can be done less frequently. This still runs about 4 times per second
if ((mainLoopCount & 255) == 1) //Every 256 loops
@ -1104,6 +1108,7 @@ void loop()
if (currentStatus.hasSync && (currentStatus.RPM > 0))
{
if(currentStatus.startRevolutions >= configPage2.StgCycles) { ignitionOn = true; fuelOn = true;} //Enable the fuel and ignition, assuming staging revolutions are complete
else { ignitionOn = false; fuelOn = false;}
//If it is, check is we're running or cranking
if(currentStatus.RPM > ((unsigned int)configPage2.crankRPM * 100)) //Crank RPM stored in byte as RPM / 100
{

197
speeduino/src/PID_v1/PID_v1.cpp
View File

@ -302,9 +302,9 @@ void integerPID::SetSampleTime(int NewSampleTime)
if (NewSampleTime > 0)
{
unsigned long ratioX1000 = (unsigned long)(NewSampleTime * 1000) / (unsigned long)SampleTime;
ki = (ki * ratioX1000) / 1000;
ki = ((unsigned long)ki * ratioX1000) / 1000;
//kd /= ratio;
kd = (kd * 1000) / ratioX1000;
kd = ((unsigned long)kd * 1000) / ratioX1000;
SampleTime = (unsigned long)NewSampleTime;
}
}
@ -387,3 +387,196 @@ byte integerPID::GetKi(){ return dispKi;}
byte integerPID::GetKd(){ return dispKd;}
int integerPID::GetMode(){ return inAuto ? AUTOMATIC : MANUAL;}
int integerPID::GetDirection(){ return controllerDirection;}
//************************************************************************************************************************
#define PID_P_FACTOR 128
#define PID_I_FACTOR 1024
#define PID_D_FACTOR 128
/*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.
***************************************************************************/
integerPIDnew::integerPIDnew(long* Input, long* Output, long* Setpoint,
byte Kp, byte Ki, byte Kd, byte ControllerDirection)
{
myOutput = Output;
myInput = (long*)Input;
mySetpoint = Setpoint;
inAuto = false;
integerPIDnew::SetOutputLimits(0, 255); //default output limit corresponds to
//the arduino pwm limits
SampleTime = 50; //default Controller Sample Time is 0.05 seconds
integerPIDnew::SetControllerDirection(ControllerDirection);
integerPIDnew::SetTunings(Kp, Ki, Kd);
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 integerPIDnew::Compute()
{
if(!inAuto) return false;
unsigned long now = millis();
//SampleTime = (now - lastTime);
unsigned long timeChange = (now - lastTime);
if(timeChange >= SampleTime)
{
/*Compute all the working error variables*/
long input = *myInput;
long error = (*mySetpoint - input) * 100; //Error is multiplied by 100 in order to allow use of 0-100% rather than 0-1
ITerm += (ki * error)/PID_I_FACTOR; //Note that ki is multiplied by 1024 to avoid floats. It is divided back here AFTER being multiplied by error
if(ITerm > outMax) { ITerm = outMax; }
else if(ITerm < outMin) { ITerm = outMin; }
long dInput = (input - lastInput);
/*Compute PID Output*/
long output = (kp * error)/100 + ITerm - (kd * dInput)/100; //100 is used to allow 0-100% rather than 0-1
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;
}
/* 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 integerPIDnew::SetTunings(byte Kp, byte Ki, byte Kd)
{
if (Kp<0 || Ki<0 || Kd<0) return;
if ( dispKp == Kp && dispKi == Ki && dispKd == Kd ) return; //Only do anything if one of the values has changed
dispKp = Kp; dispKi = Ki; dispKd = Kd;
/*
double SampleTimeInSec = ((double)SampleTime)/1000;
kp = Kp;
ki = Ki * SampleTimeInSec;
kd = Kd / SampleTimeInSec;
*/
long InverseSampleTimeInSec = 1000 / SampleTime;
kp = Kp;
ki = (long)((long)Ki * PID_I_FACTOR) / InverseSampleTimeInSec;
kd = (long)Kd * InverseSampleTimeInSec;
if(controllerDirection == REVERSE)
{
kp = (0 - kp);
ki = (0 - ki);
kd = (0 - kd);
}
}
/* SetSampleTime(...) *********************************************************
* sets the period, in Milliseconds, at which the calculation is performed
******************************************************************************/
void integerPIDnew::SetSampleTime(int 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;
}
}
/* 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 integerPIDnew::SetOutputLimits(long Min, long 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;
}
}
/* 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 integerPIDnew::SetMode(int Mode)
{
bool newAuto = (Mode == AUTOMATIC);
if(newAuto == !inAuto)
{ /*we just went from manual to auto*/
integerPIDnew::Initialize();
}
inAuto = newAuto;
}
/* Initialize()****************************************************************
* does all the things that need to happen to ensure a bumpless transfer
* from manual to automatic mode.
******************************************************************************/
void integerPIDnew::Initialize()
{
ITerm = *myOutput;
lastInput = *myInput;
if(ITerm > outMax) ITerm = outMax;
else if(ITerm < outMin) ITerm = 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 integerPIDnew::SetControllerDirection(byte 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
******************************************************************************/
byte integerPIDnew::GetKp(){ return dispKp; }
byte integerPIDnew::GetKi(){ return dispKi;}
byte integerPIDnew::GetKd(){ return dispKd;}
int integerPIDnew::GetMode(){ return inAuto ? AUTOMATIC : MANUAL;}
int integerPIDnew::GetDirection(){ return controllerDirection;}

142
speeduino/src/PID_v1/PID_v1.h
View File

@ -15,9 +15,9 @@ class PID
#define REVERSE 1
//commonly used functions **************************************************************************
PID(long*, long*, long*, // * constructor. links the PID to the Input, Output, and
PID(long*, long*, long*, // * constructor. links the PID to the Input, Output, and
byte, byte, byte, byte); // 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,47 +28,47 @@ class PID
void SetOutputLimits(long, long); //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(byte, byte, // * While most users will set the tunings once in the
void SetTunings(byte, byte, // * While most users will set the tunings once in the
byte); // constructor, this function gives the user the option
// of changing tunings during runtime for Adaptive control
void SetControllerDirection(byte); // * 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 ****************************************************************
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
byte GetKd(); // where it's important to know what is actually
int GetMode(); // inside the PID.
int GetDirection(); //
private:
void Initialize();
byte dispKp; // * we'll hold on to the tuning parameters in user-entered
byte dispKp; // * we'll hold on to the tuning parameters in user-entered
byte dispKi; // format for display purposes
byte dispKd; //
byte kp; // * (P)roportional Tuning Parameter
byte ki; // * (I)ntegral Tuning Parameter
byte kd; // * (D)erivative Tuning Parameter
byte ki; // * (I)ntegral Tuning Parameter
byte kd; // * (D)erivative Tuning Parameter
int controllerDirection;
long *myInput; // * Pointers to the Input, Output, and Setpoint variables
long *myOutput; // This creates a hard link between the variables and the
long *myOutput; // This creates a hard link between the variables and the
long *mySetpoint; // PID, freeing the user from having to constantly tell us
// what these values are. with pointers we'll just know.
unsigned long lastTime;
long ITerm, lastInput;
@ -90,9 +90,9 @@ class integerPID
#define REVERSE 1
//commonly used functions **************************************************************************
integerPID(long*, long*, long*, // * constructor. links the PID to the Input, Output, and
integerPID(long*, long*, long*, // * constructor. links the PID to the Input, Output, and
byte, byte, byte, byte); // 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
@ -103,47 +103,122 @@ class integerPID
void SetOutputLimits(long, long); //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(byte, byte, // * While most users will set the tunings once in the
void SetTunings(byte, byte, // * While most users will set the tunings once in the
byte); // constructor, this function gives the user the option
// of changing tunings during runtime for Adaptive control
void SetControllerDirection(byte); // * 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 ****************************************************************
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
byte GetKd(); // where it's important to know what is actually
int GetMode(); // inside the PID.
int GetDirection(); //
private:
void Initialize();
byte dispKp; // * we'll hold on to the tuning parameters in user-entered
byte dispKp; // * we'll hold on to the tuning parameters in user-entered
byte dispKi; // format for display purposes
byte dispKd; //
int kp; // * (P)roportional Tuning Parameter
int ki; // * (I)ntegral Tuning Parameter
int kd; // * (D)erivative Tuning Parameter
uint16_t kp; // * (P)roportional Tuning Parameter
uint16_t ki; // * (I)ntegral Tuning Parameter
uint16_t kd; // * (D)erivative Tuning Parameter
int controllerDirection;
long *myInput; // * Pointers to the Input, Output, and Setpoint variables
long *myOutput; // This creates a hard link between the variables and the
long *myOutput; // This creates a hard link between the variables and the
long *mySetpoint; // PID, freeing the user from having to constantly tell us
// what these values are. with pointers we'll just know.
unsigned long lastTime;
long ITerm, lastInput;
unsigned long SampleTime;
long outMin, outMax;
bool inAuto;
};
class integerPIDnew
{
public:
//Constants used in some of the functions below
#define AUTOMATIC 1
#define MANUAL 0
#define DIRECT 0
#define REVERSE 1
//commonly used functions **************************************************************************
integerPIDnew(long*, long*, long*, // * constructor. links the PID to the Input, Output, and
byte, byte, byte, byte); // 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
// called every time loop() cycles. ON/OFF and
// calculation frequency can be set using SetMode
// SetSampleTime respectively
void SetOutputLimits(long, long); //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(byte, byte, // * While most users will set the tunings once in the
byte); // constructor, this function gives the user the option
// of changing tunings during runtime for Adaptive control
void SetControllerDirection(byte); // * 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
// 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(); //
private:
void Initialize();
byte dispKp; // * we'll hold on to the tuning parameters in user-entered
byte dispKi; // format for display purposes
byte dispKd; //
uint16_t kp; // * (P)roportional Tuning Parameter
uint16_t ki; // * (I)ntegral Tuning Parameter
uint16_t kd; // * (D)erivative Tuning Parameter
int controllerDirection;
long *myInput; // * Pointers to the Input, Output, and Setpoint variables
long *myOutput; // This creates a hard link between the variables and the
long *mySetpoint; // PID, freeing the user from having to constantly tell us
// what these values are. with pointers we'll just know.
unsigned long lastTime;
long ITerm, lastInput;
@ -152,4 +227,3 @@ class integerPID
bool inAuto;
};
#endif