pressureNormalization, injectControl PID

Author: Markus

main/.vscode/c_cpp_properties.json

@@ -15,8 +15,11 @@
             "macFrameworkPath": [
                 "/System/Library/Frameworks",
                 "/Library/Frameworks"
-            ]
+            ],
+            "compilerPath": "/usr/bin/clang",
+            "cStandard": "c11",
+            "cppStandard": "c++17"
         }
     ],
-    "version": 3
+    "version": 4
 }

main/calc.cpp

@@ -18,6 +18,31 @@ int initEVoltage = analogRead(exhaustPresPin) * 5.0;
 
 // Calculation helpers
 
+int pressureNormalization(int givenPressure)
+{
+  struct SensorVals sensor = readSensors();
+  int targetVoltage = 12000;
+  float pressureModifier = targetVoltage / sensor.curBattery;
+  if (sensor.curBattery < targetVoltage)
+  {
+    Serial.println("Battery voltage too low, target pressure cannot be reached.");
+  }
+
+  int normalizedPressure = pressureModifier * givenPressure;
+  if (normalizedPressure > 100)
+  {
+    normalizedPressure = 100;
+    Serial.println("Pressure high compensation reached. Low battery?")
+  }
+  else if (normalizedPressure < 0)
+  {
+    normalizedPressure = 0;
+    Serial.println("Pressure low compensation reached. Too high voltage?")
+  }
+
+  return normalizedPressure;
+}
+
 // Mapping throttle position sensor voltage to percentage
 int readTPSVoltage(int voltage)
 {
@@ -34,14 +59,14 @@ int readTPSVoltage(int voltage)
 // Mapping boost sensor voltage to percentage
 int readBoostVoltage(int voltage)
 {
-  int result = voltage * 700/2.95;
+  int result = voltage * 700 / 2.95;
   //int result = map(voltage, initBVoltage, 3100, 0, 3000); // NXP MPX5700AP (range 0-700kPa)
   return result;
 }
 
 int readExPresVoltage(int voltage)
 {
-  int result = voltage * 700/4.6;
+  int result = voltage * 700 / 4.6;
   //int result = map(voltage, initEVoltage, 5000, 0, 3000); // NXP MPX5700AP (range 0-700kPa)
   return result;
 }
@@ -147,7 +172,6 @@ int readTempMapInverted(const int theMap[14][2], int y)
   return betweenL1;
 }
 
-
 int readPercentualMap(const int theMap[14][12], int x, int y)
 {
 
@@ -289,8 +313,14 @@ int readPercentualMap(const int theMap[14][12], int x, int y)
     }
   }
   calculatedPoint = calculatedPoint * config.transSloppy;
-  if ( calculatedPoint > 100 ) { calculatedPoint = 100; }
-  if ( calculatedPoint < 1 ) { calculatedPoint = 0; }
+  if (calculatedPoint > 100)
+  {
+    calculatedPoint = 100;
+  }
+  if (calculatedPoint < 1)
+  {
+    calculatedPoint = 0;
+  }
   return calculatedPoint;
 }
 

main/core.cpp

@@ -140,8 +140,12 @@ void doShift()
       Serial.println(F("[switchGearStart->switchGearStart] SPC low limit hit."));
     }
   }
-  spcSetVal = (100 - spcPercentVal) * 2.55; // these are calculated twice to make sure if there is changes they are noted.
-  mpcSetVal = (100 - mpcPercentVal) * 2.55;
+  spcPressureNormalized = pressureNormalization(spcPercentVal);
+  mpcPressureNormalized = pressureNormalization(mpcPercentVal);
+  onPressureNormalized = pressureNormalization(100);
+
+  spcSetVal = (100 - spcPressureNormalized) * 2.55; // these are calculated twice to make sure if there is changes they are noted.
+  mpcSetVal = (100 - mpcPressureNormalized) * 2.55;
 
   shiftStartTime = millis(); // Beginning to count shiftStartTime
   // pinmode change is due the fact how n2/n3 speed sensors change during the shift.
@@ -150,7 +154,7 @@ void doShift()
   analogWrite(tcc, 0);
   analogWrite(spc, spcSetVal);
   analogWrite(mpc, mpcSetVal);
-  analogWrite(cSolenoidEnabled, 255); // Beginning of gear change
+  analogWrite(cSolenoidEnabled, onPressureNormalized); // Beginning of gear change
 
   if (debugEnabled)
   {

main/input.cpp

@@ -14,22 +14,27 @@ byte wantedGear = 100;
 
 // INPUT
 
-// Pid tuning parameters
-const double Kp = 7; //80,21 Pid Proporional Gain. Initial ramp up i.e Spool, Lower if over boost
-double Ki = 20;      //40,7 Pid Integral Gain. Overall change while near Target Boost, higher value means less change, possible boost spikes
-const double Kd = 0; //100, 1 Pid Derivative Gain.
+// Pid tuning parameters, for boostCtrl
+const double boostKp = 7; //80,21 Pid Proporional Gain. Initial ramp up i.e Spool, Lower if over boost
+double boostKi = 20;      //40,7 Pid Integral Gain. Overall change while near Target Boost, higher value means less change, possible boost spikes
+const double boostKd = 0; //100, 1 Pid Derivative Gain.
+double pidBoost, boostPWM, pidBoostLim;
+//Load PID controller
+AutoPID boostPID(&pidBoost, &pidBoostLim, &boostPWM, 0, 255, boostKp, boostKi, boostKd);
+
+#ifdef ECU
+// Pid tuning parameters, for injectionCtrl
+const double injectKp = 7; //80,21 Pid Proporional Gain. Initial ramp up, Lower if over
+double injectKi = 20;      //40,7 Pid Integral Gain. Overall change while near Target
+const double injectKd = 0; //100, 1 Pid Derivative Gain.
+double pidInject, injectPWM, pidInjectLim;
+//Load PID controller
+AutoPID injectPID(&pidInject, &pidInjectLim, &injectPWM, 0, 255, injectKp, injectKi, injectKd);
+#endif
+
 boolean garageShift, garageShiftMove, tpsConfigMode, tpsInitPhase1, tpsInitPhase2 = false;
-double garageTime, lastShift, lastInput;
+double garageTime, lastShift, lastInput, hornPressTime;
 int lockVal = 0;
-/*
-const double Kp = 200; 
-double Ki = 100;      
-const double Kd = 25; //This is not necessarily good idea.
-*/
-double pidBoost, boostPWM, pidBoostLim, hornPressTime;
-
-//Load PID controller
-AutoPID myPID(&pidBoost, &pidBoostLim, &boostPWM, 0, 255, Kp, Ki, Kd);
 
 // Polling for stick control
 // This is W202 electronic gear stick, should work on any pre-canbus sticks.
@@ -211,8 +216,8 @@ void boostControl(Task *me)
     struct SensorVals sensor = readSensors();
     pidBoost = sensor.curBoost;
     pidBoostLim = sensor.curBoostLim;
-    myPID.setBangBang(100, 50);
-    myPID.setTimeStep(100);
+    boostPID.setBangBang(100, 50);
+    boostPID.setTimeStep(100);
 
     if (shiftBlocker && !slipFault && boostLimitShift)
     {
@@ -225,18 +230,18 @@ void boostControl(Task *me)
       {
         pidBoostLim = 0;
       }
-      Ki = 5; // New integral gain value; we want change of pressure to be aggressive here.
+      boostKi = 5; // New integral gain value; we want change of pressure to be aggressive here.
     }
     else
     {
       pidBoostLim = sensor.curBoostLim;
-      Ki = 20; // New integral gain value; we want change of pressure to be more modest.
+      boostKi = 20; // New integral gain value; we want change of pressure to be more modest.
     }
 
     // Just a sanity check to make sure PID library is not doing anything stupid.
     if (sensor.curBoostLim > 0 && !slipFault && truePower)
     {
-      myPID.run();
+      boostPID.run();
       analogWrite(boostCtrl, boostPWM);
       //  if (debugEnabled) { Serial.print("BoostPWM = "); Serial.println(boostPWM); }
     }
@@ -555,21 +560,26 @@ int adaptSPC(int mapId, int xVal, int yVal)
 
 void injectionControl(Task *me)
 {
+#ifdef ECU
   struct SensorVals sensor = readSensors();
   int fuelRequire = sensor.curLoad / sensor.curLambda; // eg. 100% load / 100% lambda = 1x fueling, 100% load / 10% lambda = 10x fueling
   int fuelAmount = readMap(injectionMap, fuelRequire, sensor.curRPM);
   fuelAmount = fuelAmount * 2.55;
-  analogWrite(injectionPin, fuelAmount);
-
+  injectPID.setBangBang(100, 50);
+  injectPID.setTimeStep(100);
+  // Read injectionpump travel
+  injectPID.run();
+  analogWrite(injectionPin, injectPWM);
   if (debugEnabled)
   {
     Serial.print("Fueling quantity with load/lambda: ")
-    Serial.print(sensor.curLoad);
+        Serial.print(sensor.curLoad);
     Serial.print("/");
     Serial.print(sensor.curLambda);
     Serial.print(" is ");
     Serial.print(fuelAmount);
   }
+#endif
 }
 
 void radioControl()