Bug fixes for getAdvance1, getAdvance2 & secondary tables. (#1155)
* Unit testability: split out definition of statuses struct. * Separate out getLoad() function * Bug Fix: getAdvance1() & getAdvance2() should return a signed value. * secondarytables.cpp - extract duplicate code into functions. * Bug fix: BIT_STATUS3_FUEL2_ACTIVE not set in 2 cases. * Performance: secondaryTables call percentage() (which is optimised) * Add secondary table tests * Bug Fix: do not correct secondary spark multiplier * Unit test no secondary spark with fixed timing. * MISRA fixes * Save memory: remove statuses::ignLoad2 & fuelLoad2 (unused) * Unit testability: split out definition of config page structs. * Make 3D table interpolation a const operation. * Unit testability: inject the tune & status. * Make the advance2 gauge work correctly in multiply mode * Secondary table tests - no global state * Secondary table tests: add additional spark multiply tests to cover #1274 --------- Co-authored-by: Josh Stewart <josh@noisymime.org>
This commit is contained in:
tx_haggis
GitHub
parent
784c2ed0bc
commit
fbd1e4fa4f
|
|
@ -98,10 +98,12 @@
|
|||
|
||||
#define loadSourceNames = "MAP", "TPS", "IMAP/EMAP", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID"
|
||||
#define loadSourceUnits = "kPa", "% TPS", "%", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID"
|
||||
|
||||
algorithmNames = bits, U08, [0:2], $loadSourceNames
|
||||
algorithmUnits = bits, U08, [0:2], "kPa", "% TPS", "%", "% TPS", "INVALID", "INVALID", "INVALID", "INVALID"
|
||||
algorithmLimits = array, U16, [8], "", 1.0, 0, 0, 511, 0, noMsqSave
|
||||
fuel2SwitchUnits = bits, U08, [0:2], "rpm", "kPa", "% TPS", "%", "% TPS", "INVALID", "INVALID", "INVALID"
|
||||
spark2ModeUnits = bits, U08, [0:2], "", "%", "deg", "deg", "deg","INVALID","INVALID","INVALID"
|
||||
|
||||
;All definitions of split fullStatus should keep 32 options
|
||||
#define fullStatus_def_1= "seconds", "status bits", "Engine status", "syncLossCounter", "MAP (Kpa)", "INVALID", "IAT / MAT", "coolant", "batCorrection", "battery voltage x10", "O2", "egoCorrection", "iatCorrection", "wueCorrection", "RPM", "INVALID", "AEamount/2", "GammaE", "INVALID", "VE1", "VE2", "AFR Target", "TPS DOT", "INVALID", "Advance", "TPS", "loopsPerSecond", "INVALID", "free RAM", "INVALID", "boostTarget/2", "Boost duty"
|
||||
|
|
@ -5160,9 +5162,9 @@ cmdVSSratio6 = "E\x99\x06"
|
|||
baroCorrectGauge = baroCorrection,"Baro Correction", "%", 0, 200, 130, 140, 140, 150, 0, 0
|
||||
flexEnrich = flexFuelCor, "Flex Correction", "%", 0, 200, 130, 140, 140, 150, 0, 0
|
||||
fuelTempCorGauge = fuelTempCor, "Fuel Temp Correction", "%", 0, 200, 130, 140, 140, 150, 0, 0
|
||||
advanceGauge = advance, "Advance (Current)", "deg", 50, -10, 0, 0, 35, 45, 0, 0
|
||||
advance1Gauge = advance1, "Advance1 (Spark Table 1)", "deg",50, -10, 0, 0, 35, 45, 0, 0
|
||||
advance2Gauge = advance2, "Advance2 (Spark Table 2)", "deg",50, -10, 0, 0, 35, 45, 0, 0
|
||||
advanceGauge = advance, "Advance (Current)", "deg", -10, 50, 0, 0, 35, 45, 0, 0
|
||||
advance1Gauge = advance1, "Advance1 (Spark Table 1)", "deg",-10, 50, 0, 0, 35, 45, 0, 0
|
||||
advance2Gauge = advance2ForGauge, "Advance2 (Spark Table 2)", { bitStringValue( spark2ModeUnits, spark2Mode ) }, { ign2ValuesMin }, { ign2ValuesMax }, { ign2ValueLoD }, { ign2ValueLoW }, { ign2ValueHiW }, { ign2ValueHiD }, 0, 0
|
||||
dwellGauge = dwell, "Dwell (Requested)", "mSec", 0, 35.0, 1.0, 1.2, 20, 25, 3, 3
|
||||
dwellActualGauge = dwellActual, "Dwell (Measured)", "mSec", 0, 35.0, 1.0, 1.2, 20, 25, 3, 3
|
||||
boostTargetGauge = boostTarget, "Target Boost", "kPa", 0, {maphigh}, 0, 20, {mapwarn}, {mapdang}, 0, 0
|
||||
|
|
@ -5566,6 +5568,12 @@ cmdVSSratio6 = "E\x99\x06"
|
|||
ign2LoadMax = { (spark2Algorithm == 0 || spark2Algorithm == 2) ? 511 : 100.0 }
|
||||
ign2ValuesMin = { (spark2Mode == 1) ? 0 : -40 }
|
||||
ign2ValuesMax = { (spark2Mode == 1) ? 215 : 70 }
|
||||
; We have to pass a U08 through a S08 in multiply mode
|
||||
advance2ForGauge = { (spark2Mode == 1) ? advance2+127 : advance2 }
|
||||
ign2ValueLoD = { (spark2Mode == 1) ? ign2ValuesMin : (ign2ValuesMin/10)*9 }
|
||||
ign2ValueHiD = { (spark2Mode == 1) ? ign2ValuesMax : (ign2ValuesMax/10)*9 }
|
||||
ign2ValueLoW = { (spark2Mode == 1) ? ign2ValuesMin : (ign2ValuesMin/10)*8 }
|
||||
ign2ValueHiW = { (spark2Mode == 1) ? ign2ValuesMax : (ign2ValuesMax/10)*8 }
|
||||
|
||||
fuelLoad2 = { fuel2Algorithm == 0 ? map : fuel2Algorithm == 1 ? tps : fuel2Algorithm == 2 ? 0 : 0 }
|
||||
ignLoad2 = { spark2Algorithm == 0 ? map : spark2Algorithm == 1 ? tps : spark2Algorithm == 2 ? 0 : ignLoad }
|
||||
|
|
|
|||
|
|
@ -0,0 +1,21 @@
|
|||
#pragma once
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Bit twiddling macros
|
||||
*/
|
||||
|
||||
/** @brief Set bit b (0-7) in byte a */
|
||||
#define BIT_SET(var,pos) ((var) |= (1U<<(pos)))
|
||||
|
||||
/** @brief Clear bit b (0-7) in byte a */
|
||||
#define BIT_CLEAR(var,pos) ((var) &= ~(1U<<(pos)))
|
||||
|
||||
/** @brief Is bit pos (0-7) in byte var set? */
|
||||
#define BIT_CHECK(var,pos) !!((var) & (1U<<(pos)))
|
||||
|
||||
/** @brief Toggle the value of bit pos (0-7) in byte var */
|
||||
#define BIT_TOGGLE(var,pos) ((var)^= 1UL << (pos))
|
||||
|
||||
/** @brief Set the value ([0,1], [true, false]) of bit pos (0-7) in byte var */
|
||||
#define BIT_WRITE(var, pos, bitvalue) ((bitvalue) ? BIT_SET((var), (pos)) : BIT_CLEAR((var), (pos)))
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -3,10 +3,6 @@
|
|||
*/
|
||||
#include "globals.h"
|
||||
|
||||
const char TSfirmwareVersion[] PROGMEM = "Speeduino";
|
||||
|
||||
const byte data_structure_version = 2; //This identifies the data structure when reading / writing. (outdated ?)
|
||||
|
||||
struct table3d16RpmLoad fuelTable; ///< 16x16 fuel map
|
||||
struct table3d16RpmLoad fuelTable2; ///< 16x16 fuel map
|
||||
struct table3d16RpmLoad ignitionTable; ///< 16x16 ignition map
|
||||
|
|
@ -310,6 +306,8 @@ bool pinIsOutput(byte pin)
|
|||
return used;
|
||||
}
|
||||
|
||||
#define pinIsSensor(pin) ( ((pin) == pinCLT) || ((pin) == pinIAT) || ((pin) == pinMAP) || ((pin) == pinTPS) || ((pin) == pinO2) || ((pin) == pinBat) || (((pin) == pinFlex) && (configPage2.flexEnabled != 0)) )
|
||||
|
||||
bool pinIsUsed(byte pin)
|
||||
{
|
||||
bool used = false;
|
||||
|
|
|
|||
1145
speeduino/globals.h
1145
speeduino/globals.h
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,42 @@
|
|||
#pragma once
|
||||
|
||||
#include "statuses.h"
|
||||
|
||||
/** \enum LoadSource
|
||||
* @brief The load source for various tables
|
||||
* */
|
||||
enum LoadSource {
|
||||
/** Manifold Absolute Pressure (MAP). Aka Intake MAP (IMAP).
|
||||
* I.e. a pressure sensor that reads the pressure (positive or negative)
|
||||
* in the intake manifold */
|
||||
LOAD_SOURCE_MAP,
|
||||
/** Throttle Position Sensor (TPS)*/
|
||||
LOAD_SOURCE_TPS,
|
||||
/** Ratio of intake pressure to exhaust pressure.
|
||||
* A variation of the standard MAP that uses the ratio of inlet manifold pressure to exhaust manifold pressure,
|
||||
* something that is particularly useful on turbo engines. */
|
||||
LOAD_SOURCE_IMAPEMAP
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Get the load value, based the supplied algorithm
|
||||
*
|
||||
* @param algorithm The load algorithm
|
||||
* @param current The current system state, from which the load is computed.
|
||||
* @return The load.
|
||||
*/
|
||||
static inline int16_t getLoad(LoadSource algorithm, const statuses ¤t) {
|
||||
if (algorithm == LOAD_SOURCE_TPS)
|
||||
{
|
||||
//Alpha-N
|
||||
return current.TPS * 2U;
|
||||
}
|
||||
else if (algorithm == LOAD_SOURCE_IMAPEMAP)
|
||||
{
|
||||
//IMAP / EMAP
|
||||
return ((int16_t)current.MAP * 100) / current.EMAP;
|
||||
} else {
|
||||
// LOAD_SOURCE_MAP (the default). Aka Speed Density
|
||||
return current.MAP;
|
||||
}
|
||||
}
|
||||
|
|
@ -2,6 +2,7 @@
|
|||
#include "page_crc.h"
|
||||
#include "pages.h"
|
||||
#include "table3d_axis_io.h"
|
||||
#include "src/FastCRC/FastCRC.h"
|
||||
|
||||
using pCrcCalc = uint32_t (FastCRC32::*)(const uint8_t *, const uint16_t, bool);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,163 +1,8 @@
|
|||
#include "globals.h"
|
||||
#include "secondaryTables.h"
|
||||
#include "corrections.h"
|
||||
|
||||
void calculateSecondaryFuel(void)
|
||||
{
|
||||
//If the secondary fuel table is in use, also get the VE value from there
|
||||
BIT_CLEAR(currentStatus.status3, BIT_STATUS3_FUEL2_ACTIVE); //Clear the bit indicating that the 2nd fuel table is in use.
|
||||
if(configPage10.fuel2Mode > 0)
|
||||
{
|
||||
if(configPage10.fuel2Mode == FUEL2_MODE_MULTIPLY)
|
||||
{
|
||||
currentStatus.VE2 = getVE2();
|
||||
//Fuel 2 table is treated as a % value. Table 1 and 2 are multiplied together and divided by 100
|
||||
uint16_t combinedVE = ((uint16_t)currentStatus.VE1 * (uint16_t)currentStatus.VE2) / 100;
|
||||
if(combinedVE <= UINT8_MAX) { currentStatus.VE = combinedVE; }
|
||||
else { currentStatus.VE = UINT8_MAX; }
|
||||
}
|
||||
else if(configPage10.fuel2Mode == FUEL2_MODE_ADD)
|
||||
{
|
||||
currentStatus.VE2 = getVE2();
|
||||
//Fuel tables are added together, but a check is made to make sure this won't overflow the 8-bit VE value
|
||||
uint16_t combinedVE = (uint16_t)currentStatus.VE1 + (uint16_t)currentStatus.VE2;
|
||||
if(combinedVE <= UINT8_MAX) { currentStatus.VE = combinedVE; }
|
||||
else { currentStatus.VE = UINT8_MAX; }
|
||||
}
|
||||
else if(configPage10.fuel2Mode == FUEL2_MODE_CONDITIONAL_SWITCH )
|
||||
{
|
||||
if(configPage10.fuel2SwitchVariable == FUEL2_CONDITION_RPM)
|
||||
{
|
||||
if(currentStatus.RPM > configPage10.fuel2SwitchValue)
|
||||
{
|
||||
BIT_SET(currentStatus.status3, BIT_STATUS3_FUEL2_ACTIVE); //Set the bit indicating that the 2nd fuel table is in use.
|
||||
currentStatus.VE2 = getVE2();
|
||||
currentStatus.VE = currentStatus.VE2;
|
||||
}
|
||||
}
|
||||
else if(configPage10.fuel2SwitchVariable == FUEL2_CONDITION_MAP)
|
||||
{
|
||||
if(currentStatus.MAP > configPage10.fuel2SwitchValue)
|
||||
{
|
||||
BIT_SET(currentStatus.status3, BIT_STATUS3_FUEL2_ACTIVE); //Set the bit indicating that the 2nd fuel table is in use.
|
||||
currentStatus.VE2 = getVE2();
|
||||
currentStatus.VE = currentStatus.VE2;
|
||||
}
|
||||
}
|
||||
else if(configPage10.fuel2SwitchVariable == FUEL2_CONDITION_TPS)
|
||||
{
|
||||
if(currentStatus.TPS > configPage10.fuel2SwitchValue)
|
||||
{
|
||||
BIT_SET(currentStatus.status3, BIT_STATUS3_FUEL2_ACTIVE); //Set the bit indicating that the 2nd fuel table is in use.
|
||||
currentStatus.VE2 = getVE2();
|
||||
currentStatus.VE = currentStatus.VE2;
|
||||
}
|
||||
}
|
||||
else if(configPage10.fuel2SwitchVariable == FUEL2_CONDITION_ETH)
|
||||
{
|
||||
if(currentStatus.ethanolPct > configPage10.fuel2SwitchValue)
|
||||
{
|
||||
BIT_SET(currentStatus.status3, BIT_STATUS3_FUEL2_ACTIVE); //Set the bit indicating that the 2nd fuel table is in use.
|
||||
currentStatus.VE2 = getVE2();
|
||||
currentStatus.VE = currentStatus.VE2;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(configPage10.fuel2Mode == FUEL2_MODE_INPUT_SWITCH)
|
||||
{
|
||||
if(digitalRead(pinFuel2Input) == configPage10.fuel2InputPolarity)
|
||||
{
|
||||
BIT_SET(currentStatus.status3, BIT_STATUS3_FUEL2_ACTIVE); //Set the bit indicating that the 2nd fuel table is in use.
|
||||
currentStatus.VE2 = getVE2();
|
||||
currentStatus.VE = currentStatus.VE2;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void calculateSecondarySpark(void)
|
||||
{
|
||||
//Same as above but for the secondary ignition table
|
||||
BIT_CLEAR(currentStatus.status5, BIT_STATUS5_SPARK2_ACTIVE); //Clear the bit indicating that the 2nd spark table is in use.
|
||||
if(configPage10.spark2Mode > 0)
|
||||
{
|
||||
if(configPage10.spark2Mode == SPARK2_MODE_MULTIPLY)
|
||||
{
|
||||
BIT_SET(currentStatus.status5, BIT_STATUS5_SPARK2_ACTIVE);
|
||||
currentStatus.advance2 = getAdvance2();
|
||||
//make sure we don't have a negative value in the multiplier table (sharing a signed 8 bit table)
|
||||
if(currentStatus.advance2 < 0) { currentStatus.advance2 = 0; }
|
||||
//Spark 2 table is treated as a % value. Table 1 and 2 are multiplied together and divided by 100
|
||||
int16_t combinedAdvance = ((int16_t)currentStatus.advance1 * (int16_t)currentStatus.advance2) / 100;
|
||||
//make sure we don't overflow and accidentally set negative timing, currentStatus.advance can only hold a signed 8 bit value
|
||||
if(combinedAdvance <= 127) { currentStatus.advance = combinedAdvance; }
|
||||
else { currentStatus.advance = 127; }
|
||||
}
|
||||
else if(configPage10.spark2Mode == SPARK2_MODE_ADD)
|
||||
{
|
||||
BIT_SET(currentStatus.status5, BIT_STATUS5_SPARK2_ACTIVE); //Set the bit indicating that the 2nd spark table is in use.
|
||||
currentStatus.advance2 = getAdvance2();
|
||||
//Spark tables are added together, but a check is made to make sure this won't overflow the 8-bit VE value
|
||||
int16_t combinedAdvance = (int16_t)currentStatus.advance1 + (int16_t)currentStatus.advance2;
|
||||
//make sure we don't overflow and accidentally set negative timing, currentStatus.advance can only hold a signed 8 bit value
|
||||
if(combinedAdvance <= 127) { currentStatus.advance = combinedAdvance; }
|
||||
else { currentStatus.advance = 127; }
|
||||
}
|
||||
else if(configPage10.spark2Mode == SPARK2_MODE_CONDITIONAL_SWITCH )
|
||||
{
|
||||
if(configPage10.spark2SwitchVariable == SPARK2_CONDITION_RPM)
|
||||
{
|
||||
if(currentStatus.RPM > configPage10.spark2SwitchValue)
|
||||
{
|
||||
BIT_SET(currentStatus.status5, BIT_STATUS5_SPARK2_ACTIVE); //Set the bit indicating that the 2nd spark table is in use.
|
||||
currentStatus.advance2 = getAdvance2();
|
||||
currentStatus.advance = currentStatus.advance2;
|
||||
}
|
||||
}
|
||||
else if(configPage10.spark2SwitchVariable == SPARK2_CONDITION_MAP)
|
||||
{
|
||||
if(currentStatus.MAP > configPage10.spark2SwitchValue)
|
||||
{
|
||||
BIT_SET(currentStatus.status5, BIT_STATUS5_SPARK2_ACTIVE); //Set the bit indicating that the 2nd spark table is in use.
|
||||
currentStatus.advance2 = getAdvance2();
|
||||
currentStatus.advance = currentStatus.advance2;
|
||||
}
|
||||
}
|
||||
else if(configPage10.spark2SwitchVariable == SPARK2_CONDITION_TPS)
|
||||
{
|
||||
if(currentStatus.TPS > configPage10.spark2SwitchValue)
|
||||
{
|
||||
BIT_SET(currentStatus.status5, BIT_STATUS5_SPARK2_ACTIVE); //Set the bit indicating that the 2nd spark table is in use.
|
||||
currentStatus.advance2 = getAdvance2();
|
||||
currentStatus.advance = currentStatus.advance2;
|
||||
}
|
||||
}
|
||||
else if(configPage10.spark2SwitchVariable == SPARK2_CONDITION_ETH)
|
||||
{
|
||||
if(currentStatus.ethanolPct > configPage10.spark2SwitchValue)
|
||||
{
|
||||
BIT_SET(currentStatus.status5, BIT_STATUS5_SPARK2_ACTIVE); //Set the bit indicating that the 2nd spark table is in use.
|
||||
currentStatus.advance2 = getAdvance2();
|
||||
currentStatus.advance = currentStatus.advance2;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(configPage10.spark2Mode == SPARK2_MODE_INPUT_SWITCH)
|
||||
{
|
||||
if(digitalRead(pinSpark2Input) == configPage10.spark2InputPolarity)
|
||||
{
|
||||
BIT_SET(currentStatus.status5, BIT_STATUS5_SPARK2_ACTIVE); //Set the bit indicating that the 2nd spark table is in use.
|
||||
currentStatus.advance2 = getAdvance2();
|
||||
currentStatus.advance = currentStatus.advance2;
|
||||
}
|
||||
}
|
||||
|
||||
//Apply the fixed timing correction manually. This has to be done again here if any of the above conditions are met to prevent any of the seconadary calculations applying instead of fixec timing
|
||||
currentStatus.advance = correctionFixedTiming(currentStatus.advance);
|
||||
currentStatus.advance = correctionCrankingFixedTiming(currentStatus.advance); //This overrides the regular fixed timing, must come last
|
||||
}
|
||||
}
|
||||
#include "load_source.h"
|
||||
#include "maths.h"
|
||||
#include "unit_testing.h"
|
||||
|
||||
/**
|
||||
* @brief Looks up and returns the VE value from the secondary fuel table
|
||||
|
|
@ -165,59 +10,171 @@ void calculateSecondarySpark(void)
|
|||
* This performs largely the same operations as getVE() however the lookup is of the secondary fuel table and uses the secondary load source
|
||||
* @return byte
|
||||
*/
|
||||
byte getVE2(void)
|
||||
static inline uint8_t lookupVE2(const config10 &page10, const table3d16RpmLoad &veLookupTable, const statuses ¤t)
|
||||
{
|
||||
byte tempVE = 100;
|
||||
if( configPage10.fuel2Algorithm == LOAD_SOURCE_MAP)
|
||||
{
|
||||
//Speed Density
|
||||
currentStatus.fuelLoad2 = currentStatus.MAP;
|
||||
}
|
||||
else if (configPage10.fuel2Algorithm == LOAD_SOURCE_TPS)
|
||||
{
|
||||
//Alpha-N
|
||||
currentStatus.fuelLoad2 = currentStatus.TPS * 2;
|
||||
}
|
||||
else if (configPage10.fuel2Algorithm == LOAD_SOURCE_IMAPEMAP)
|
||||
{
|
||||
//IMAP / EMAP
|
||||
currentStatus.fuelLoad2 = ((int16_t)currentStatus.MAP * 100U) / currentStatus.EMAP;
|
||||
}
|
||||
else { currentStatus.fuelLoad2 = currentStatus.MAP; } //Fallback position
|
||||
tempVE = get3DTableValue(&fuelTable2, currentStatus.fuelLoad2, currentStatus.RPM); //Perform lookup into fuel map for RPM vs MAP value
|
||||
|
||||
return tempVE;
|
||||
return get3DTableValue(&veLookupTable, getLoad(page10.fuel2Algorithm, current), (table3d_axis_t)current.RPM); //Perform lookup into fuel map for RPM vs MAP value
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Performs a lookup of the second ignition advance table. The values used to look this up will be RPM and whatever load source the user has configured
|
||||
*
|
||||
* @return byte The current target advance value in degrees
|
||||
*/
|
||||
byte getAdvance2(void)
|
||||
{
|
||||
byte tempAdvance = 0;
|
||||
if (configPage10.spark2Algorithm == LOAD_SOURCE_MAP) //Check which fuelling algorithm is being used
|
||||
{
|
||||
//Speed Density
|
||||
currentStatus.ignLoad2 = currentStatus.MAP;
|
||||
}
|
||||
else if(configPage10.spark2Algorithm == LOAD_SOURCE_TPS)
|
||||
{
|
||||
//Alpha-N
|
||||
currentStatus.ignLoad2 = currentStatus.TPS * 2;
|
||||
|
||||
}
|
||||
else if (configPage10.spark2Algorithm == LOAD_SOURCE_IMAPEMAP)
|
||||
{
|
||||
//IMAP / EMAP
|
||||
currentStatus.ignLoad2 = (currentStatus.MAP * 100) / currentStatus.EMAP;
|
||||
}
|
||||
else { currentStatus.ignLoad2 = currentStatus.MAP; }
|
||||
tempAdvance = get3DTableValue(&ignitionTable2, currentStatus.ignLoad2, currentStatus.RPM) - OFFSET_IGNITION; //As above, but for ignition advance
|
||||
|
||||
//Perform the corrections calculation on the secondary advance value, only if it uses a switched mode
|
||||
if( (configPage10.spark2SwitchVariable == SPARK2_MODE_CONDITIONAL_SWITCH) || (configPage10.spark2SwitchVariable == SPARK2_MODE_INPUT_SWITCH) ) { tempAdvance = correctionsIgn(tempAdvance); }
|
||||
|
||||
return tempAdvance;
|
||||
static inline bool fuelModeCondSwitchRpmActive(const config10 &page10, const statuses ¤t) {
|
||||
return (page10.fuel2SwitchVariable == FUEL2_CONDITION_RPM)
|
||||
&& (current.RPM > page10.fuel2SwitchValue);
|
||||
}
|
||||
|
||||
static inline bool fuelModeCondSwitchMapActive(const config10 &page10, const statuses ¤t) {
|
||||
return (page10.fuel2SwitchVariable == FUEL2_CONDITION_MAP)
|
||||
&& ((uint16_t)(int16_t)current.MAP > page10.fuel2SwitchValue);
|
||||
}
|
||||
|
||||
static inline bool fuelModeCondSwitchTpsActive(const config10 &page10, const statuses ¤t) {
|
||||
return (page10.fuel2SwitchVariable == FUEL2_CONDITION_TPS)
|
||||
&& (current.TPS > page10.fuel2SwitchValue);
|
||||
}
|
||||
|
||||
static inline bool fuelModeCondSwitchEthanolActive(const config10 &page10, const statuses ¤t) {
|
||||
return (page10.fuel2SwitchVariable == FUEL2_CONDITION_ETH)
|
||||
&& (current.ethanolPct > page10.fuel2SwitchValue);
|
||||
}
|
||||
|
||||
static inline bool fuelModeCondSwitchActive(const config10 &page10, const statuses ¤t) {
|
||||
return (page10.fuel2Mode == FUEL2_MODE_CONDITIONAL_SWITCH)
|
||||
&& ( fuelModeCondSwitchRpmActive(page10, current)
|
||||
|| fuelModeCondSwitchMapActive(page10, current)
|
||||
|| fuelModeCondSwitchTpsActive(page10, current)
|
||||
|| fuelModeCondSwitchEthanolActive(page10, current));
|
||||
}
|
||||
|
||||
static inline bool fuelModeInputSwitchActive(const config10 &page10) {
|
||||
return (page10.fuel2Mode == FUEL2_MODE_INPUT_SWITCH)
|
||||
&& (digitalRead(pinFuel2Input) == page10.fuel2InputPolarity);
|
||||
}
|
||||
|
||||
void calculateSecondaryFuel(const config10 &page10, const table3d16RpmLoad &veLookupTable, statuses ¤t)
|
||||
{
|
||||
//If the secondary fuel table is in use, also get the VE value from there
|
||||
if(page10.fuel2Mode == FUEL2_MODE_MULTIPLY)
|
||||
{
|
||||
current.VE2 = lookupVE2(page10, veLookupTable, current);
|
||||
BIT_SET(current.status3, BIT_STATUS3_FUEL2_ACTIVE); //Set the bit indicating that the 2nd fuel table is in use.
|
||||
//Fuel 2 table is treated as a % value. Table 1 and 2 are multiplied together and divided by 100
|
||||
auto combinedVE = percentage(current.VE2, current.VE1);
|
||||
current.VE = (uint8_t)min((uint32_t)UINT8_MAX, combinedVE);
|
||||
}
|
||||
else if(page10.fuel2Mode == FUEL2_MODE_ADD)
|
||||
{
|
||||
current.VE2 = lookupVE2(page10, veLookupTable, current);
|
||||
BIT_SET(current.status3, BIT_STATUS3_FUEL2_ACTIVE); //Set the bit indicating that the 2nd fuel table is in use.
|
||||
//Fuel tables are added together, but a check is made to make sure this won't overflow the 8-bit VE value
|
||||
uint16_t combinedVE = (uint16_t)current.VE1 + (uint16_t)current.VE2;
|
||||
current.VE = (uint8_t)min((uint16_t)UINT8_MAX, combinedVE);
|
||||
}
|
||||
else if(fuelModeCondSwitchActive(page10, current) || fuelModeInputSwitchActive(page10))
|
||||
{
|
||||
current.VE2 = lookupVE2(page10, veLookupTable, current);
|
||||
BIT_SET(current.status3, BIT_STATUS3_FUEL2_ACTIVE); //Set the bit indicating that the 2nd fuel table is in use.
|
||||
current.VE = current.VE2;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Unknown mode or mode not activated
|
||||
BIT_CLEAR(current.status3, BIT_STATUS3_FUEL2_ACTIVE); //Clear the bit indicating that the 2nd fuel table is in use.
|
||||
current.VE2 = 0U;
|
||||
}
|
||||
}
|
||||
|
||||
// The bounds of the spark table vary depending on the mode (see the INI file).
|
||||
// int16_t is wide enough to capture the full range of the table.
|
||||
static inline int16_t lookupSpark2(const config10 &page10, const table3d16RpmLoad &sparkLookupTable, const statuses ¤t) {
|
||||
return (int16_t)get3DTableValue(&sparkLookupTable, getLoad(page10.spark2Algorithm, current), (table3d_axis_t)current.RPM) - INT16_C(OFFSET_IGNITION);
|
||||
}
|
||||
|
||||
static inline int8_t constrainAdvance(int16_t advance)
|
||||
{
|
||||
// Clamp to return type range.
|
||||
return (int8_t)clamp(advance, (int16_t)INT8_MIN, (int16_t)INT8_MAX);
|
||||
}
|
||||
|
||||
static inline bool sparkModeCondSwitchRpmActive(const config10 &page10, const statuses ¤t) {
|
||||
return (page10.spark2SwitchVariable == SPARK2_CONDITION_RPM)
|
||||
&& (current.RPM > page10.spark2SwitchValue);
|
||||
}
|
||||
|
||||
static inline bool sparkModeCondSwitchMapActive(const config10 &page10, const statuses ¤t) {
|
||||
return (page10.spark2SwitchVariable == SPARK2_CONDITION_MAP)
|
||||
&& ((uint16_t)(int16_t)current.MAP > page10.spark2SwitchValue);
|
||||
}
|
||||
|
||||
static inline bool sparkModeCondSwitchTpsActive(const config10 &page10, const statuses ¤t) {
|
||||
return (page10.spark2SwitchVariable == SPARK2_CONDITION_TPS)
|
||||
&& (current.TPS > page10.spark2SwitchValue);
|
||||
}
|
||||
|
||||
static inline bool sparkModeCondSwitchEthanolActive(const config10 &page10, const statuses ¤t) {
|
||||
return (page10.spark2SwitchVariable == SPARK2_CONDITION_ETH)
|
||||
&& (current.ethanolPct > page10.spark2SwitchValue);
|
||||
}
|
||||
|
||||
static inline bool sparkModeCondSwitchActive(const config10 &page10, const statuses ¤t) {
|
||||
return (page10.spark2Mode == SPARK2_MODE_CONDITIONAL_SWITCH)
|
||||
&& ( sparkModeCondSwitchRpmActive(page10, current)
|
||||
|| sparkModeCondSwitchMapActive(page10, current)
|
||||
|| sparkModeCondSwitchTpsActive(page10, current)
|
||||
|| sparkModeCondSwitchEthanolActive(page10, current));
|
||||
}
|
||||
|
||||
static inline bool sparkModeInputSwitchActive(const config10 &page10) {
|
||||
return (page10.spark2Mode == SPARK2_MODE_INPUT_SWITCH)
|
||||
&& (digitalRead(pinSpark2Input) == page10.spark2InputPolarity);
|
||||
}
|
||||
|
||||
static inline bool isFixedTimingOn(const config2 &page2, const statuses ¤t) {
|
||||
// Fixed timing is in effect
|
||||
return (page2.fixAngEnable == 1U)
|
||||
// Cranking, so the cranking advance angle is in effect
|
||||
|| (BIT_CHECK(current.engine, BIT_ENGINE_CRANK));
|
||||
}
|
||||
|
||||
void calculateSecondarySpark(const config2 &page2, const config10 &page10, const table3d16RpmLoad &sparkLookupTable, statuses ¤t)
|
||||
{
|
||||
BIT_CLEAR(current.status5, BIT_STATUS5_SPARK2_ACTIVE); //Clear the bit indicating that the 2nd spark table is in use.
|
||||
current.advance2 = 0;
|
||||
|
||||
if (!isFixedTimingOn(page2, current))
|
||||
{
|
||||
if(page10.spark2Mode == SPARK2_MODE_MULTIPLY)
|
||||
{
|
||||
BIT_SET(current.status5, BIT_STATUS5_SPARK2_ACTIVE);
|
||||
uint8_t spark2Percent = (uint8_t)clamp(lookupSpark2(page10, sparkLookupTable, current), (int16_t)0, (int16_t)UINT8_MAX);
|
||||
//Spark 2 table is treated as a % value. Table 1 and 2 are multiplied together and divided by 100
|
||||
int16_t combinedAdvance = div100((int16_t)spark2Percent * (int16_t)current.advance1);
|
||||
//make sure we don't overflow and accidentally set negative timing: current.advance can only hold a signed 8 bit value
|
||||
current.advance = constrainAdvance(combinedAdvance);
|
||||
|
||||
// This is informational only, but the value needs corrected into the int8_t range
|
||||
current.advance2 = constrainAdvance((int16_t)spark2Percent-(int16_t)INT8_MAX);
|
||||
}
|
||||
else if(page10.spark2Mode == SPARK2_MODE_ADD)
|
||||
{
|
||||
BIT_SET(current.status5, BIT_STATUS5_SPARK2_ACTIVE); //Set the bit indicating that the 2nd spark table is in use.
|
||||
current.advance2 = constrainAdvance(lookupSpark2(page10, sparkLookupTable, current));
|
||||
//Spark tables are added together, but a check is made to make sure this won't overflow the 8-bit VE value
|
||||
int16_t combinedAdvance = (int16_t)current.advance1 + (int16_t)current.advance2;
|
||||
current.advance = constrainAdvance(combinedAdvance);
|
||||
}
|
||||
else if(sparkModeCondSwitchActive(page10, current) || sparkModeInputSwitchActive(page10))
|
||||
{
|
||||
BIT_SET(current.status5, BIT_STATUS5_SPARK2_ACTIVE); //Set the bit indicating that the 2nd spark table is in use.
|
||||
#if defined(UNIT_TEST)
|
||||
current.advance2 = constrainAdvance(lookupSpark2(page10, sparkLookupTable, current));
|
||||
#else
|
||||
//Perform the corrections calculation on the secondary advance value, only if it uses a switched mode
|
||||
current.advance2 = correctionsIgn(constrainAdvance(lookupSpark2(page10, sparkLookupTable, current)));
|
||||
#endif
|
||||
current.advance = current.advance2;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Unknown mode or mode not activated
|
||||
// Keep MISRA checker happy.
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,9 @@
|
|||
void calculateSecondaryFuel(void);
|
||||
void calculateSecondarySpark(void);
|
||||
byte getVE2(void);
|
||||
byte getAdvance2(void);
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include "statuses.h"
|
||||
#include "config_pages.h"
|
||||
#include "table3d.h"
|
||||
|
||||
void calculateSecondaryFuel(const config10 &page10, const table3d16RpmLoad &veLookupTable, statuses ¤t);
|
||||
void calculateSecondarySpark(const config2 &page2, const config10 &page10, const table3d16RpmLoad &sparkLookupTable, statuses ¤t);
|
||||
|
|
|
|||
|
|
@ -18,8 +18,8 @@
|
|||
void setup(void);
|
||||
void loop(void);
|
||||
uint16_t PW(int REQ_FUEL, byte VE, long MAP, uint16_t corrections, int injOpen);
|
||||
byte getVE1(void);
|
||||
byte getAdvance1(void);
|
||||
uint8_t getVE1(void);
|
||||
int8_t getAdvance1(void);
|
||||
uint16_t calculatePWLimit();
|
||||
void calculateStaging(uint32_t);
|
||||
void calculateIgnitionAngles(uint16_t dwellAngle);
|
||||
|
|
|
|||
|
|
@ -45,6 +45,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|||
#include "SD_logger.h"
|
||||
#include "schedule_calcs.h"
|
||||
#include "auxiliaries.h"
|
||||
#include "load_source.h"
|
||||
#include RTC_LIB_H //Defined in each boards .h file
|
||||
#include BOARD_H //Note that this is not a real file, it is defined in globals.h.
|
||||
|
||||
|
|
@ -414,8 +415,8 @@ void __attribute__((always_inline)) loop(void)
|
|||
currentStatus.advance1 = getAdvance1();
|
||||
currentStatus.advance = currentStatus.advance1; //Set the final advance value to be advance 1 as a default. This may be changed in the section below
|
||||
|
||||
calculateSecondaryFuel();
|
||||
calculateSecondarySpark();
|
||||
calculateSecondaryFuel(configPage10, fuelTable2, currentStatus);
|
||||
calculateSecondarySpark(configPage2, configPage10, ignitionTable2, currentStatus);
|
||||
|
||||
//Always check for sync
|
||||
//Main loop runs within this clause
|
||||
|
|
@ -1287,28 +1288,10 @@ uint16_t PW(int REQ_FUEL, byte VE, long MAP, uint16_t corrections, int injOpen)
|
|||
*
|
||||
* @return byte The current VE value
|
||||
*/
|
||||
byte getVE1(void)
|
||||
uint8_t getVE1(void)
|
||||
{
|
||||
byte tempVE = 100;
|
||||
if (configPage2.fuelAlgorithm == LOAD_SOURCE_MAP) //Check which fuelling algorithm is being used
|
||||
{
|
||||
//Speed Density
|
||||
currentStatus.fuelLoad = currentStatus.MAP;
|
||||
}
|
||||
else if (configPage2.fuelAlgorithm == LOAD_SOURCE_TPS)
|
||||
{
|
||||
//Alpha-N
|
||||
currentStatus.fuelLoad = currentStatus.TPS * 2;
|
||||
}
|
||||
else if (configPage2.fuelAlgorithm == LOAD_SOURCE_IMAPEMAP)
|
||||
{
|
||||
//IMAP / EMAP
|
||||
currentStatus.fuelLoad = ((int16_t)currentStatus.MAP * 100U) / currentStatus.EMAP;
|
||||
}
|
||||
else { currentStatus.fuelLoad = currentStatus.MAP; } //Fallback position
|
||||
tempVE = get3DTableValue(&fuelTable, currentStatus.fuelLoad, currentStatus.RPM); //Perform lookup into fuel map for RPM vs MAP value
|
||||
|
||||
return tempVE;
|
||||
currentStatus.fuelLoad = getLoad(configPage2.fuelAlgorithm, currentStatus);
|
||||
return get3DTableValue(&fuelTable, currentStatus.fuelLoad, currentStatus.RPM); //Perform lookup into fuel map for RPM vs MAP value
|
||||
}
|
||||
|
||||
/** Lookup the ignition advance from 3D ignition table.
|
||||
|
|
@ -1316,29 +1299,10 @@ byte getVE1(void)
|
|||
*
|
||||
* @return byte The current target advance value in degrees
|
||||
*/
|
||||
byte getAdvance1(void)
|
||||
int8_t getAdvance1(void)
|
||||
{
|
||||
byte tempAdvance = 0;
|
||||
if (configPage2.ignAlgorithm == LOAD_SOURCE_MAP) //Check which fuelling algorithm is being used
|
||||
{
|
||||
//Speed Density
|
||||
currentStatus.ignLoad = currentStatus.MAP;
|
||||
}
|
||||
else if(configPage2.ignAlgorithm == LOAD_SOURCE_TPS)
|
||||
{
|
||||
//Alpha-N
|
||||
currentStatus.ignLoad = currentStatus.TPS * 2;
|
||||
|
||||
}
|
||||
else if (configPage2.fuelAlgorithm == LOAD_SOURCE_IMAPEMAP)
|
||||
{
|
||||
//IMAP / EMAP
|
||||
currentStatus.ignLoad = ((int16_t)currentStatus.MAP * 100U) / currentStatus.EMAP;
|
||||
}
|
||||
tempAdvance = get3DTableValue(&ignitionTable, currentStatus.ignLoad, currentStatus.RPM) - OFFSET_IGNITION; //As above, but for ignition advance
|
||||
tempAdvance = correctionsIgn(tempAdvance);
|
||||
|
||||
return tempAdvance;
|
||||
currentStatus.ignLoad = getLoad(configPage2.ignAlgorithm, currentStatus);
|
||||
return correctionsIgn((int16_t)get3DTableValue(&ignitionTable, currentStatus.ignLoad, currentStatus.RPM) - INT16_C(OFFSET_IGNITION)); //As above, but for ignition advance
|
||||
}
|
||||
|
||||
/** Calculate the Ignition angles for all cylinders (based on @ref config2.nCylinders).
|
||||
|
|
|
|||
|
|
@ -0,0 +1,243 @@
|
|||
/**
|
||||
* @file
|
||||
*
|
||||
* @brief The statuses struct and related defines.
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <SimplyAtomic.h>
|
||||
#include "bit_manip.h"
|
||||
|
||||
using byte = uint8_t;
|
||||
|
||||
//Define bit positions within engine variable
|
||||
#define BIT_ENGINE_RUN 0 // Engine running
|
||||
#define BIT_ENGINE_CRANK 1 // Engine cranking
|
||||
#define BIT_ENGINE_ASE 2 // after start enrichment (ASE)
|
||||
#define BIT_ENGINE_WARMUP 3 // Engine in warmup
|
||||
#define BIT_ENGINE_ACC 4 // in acceleration mode (TPS accel)
|
||||
#define BIT_ENGINE_DCC 5 // in deceleration mode
|
||||
#define BIT_ENGINE_MAPACC 6 // MAP acceleration mode
|
||||
#define BIT_ENGINE_MAPDCC 7 // MAP deceleration mode
|
||||
|
||||
// Bit masks for statuses::status1
|
||||
#define BIT_STATUS1_INJ1 0 //inj1
|
||||
#define BIT_STATUS1_INJ2 1 //inj2
|
||||
#define BIT_STATUS1_INJ3 2 //inj3
|
||||
#define BIT_STATUS1_INJ4 3 //inj4
|
||||
#define BIT_STATUS1_DFCO 4 //Deceleration fuel cutoff
|
||||
#define BIT_STATUS1_BOOSTCUT 5 //Fuel component of MAP based boost cut out
|
||||
#define BIT_STATUS1_TOOTHLOG1READY 6 //Used to flag if tooth log 1 is ready
|
||||
#define BIT_STATUS1_TOOTHLOG2READY 7 //Used to flag if tooth log 2 is ready (Log is not currently used)
|
||||
|
||||
// Bit masks for statuses::status2
|
||||
#define BIT_STATUS2_HLAUNCH 0 //Hard Launch indicator
|
||||
#define BIT_STATUS2_SLAUNCH 1 //Soft Launch indicator
|
||||
#define BIT_STATUS2_HRDLIM 2 //Hard limiter indicator
|
||||
#define BIT_STATUS2_SFTLIM 3 //Soft limiter indicator
|
||||
#define BIT_STATUS2_BOOSTCUT 4 //Spark component of MAP based boost cut out
|
||||
#define BIT_STATUS2_ERROR 5 // Error is detected
|
||||
#define BIT_STATUS2_IDLE 6 // idle on
|
||||
#define BIT_STATUS2_SYNC 7 // Whether engine has sync or not
|
||||
|
||||
// Bit masks for statuses::status3
|
||||
#define BIT_STATUS3_RESET_PREVENT 0 //Indicates whether reset prevention is enabled
|
||||
#define BIT_STATUS3_NITROUS 1
|
||||
#define BIT_STATUS3_FUEL2_ACTIVE 2
|
||||
#define BIT_STATUS3_VSS_REFRESH 3
|
||||
#define BIT_STATUS3_HALFSYNC 4 //shows if there is only sync from primary trigger, but not from secondary.
|
||||
#define BIT_STATUS3_NSQUIRTS1 5
|
||||
#define BIT_STATUS3_UNUSED1 6
|
||||
#define BIT_STATUS3_UNUSED2 7
|
||||
|
||||
// Bit masks for statuses::status4
|
||||
#define BIT_STATUS4_WMI_EMPTY 0 //Indicates whether the WMI tank is empty
|
||||
#define BIT_STATUS4_VVT1_ERROR 1 //VVT1 cam angle within limits or not
|
||||
#define BIT_STATUS4_VVT2_ERROR 2 //VVT2 cam angle within limits or not
|
||||
#define BIT_STATUS4_FAN 3 //Fan Status
|
||||
#define BIT_STATUS4_BURNPENDING 4
|
||||
#define BIT_STATUS4_STAGING_ACTIVE 5
|
||||
#define BIT_STATUS4_COMMS_COMPAT 6
|
||||
#define BIT_STATUS4_ALLOW_LEGACY_COMMS 7
|
||||
|
||||
// Bit masks for statuses::status5
|
||||
#define BIT_STATUS5_FLATSH 0 //Flat shift hard cut
|
||||
#define BIT_STATUS5_FLATSS 1 //Flat shift soft cut
|
||||
#define BIT_STATUS5_SPARK2_ACTIVE 2
|
||||
#define BIT_STATUS5_KNOCK_ACTIVE 3
|
||||
#define BIT_STATUS5_KNOCK_PULSE 4
|
||||
#define BIT_STATUS5_UNUSED6 5
|
||||
#define BIT_STATUS5_UNUSED7 6
|
||||
#define BIT_STATUS5_UNUSED8 7
|
||||
|
||||
#define BIT_AIRCON_REQUEST 0 //Indicates whether the A/C button is pressed
|
||||
#define BIT_AIRCON_COMPRESSOR 1 //Indicates whether the A/C compressor is running
|
||||
#define BIT_AIRCON_RPM_LOCKOUT 2 //Indicates the A/C is locked out due to the RPM being too high/low, or the post-high/post-low-RPM "stand-down" lockout period
|
||||
#define BIT_AIRCON_TPS_LOCKOUT 3 //Indicates the A/C is locked out due to high TPS, or the post-high-TPS "stand-down" lockout period
|
||||
#define BIT_AIRCON_TURNING_ON 4 //Indicates the A/C request is on (i.e. A/C button pressed), the lockouts are off, however the start delay has not yet elapsed. This gives the idle up time to kick in before the compressor.
|
||||
#define BIT_AIRCON_CLT_LOCKOUT 5 //Indicates the A/C is locked out either due to high coolant temp.
|
||||
#define BIT_AIRCON_FAN 6 //Indicates whether the A/C fan is running
|
||||
#define BIT_AIRCON_UNUSED8 7
|
||||
|
||||
#define ENGINE_PROTECT_BIT_RPM 0
|
||||
#define ENGINE_PROTECT_BIT_MAP 1
|
||||
#define ENGINE_PROTECT_BIT_OIL 2
|
||||
#define ENGINE_PROTECT_BIT_AFR 3
|
||||
#define ENGINE_PROTECT_BIT_COOLANT 4
|
||||
|
||||
/** @brief The status struct with current values for all 'live' variables.
|
||||
*
|
||||
* Instantiated as global currentStatus.
|
||||
*
|
||||
* @note int *ADC (Analog-to-digital value / count) values contain the "raw" value from AD conversion, which get converted to
|
||||
* unit based values in similar variable(s) without ADC part in name (see sensors.ino for reading of sensors).
|
||||
*/
|
||||
struct statuses {
|
||||
// cppcheck-suppress misra-c2012-6.1 ; False positive - MISRA C:2012 Rule (R 6.1) permits the use of boolean for bit fields.
|
||||
volatile bool hasSync : 1; /**< Flag for crank/cam position being known by decoders (See decoders.ino).
|
||||
This is used for sanity checking e.g. before logging tooth history or reading some sensors and computing readings. */
|
||||
// cppcheck-suppress misra-c2012-6.1
|
||||
bool initialisationComplete : 1; ///< Tracks whether the setup() function has run completely
|
||||
// cppcheck-suppress misra-c2012-6.1
|
||||
bool clutchTrigger : 1;
|
||||
// cppcheck-suppress misra-c2012-6.1
|
||||
bool previousClutchTrigger : 1;
|
||||
// cppcheck-suppress misra-c2012-6.1
|
||||
volatile bool fpPrimed : 1; ///< Tracks whether or not the fuel pump priming has been completed yet
|
||||
// cppcheck-suppress misra-c2012-6.1
|
||||
volatile bool injPrimed : 1; ///< Tracks whether or not the injector priming has been completed yet
|
||||
// cppcheck-suppress misra-c2012-6.1
|
||||
volatile bool tachoSweepEnabled : 1;
|
||||
// cppcheck-suppress misra-c2012-6.1
|
||||
volatile bool tachoAlt : 1;
|
||||
|
||||
uint16_t RPM; ///< RPM - Current Revs per minute
|
||||
byte RPMdiv100; ///< RPM value scaled (divided by 100) to fit a byte (0-255, e.g. 12000 => 120)
|
||||
long longRPM; ///< RPM as long int (gets assigned to / maintained in statuses.RPM as well)
|
||||
uint16_t baroADC;
|
||||
long MAP; ///< Manifold absolute pressure. Has to be a long for PID calcs (Boost control)
|
||||
int16_t EMAP; ///< EMAP ... (See @ref config6.useEMAP for EMAP enablement)
|
||||
uint8_t baro; ///< Barometric pressure is simply the initial MAP reading, taken before the engine is running. Alternatively, can be taken from an external sensor
|
||||
uint8_t TPS; /**< The current TPS reading (0% - 100%). Is the tpsADC value after the calibration is applied */
|
||||
uint8_t tpsADC; /**< byte (valued: 0-255) representation of the TPS. Downsampled from the original 10-bit (0-1023) reading, but before any calibration is applied */
|
||||
int16_t tpsDOT; /**< TPS delta over time. Measures the % per second that the TPS is changing. Note that is signed value, because TPSdot can be also negative */
|
||||
byte TPSlast; /**< The previous TPS reading */
|
||||
int16_t mapDOT; /**< MAP delta over time. Measures the kpa per second that the MAP is changing. Note that is signed value, because MAPdot can be also negative */
|
||||
volatile int rpmDOT; /**< RPM delta over time (RPM increase / s ?) */
|
||||
byte VE; /**< The current VE value being used in the fuel calculation. Can be the same as VE1 or VE2, or a calculated value of both. */
|
||||
byte VE1; /**< The VE value from fuel table 1 */
|
||||
byte VE2; /**< The VE value from fuel table 2, if in use (and required conditions are met) */
|
||||
uint8_t O2; /**< Primary O2 sensor reading */
|
||||
uint8_t O2_2; /**< Secondary O2 sensor reading */
|
||||
int coolant; /**< Coolant temperature reading */
|
||||
uint16_t cltADC;
|
||||
int IAT; /**< Inlet air temperature reading */
|
||||
uint16_t iatADC;
|
||||
uint16_t O2ADC;
|
||||
uint16_t O2_2ADC;
|
||||
uint16_t dwell; ///< dwell (coil primary winding/circuit on) time (in ms * 10 ? See @ref correctionsDwell)
|
||||
volatile uint16_t actualDwell; ///< actual dwell time if new ignition mode is used (in uS)
|
||||
byte dwellCorrection; /**< The amount of correction being applied to the dwell time (in unit ...). */
|
||||
byte battery10; /**< The current BRV in volts (multiplied by 10. Eg 12.5V = 125) */
|
||||
int8_t advance; /**< The current advance value being used in the spark calculation. Can be the same as advance1 or advance2, or a calculated value of both */
|
||||
int8_t advance1; /**< The advance value from ignition table 1 */
|
||||
int8_t advance2; /**< The advance value from ignition table 2 */
|
||||
uint16_t corrections; /**< The total current corrections % amount */
|
||||
uint16_t AEamount; /**< The amount of acceleration enrichment currently being applied. 100=No change. Varies above 255 */
|
||||
byte egoCorrection; /**< The amount of closed loop AFR enrichment currently being applied */
|
||||
byte wueCorrection; /**< The amount of warmup enrichment currently being applied */
|
||||
byte batCorrection; /**< The amount of battery voltage enrichment currently being applied */
|
||||
byte iatCorrection; /**< The amount of inlet air temperature adjustment currently being applied */
|
||||
byte baroCorrection; /**< The amount of correction being applied for the current baro reading */
|
||||
byte launchCorrection; /**< The amount of correction being applied if launch control is active */
|
||||
byte flexCorrection; /**< Amount of correction being applied to compensate for ethanol content */
|
||||
byte fuelTempCorrection; /**< Amount of correction being applied to compensate for fuel temperature */
|
||||
int8_t flexIgnCorrection;/**< Amount of additional advance being applied based on flex. Note the type as this allows for negative values */
|
||||
byte afrTarget; /**< Current AFR Target looked up from AFR target table (x10 ? See @ref afrTable)*/
|
||||
byte CLIdleTarget; /**< The target idle RPM (when closed loop idle control is active) */
|
||||
bool idleUpActive; /**< Whether the externally controlled idle up is currently active */
|
||||
bool CTPSActive; /**< Whether the externally controlled closed throttle position sensor is currently active */
|
||||
volatile byte ethanolPct; /**< Ethanol reading (if enabled). 0 = No ethanol, 100 = pure ethanol. Eg E85 = 85. */
|
||||
volatile int8_t fuelTemp;
|
||||
unsigned long AEEndTime; /**< The target end time used whenever AE (acceleration enrichment) is turned on */
|
||||
volatile byte status1; ///< Status bits (See BIT_STATUS1_* defines on top of this file)
|
||||
volatile byte status2; ///< status 2/control indicator bits (launch control, boost cut, spark errors, See BIT_STATUS2_* defines)
|
||||
volatile byte status3; ///< Status bits (See BIT_STATUS3_* defines on top of this file)
|
||||
volatile byte status4; ///< Status bits (See BIT_STATUS4_* defines on top of this file)
|
||||
volatile byte status5; ///< Status 5 ... (See also @ref config10 Status 5* members and BIT_STATU5_* defines)
|
||||
uint8_t engine; ///< Engine status bits (See BIT_ENGINE_* defines on top of this file)
|
||||
unsigned int PW1; ///< In uS
|
||||
unsigned int PW2; ///< In uS
|
||||
unsigned int PW3; ///< In uS
|
||||
unsigned int PW4; ///< In uS
|
||||
unsigned int PW5; ///< In uS
|
||||
unsigned int PW6; ///< In uS
|
||||
unsigned int PW7; ///< In uS
|
||||
unsigned int PW8; ///< In uS
|
||||
volatile byte runSecs; /**< Counter of seconds since cranking commenced (Maxes out at 255 to prevent overflow) */
|
||||
volatile byte secl; /**< Counter incrementing once per second. Will overflow after 255 and begin again. This is used by TunerStudio to maintain comms sync */
|
||||
volatile uint16_t loopsPerSecond; /**< A performance indicator showing the number of main loops that are being executed each second */
|
||||
bool launchingSoft; /**< Indicator showing whether soft launch control adjustments are active */
|
||||
bool launchingHard; /**< Indicator showing whether hard launch control adjustments are active */
|
||||
uint16_t freeRAM;
|
||||
unsigned int clutchEngagedRPM; /**< The RPM at which the clutch was last depressed. Used for distinguishing between launch control and flat shift */
|
||||
bool flatShiftingHard;
|
||||
volatile uint32_t startRevolutions; /**< A counter for how many revolutions have been completed since sync was achieved. */
|
||||
uint16_t boostTarget;
|
||||
byte testOutputs; ///< Test Output bits (only first bit used/tested ?)
|
||||
bool testActive; // Not in use ? Replaced by testOutputs ?
|
||||
uint16_t boostDuty; ///< Boost Duty percentage value * 100 to give 2 points of precision
|
||||
byte idleLoad; ///< Either the current steps or current duty cycle for the idle control
|
||||
uint16_t canin[16]; ///< 16bit raw value of selected canin data for channels 0-15
|
||||
uint8_t current_caninchannel = 0; /**< Current CAN channel, defaults to 0 */
|
||||
uint16_t crankRPM = 400; /**< The actual cranking RPM limit. This is derived from the value in the config page, but saves us multiplying it every time it's used (Config page value is stored divided by 10) */
|
||||
int16_t flexBoostCorrection; /**< Amount of boost added based on flex */
|
||||
byte nitrous_status;
|
||||
byte nSquirts; ///< Number of injector squirts per cycle (per injector)
|
||||
byte nChannels; /**< Number of fuel and ignition channels. */
|
||||
int16_t fuelLoad;
|
||||
int16_t ignLoad;
|
||||
bool fuelPumpOn; /**< Indicator showing the current status of the fuel pump */
|
||||
volatile byte syncLossCounter;
|
||||
byte knockRetard;
|
||||
volatile byte knockCount;
|
||||
bool toothLogEnabled;
|
||||
byte compositeTriggerUsed; // 0 means composite logger disabled, 2 means use secondary input (1st cam), 3 means use tertiary input (2nd cam), 4 means log both cams together
|
||||
int16_t vvt1Angle; //Has to be a long for PID calcs (CL VVT control)
|
||||
byte vvt1TargetAngle;
|
||||
long vvt1Duty; //Has to be a long for PID calcs (CL VVT control)
|
||||
uint16_t injAngle;
|
||||
byte ASEValue;
|
||||
uint16_t vss; /**< Current speed reading. Natively stored in kph and converted to mph in TS if required */
|
||||
bool idleUpOutputActive; /**< Whether the idle up output is currently active */
|
||||
byte gear; /**< Current gear (Calculated from vss) */
|
||||
byte fuelPressure; /**< Fuel pressure in PSI */
|
||||
byte oilPressure; /**< Oil pressure in PSI */
|
||||
byte engineProtectStatus;
|
||||
byte fanDuty;
|
||||
byte wmiPW;
|
||||
int16_t vvt2Angle; //Has to be a long for PID calcs (CL VVT control)
|
||||
byte vvt2TargetAngle;
|
||||
long vvt2Duty; //Has to be a long for PID calcs (CL VVT control)
|
||||
byte outputsStatus;
|
||||
byte TS_SD_Status; //TunerStudios SD card status
|
||||
byte airConStatus;
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Non-atomic version of HasAnySync. **Should only be called in an ATOMIC() block***
|
||||
*
|
||||
*/
|
||||
static inline bool HasAnySyncUnsafe(const statuses &status) {
|
||||
return status.hasSync || BIT_CHECK(status.status3, BIT_STATUS3_HALFSYNC);
|
||||
}
|
||||
|
||||
static inline bool HasAnySync(const statuses &status) {
|
||||
ATOMIC() {
|
||||
return HasAnySyncUnsafe(status);
|
||||
}
|
||||
return false; // Just here to avoid compiler warning.
|
||||
}
|
||||
|
|
@ -83,7 +83,7 @@ enum table_type_t {
|
|||
/* This will take up zero space unless we take the address somewhere */ \
|
||||
static constexpr table_type_t type_key = TO_TYPE_KEY(size, xDom, yDom); \
|
||||
\
|
||||
table3DGetValueCache get_value_cache; \
|
||||
mutable table3DGetValueCache get_value_cache; \
|
||||
value_t values; \
|
||||
xaxis_t axisX; \
|
||||
yaxis_t axisY; \
|
||||
|
|
@ -92,7 +92,7 @@ TABLE3D_GENERATOR(TABLE3D_GEN_TYPE)
|
|||
|
||||
// Generate get3DTableValue() functions
|
||||
#define TABLE3D_GEN_GET_TABLE_VALUE(size, xDom, yDom) \
|
||||
static inline table3d_value_t get3DTableValue(TABLE3D_TYPENAME_BASE(size, xDom, yDom) *pTable, table3d_axis_t y, table3d_axis_t x) \
|
||||
static inline table3d_value_t get3DTableValue(const TABLE3D_TYPENAME_BASE(size, xDom, yDom) *pTable, table3d_axis_t y, table3d_axis_t x) \
|
||||
{ \
|
||||
return get3DTableValue( &pTable->get_value_cache, \
|
||||
TABLE3D_TYPENAME_BASE(size, xDom, yDom)::value_t::row_size, \
|
||||
|
|
|
|||
|
|
@ -145,8 +145,8 @@ void doUpdates(void)
|
|||
if (readEEPROMVersion() == 8)
|
||||
{
|
||||
//May 2018 adds separate load sources for fuel and ignition. Copy the existing load algorithm into Both
|
||||
configPage2.fuelAlgorithm = configPage2.legacyMAP; //Was configPage2.unused2_38c
|
||||
configPage2.ignAlgorithm = configPage2.legacyMAP; //Was configPage2.unused2_38c
|
||||
configPage2.fuelAlgorithm = (LoadSource)configPage2.legacyMAP; //Was configPage2.unused2_38c
|
||||
configPage2.ignAlgorithm = (LoadSource)configPage2.legacyMAP; //Was configPage2.unused2_38c
|
||||
|
||||
//Add option back in for open or closed loop boost. For all current configs to use closed
|
||||
configPage4.boostType = 1;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,42 @@
|
|||
#include <Arduino.h>
|
||||
#include <unity.h>
|
||||
#include <avr/sleep.h>
|
||||
|
||||
#define UNITY_EXCLUDE_DETAILS
|
||||
|
||||
extern void test_calculateSecondaryFuel(void);
|
||||
extern void test_calculateSecondarySpark(void);
|
||||
|
||||
|
||||
void setup()
|
||||
{
|
||||
pinMode(LED_BUILTIN, OUTPUT);
|
||||
|
||||
// NOTE!!! Wait for >2 secs
|
||||
// if board doesn't support software reset via Serial.DTR/RTS
|
||||
#if !defined(SIMULATOR)
|
||||
delay(2000);
|
||||
#endif
|
||||
|
||||
UNITY_BEGIN(); // IMPORTANT LINE!
|
||||
|
||||
test_calculateSecondaryFuel();
|
||||
test_calculateSecondarySpark();
|
||||
|
||||
UNITY_END(); // stop unit testing
|
||||
|
||||
#if defined(SIMULATOR) // Tell SimAVR we are done
|
||||
cli();
|
||||
sleep_enable();
|
||||
sleep_cpu();
|
||||
#endif
|
||||
}
|
||||
|
||||
void loop()
|
||||
{
|
||||
// Blink to indicate end of test
|
||||
digitalWrite(LED_BUILTIN, HIGH);
|
||||
delay(250);
|
||||
digitalWrite(LED_BUILTIN, LOW);
|
||||
delay(250);
|
||||
}
|
||||
|
|
@ -0,0 +1,208 @@
|
|||
#include <unity.h>
|
||||
#include <avr/pgmspace.h>
|
||||
#include "secondaryTables.h"
|
||||
#include "globals.h"
|
||||
#include "../test_utils.h"
|
||||
#include "storage.h"
|
||||
|
||||
TEST_DATA_P table3d_axis_t tempXAxis[] = {500, 700, 900, 1200, 1600, 2000, 2500, 3100, 3500, 4100, 4700, 5300, 5900, 6500, 6750, 7000};
|
||||
TEST_DATA_P table3d_axis_t tempYAxis[] = {16, 26, 30, 36, 40, 46, 50, 56, 60, 66, 70, 76, 86, 90, 96, 100};
|
||||
|
||||
static void __attribute__((noinline)) assert_2nd_fuel_is_off(const statuses ¤t, uint8_t expectedVE) {
|
||||
TEST_ASSERT_BIT_LOW(BIT_STATUS3_FUEL2_ACTIVE, current.status3);
|
||||
TEST_ASSERT_EQUAL(expectedVE, current.VE1);
|
||||
TEST_ASSERT_EQUAL(0, current.VE2);
|
||||
TEST_ASSERT_EQUAL(current.VE1, current.VE);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) assert_2nd_fuel_is_on(const statuses ¤t, uint8_t expectedVE1, uint8_t expectedVE2, uint8_t expectedVE) {
|
||||
TEST_ASSERT_BIT_HIGH(BIT_STATUS3_FUEL2_ACTIVE, current.status3);
|
||||
TEST_ASSERT_EQUAL(expectedVE1, current.VE1);
|
||||
TEST_ASSERT_EQUAL(expectedVE2, current.VE2);
|
||||
TEST_ASSERT_EQUAL(expectedVE, current.VE);
|
||||
}
|
||||
|
||||
static void test_no_secondary_fuel(void) {
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
|
||||
page10.fuel2Mode = FUEL2_MODE_OFF;
|
||||
page10.fuel2Algorithm = LOAD_SOURCE_MAP;
|
||||
current.VE1 = 50;
|
||||
current.VE = current.VE1;
|
||||
|
||||
calculateSecondaryFuel(page10, lookupTable, current);
|
||||
|
||||
assert_2nd_fuel_is_off(current, 50);
|
||||
}
|
||||
|
||||
static constexpr int16_t SIMPLE_LOAD_VALUE = 150;
|
||||
|
||||
static void __attribute__((noinline)) test_fuel_mode_cap_UINT8_MAX(uint8_t mode) {
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
|
||||
fill_table_values(lookupTable, SIMPLE_LOAD_VALUE);
|
||||
populate_table_axis_P(lookupTable.axisX.begin(), tempXAxis);
|
||||
populate_table_axis_P(lookupTable.axisY.begin(), tempYAxis);
|
||||
|
||||
page10.fuel2Mode = mode;
|
||||
page10.fuel2Algorithm = LOAD_SOURCE_MAP;
|
||||
current.VE1 = 200;
|
||||
current.VE = current.VE1;
|
||||
current.MAP = 100; //Load source value
|
||||
current.RPM = 7000;
|
||||
|
||||
calculateSecondaryFuel(page10, lookupTable, current);
|
||||
|
||||
assert_2nd_fuel_is_on(current, 200, 150, UINT8_MAX);
|
||||
}
|
||||
|
||||
static constexpr int8_t SIMPLE_VE1 = 75;
|
||||
|
||||
static void __attribute__((noinline)) setup_test_fuel_mode_simple(config10 &page10, statuses ¤t, table3d16RpmLoad &lookupTable, uint8_t mode) {
|
||||
fill_table_values(lookupTable, SIMPLE_LOAD_VALUE);
|
||||
populate_table_axis_P(lookupTable.axisX.begin(), tempXAxis);
|
||||
populate_table_axis_P(lookupTable.axisY.begin(), tempYAxis);
|
||||
|
||||
page10.fuel2Mode = mode;
|
||||
page10.fuel2Algorithm = LOAD_SOURCE_MAP;
|
||||
current.VE1 = SIMPLE_VE1;
|
||||
current.VE = current.VE1;
|
||||
current.MAP = tempYAxis[0]; //Load source value
|
||||
current.RPM = tempXAxis[0];
|
||||
}
|
||||
static void __attribute__((noinline)) test_fuel_mode_simple(uint8_t mode, uint8_t expectedVE) {
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
|
||||
setup_test_fuel_mode_simple(page10, current, lookupTable, mode);
|
||||
|
||||
calculateSecondaryFuel(page10, lookupTable, current);
|
||||
|
||||
assert_2nd_fuel_is_on(current, SIMPLE_VE1, SIMPLE_LOAD_VALUE, expectedVE);
|
||||
}
|
||||
|
||||
static void test_fuel_mode_multiply_cap_UINT8_MAX(void) {
|
||||
test_fuel_mode_cap_UINT8_MAX(FUEL2_MODE_MULTIPLY);
|
||||
}
|
||||
|
||||
static void test_fuel_mode_multiply(void) {
|
||||
test_fuel_mode_simple(FUEL2_MODE_MULTIPLY, ((SIMPLE_VE1*SIMPLE_LOAD_VALUE)/100)+1);
|
||||
}
|
||||
|
||||
static void test_fuel_mode_add(void) {
|
||||
test_fuel_mode_simple(FUEL2_MODE_ADD, SIMPLE_VE1+SIMPLE_LOAD_VALUE);
|
||||
}
|
||||
|
||||
static void test_fuel_mode_add_cap_UINT8_MAX(void) {
|
||||
test_fuel_mode_cap_UINT8_MAX(FUEL2_MODE_ADD);
|
||||
}
|
||||
|
||||
static constexpr int16_t SWITCHED_LOAD = 50;
|
||||
static constexpr int16_t SWITCHED_VE2 = 68;
|
||||
|
||||
static void __attribute__((noinline)) setup_test_fuel_mode_cond_switch(config10 &page10, statuses ¤t, table3d16RpmLoad &lookupTable, uint8_t cond, uint16_t trigger) {
|
||||
setup_test_fuel_mode_simple(page10, current, lookupTable, FUEL2_MODE_CONDITIONAL_SWITCH);
|
||||
fill_table_values(lookupTable, SWITCHED_VE2);
|
||||
page10.fuel2SwitchVariable = cond;
|
||||
page10.fuel2SwitchValue = trigger;
|
||||
|
||||
current.MAP = SWITCHED_LOAD; //Load source value
|
||||
current.RPM = 3500;
|
||||
current.TPS = 50;
|
||||
current.ethanolPct = 50;
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_fuel_mode_cond_switch_negative(uint8_t cond, uint16_t trigger) {
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
setup_test_fuel_mode_cond_switch(page10, current, lookupTable, cond, trigger);
|
||||
|
||||
calculateSecondaryFuel(page10, lookupTable, current);
|
||||
|
||||
assert_2nd_fuel_is_off(current, SIMPLE_VE1);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_fuel_mode_cond_switch_positive(uint8_t cond, uint16_t trigger) {
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
setup_test_fuel_mode_cond_switch(page10, current, lookupTable, cond, trigger);
|
||||
|
||||
calculateSecondaryFuel(page10, lookupTable, current);
|
||||
|
||||
assert_2nd_fuel_is_on(current, SIMPLE_VE1, SWITCHED_VE2, SWITCHED_VE2);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_fuel_mode_cond_switch_rpm(void) {
|
||||
test_fuel_mode_cond_switch_positive(FUEL2_CONDITION_RPM, 3499);
|
||||
test_fuel_mode_cond_switch_negative(FUEL2_CONDITION_RPM, 3501);
|
||||
test_fuel_mode_cond_switch_positive(FUEL2_CONDITION_RPM, 3499);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_fuel_mode_cond_switch_tps(void) {
|
||||
test_fuel_mode_cond_switch_positive(FUEL2_CONDITION_TPS, 49);
|
||||
test_fuel_mode_cond_switch_negative(FUEL2_CONDITION_TPS, 51);
|
||||
test_fuel_mode_cond_switch_positive(FUEL2_CONDITION_TPS, 49);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_fuel_mode_cond_switch_map(void) {
|
||||
test_fuel_mode_cond_switch_positive(FUEL2_CONDITION_MAP, 49);
|
||||
test_fuel_mode_cond_switch_negative(FUEL2_CONDITION_MAP, 51);
|
||||
test_fuel_mode_cond_switch_positive(FUEL2_CONDITION_MAP, 49);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_fuel_mode_cond_switch_ethanol_pct(void) {
|
||||
test_fuel_mode_cond_switch_positive(FUEL2_CONDITION_ETH, 49);
|
||||
test_fuel_mode_cond_switch_negative(FUEL2_CONDITION_ETH, 51);
|
||||
test_fuel_mode_cond_switch_positive(FUEL2_CONDITION_ETH, 49);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_fuel_mode_input_switch(void) {
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
setup_test_fuel_mode_simple(page10, current, lookupTable, FUEL2_MODE_INPUT_SWITCH);
|
||||
fill_table_values(lookupTable, SWITCHED_VE2);
|
||||
|
||||
page10.fuel2InputPolarity = HIGH;
|
||||
pinFuel2Input = 3;
|
||||
pinMode(pinFuel2Input, OUTPUT);
|
||||
|
||||
// On
|
||||
digitalWrite(pinFuel2Input, page10.fuel2InputPolarity);
|
||||
calculateSecondaryFuel(page10, lookupTable, current);
|
||||
assert_2nd_fuel_is_on(current, SIMPLE_VE1, SWITCHED_VE2, SWITCHED_VE2);
|
||||
|
||||
// Off
|
||||
digitalWrite(pinFuel2Input, !page10.fuel2InputPolarity);
|
||||
current.VE = current.VE1;
|
||||
calculateSecondaryFuel(page10, lookupTable, current);
|
||||
assert_2nd_fuel_is_off(current, SIMPLE_VE1);
|
||||
|
||||
// On again
|
||||
digitalWrite(pinFuel2Input, page10.fuel2InputPolarity);
|
||||
calculateSecondaryFuel(page10, lookupTable, current);
|
||||
assert_2nd_fuel_is_on(current, SIMPLE_VE1, SWITCHED_VE2, SWITCHED_VE2);
|
||||
}
|
||||
|
||||
void test_calculateSecondaryFuel(void)
|
||||
{
|
||||
SET_UNITY_FILENAME() {
|
||||
RUN_TEST(test_no_secondary_fuel);
|
||||
RUN_TEST(test_fuel_mode_multiply);
|
||||
RUN_TEST(test_fuel_mode_multiply_cap_UINT8_MAX);
|
||||
RUN_TEST(test_fuel_mode_add);
|
||||
RUN_TEST(test_fuel_mode_add_cap_UINT8_MAX);
|
||||
RUN_TEST(test_fuel_mode_cond_switch_rpm);
|
||||
RUN_TEST(test_fuel_mode_cond_switch_tps);
|
||||
RUN_TEST(test_fuel_mode_cond_switch_map);
|
||||
RUN_TEST(test_fuel_mode_cond_switch_ethanol_pct);
|
||||
RUN_TEST(test_fuel_mode_input_switch);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,281 @@
|
|||
#include <unity.h>
|
||||
#include <avr/pgmspace.h>
|
||||
#include "secondaryTables.h"
|
||||
#include "globals.h"
|
||||
#include "../test_utils.h"
|
||||
#include "storage.h"
|
||||
// #include "corrections.h"
|
||||
#include "maths.h"
|
||||
|
||||
TEST_DATA_P table3d_axis_t tempXAxis[] = {500, 700, 900, 1200, 1600, 2000, 2500, 3100, 3500, 4100, 4700, 5300, 5900, 6500, 6750, 7000};
|
||||
TEST_DATA_P table3d_axis_t tempYAxis[] = {16, 26, 30, 36, 40, 46, 50, 56, 60, 66, 70, 76, 86, 90, 96, 100};
|
||||
|
||||
static void __attribute__((noinline)) assert_2nd_spark_is_off(const statuses ¤t, int8_t expectedAdvance) {
|
||||
TEST_ASSERT_BIT_LOW(BIT_STATUS5_SPARK2_ACTIVE, current.status5);
|
||||
TEST_ASSERT_EQUAL(expectedAdvance, current.advance1);
|
||||
TEST_ASSERT_EQUAL(0, current.advance2);
|
||||
TEST_ASSERT_EQUAL(current.advance1, current.advance);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) assert_2nd_spark_is_on(const statuses ¤t, int8_t expectedAdvance1, int8_t expectedAdvance2, int8_t expectedAdvance) {
|
||||
TEST_ASSERT_BIT_HIGH(BIT_STATUS5_SPARK2_ACTIVE, current.status5);
|
||||
TEST_ASSERT_EQUAL(expectedAdvance1, current.advance1);
|
||||
TEST_ASSERT_EQUAL(expectedAdvance2, current.advance2);
|
||||
TEST_ASSERT_EQUAL(expectedAdvance, current.advance);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_mode_off_no_secondary_spark(void) {
|
||||
config2 page2 = {};
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
|
||||
page10.spark2Mode = SPARK2_MODE_OFF;
|
||||
page10.spark2Algorithm = LOAD_SOURCE_MAP;
|
||||
current.advance1 = 50;
|
||||
current.advance = current.advance1;
|
||||
|
||||
calculateSecondarySpark(page2, page10, lookupTable, current);
|
||||
|
||||
assert_2nd_spark_is_off(current, 50);
|
||||
}
|
||||
|
||||
static constexpr int8_t CAP_ADVANCE1 = INT8_MAX - 1;
|
||||
static constexpr int16_t CAP_LOAD_LOOKUP_RESULT = 150;
|
||||
static constexpr int16_t CAP_LOAD_VALUE = CAP_LOAD_LOOKUP_RESULT-INT16_C(OFFSET_IGNITION);
|
||||
|
||||
static void __attribute__((noinline)) setup_test_mode_cap_INT8_MAX(config2 &, config10 &page10, statuses ¤t, table3d16RpmLoad &lookupTable, uint8_t mode) {
|
||||
page10.spark2Mode = mode;
|
||||
page10.spark2Algorithm = LOAD_SOURCE_MAP;
|
||||
current.advance1 = CAP_ADVANCE1;
|
||||
current.advance = current.advance1;
|
||||
current.MAP = tempYAxis[0];
|
||||
current.RPM = tempXAxis[0];
|
||||
fill_table_values(lookupTable, CAP_LOAD_LOOKUP_RESULT);
|
||||
populate_table_axis_P(lookupTable.axisX.begin(), tempXAxis);
|
||||
populate_table_axis_P(lookupTable.axisY.begin(), tempYAxis);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_mode_cap_INT8_MAX(uint8_t mode, int8_t expectedAdvance2) {
|
||||
config2 page2 = {};
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
|
||||
setup_test_mode_cap_INT8_MAX(page2, page10, current, lookupTable, mode);
|
||||
|
||||
calculateSecondarySpark(page2, page10, lookupTable, current);
|
||||
|
||||
assert_2nd_spark_is_on(current, CAP_ADVANCE1, expectedAdvance2, INT8_MAX);
|
||||
}
|
||||
|
||||
static constexpr int8_t SIMPLE_ADVANCE1 = 35;
|
||||
static constexpr int16_t SIMPLE_LOAD_LOOKUP_RESULT = 68;
|
||||
static constexpr int16_t SIMPLE_LOAD_VALUE = SIMPLE_LOAD_LOOKUP_RESULT-INT16_C(OFFSET_IGNITION);
|
||||
|
||||
static void __attribute__((noinline)) setup_test_mode_simple(config2 &, config10 &page10, statuses ¤t, table3d16RpmLoad &lookupTable, uint8_t mode) {
|
||||
page10.spark2Mode = mode;
|
||||
page10.spark2Algorithm = LOAD_SOURCE_MAP;
|
||||
current.advance1 = SIMPLE_ADVANCE1;
|
||||
current.advance = current.advance1;
|
||||
current.MAP = tempYAxis[0];
|
||||
current.RPM = tempXAxis[0];
|
||||
fill_table_values(lookupTable, SIMPLE_LOAD_LOOKUP_RESULT);
|
||||
populate_table_axis_P(lookupTable.axisX.begin(), tempXAxis);
|
||||
populate_table_axis_P(lookupTable.axisY.begin(), tempYAxis);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_mode_simple(uint8_t mode, int8_t expectedAdvance, int8_t expectedAdvance2) {
|
||||
config2 page2 = {};
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
|
||||
setup_test_mode_simple(page2, page10, current, lookupTable, mode);
|
||||
calculateSecondarySpark(page2, page10, lookupTable, current);
|
||||
assert_2nd_spark_is_on(current, SIMPLE_ADVANCE1, expectedAdvance2, expectedAdvance);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_multiply_cap_INT8_MAX(void) {
|
||||
test_mode_cap_INT8_MAX(SPARK2_MODE_MULTIPLY, CAP_LOAD_VALUE-INT8_MAX);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_multiply(uint8_t multiplier) {
|
||||
config2 page2 = {};
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
|
||||
setup_test_mode_simple(page2, page10, current, lookupTable, SPARK2_MODE_MULTIPLY);
|
||||
fill_table_values(lookupTable, multiplier+INT16_C(OFFSET_IGNITION));
|
||||
calculateSecondarySpark(page2, page10, lookupTable, current);
|
||||
assert_2nd_spark_is_on(current, SIMPLE_ADVANCE1, multiplier-INT8_MAX, DIV_ROUND_CLOSEST((SIMPLE_ADVANCE1*multiplier), 100, int16_t));
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_multiply_0(void) {
|
||||
test_sparkmode_multiply(0);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_multiply_50(void) {
|
||||
test_sparkmode_multiply(50);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_multiply_100(void) {
|
||||
test_sparkmode_multiply(100);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_multiply_150(void) {
|
||||
test_sparkmode_multiply(150);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_multiply_200(void) {
|
||||
test_sparkmode_multiply(200);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_multiply_215(void) {
|
||||
test_sparkmode_multiply(215);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_fixed_timing_no_secondary_spark(void) {
|
||||
config2 page2 = {};
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
|
||||
setup_test_mode_simple(page2, page10, current, lookupTable, SPARK2_MODE_MULTIPLY);
|
||||
page2.fixAngEnable = 1U;// Should turn 2nd table off
|
||||
calculateSecondarySpark(page2, page10, lookupTable, current);
|
||||
assert_2nd_spark_is_off(current, SIMPLE_ADVANCE1);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_cranking_no_secondary_spark(void) {
|
||||
config2 page2 = {};
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
|
||||
setup_test_mode_simple(page2, page10, current, lookupTable, SPARK2_MODE_MULTIPLY);
|
||||
BIT_SET(current.engine, BIT_ENGINE_CRANK);// Should turn 2nd table off
|
||||
calculateSecondarySpark(page2, page10, lookupTable, current);
|
||||
assert_2nd_spark_is_off(current, SIMPLE_ADVANCE1);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_add(void) {
|
||||
test_mode_simple(SPARK2_MODE_ADD, SIMPLE_ADVANCE1+SIMPLE_LOAD_VALUE, SIMPLE_LOAD_VALUE);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_add_cap_INT8_MAX(void) {
|
||||
test_mode_cap_INT8_MAX(SPARK2_MODE_ADD, (int16_t)150-INT16_C(OFFSET_IGNITION));
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) setup_test_mode_cond_switch(config2 &page2, config10 &page10, statuses ¤t, table3d16RpmLoad &lookupTable, uint8_t cond, uint16_t trigger) {
|
||||
setup_test_mode_simple(page2, page10, current, lookupTable, SPARK2_MODE_CONDITIONAL_SWITCH);
|
||||
page10.spark2SwitchVariable = cond;
|
||||
page10.spark2SwitchValue = trigger;
|
||||
current.MAP = 50; //Load source value
|
||||
current.RPM = 3500;
|
||||
current.TPS = 50;
|
||||
current.ethanolPct = 50;
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_cond_switch_negative(uint8_t cond, uint16_t trigger) {
|
||||
config2 page2 = {};
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
|
||||
setup_test_mode_cond_switch(page2, page10, current, lookupTable, cond, trigger);
|
||||
|
||||
calculateSecondarySpark(page2, page10, lookupTable, current);
|
||||
|
||||
assert_2nd_spark_is_off(current, SIMPLE_ADVANCE1);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_cond_switch_positive(uint8_t cond, uint16_t trigger) {
|
||||
config2 page2 = {};
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
|
||||
setup_test_mode_cond_switch(page2, page10, current, lookupTable, cond, trigger);
|
||||
|
||||
calculateSecondarySpark(page2, page10, lookupTable, current);
|
||||
|
||||
assert_2nd_spark_is_on(current, SIMPLE_ADVANCE1, SIMPLE_LOAD_VALUE, SIMPLE_LOAD_VALUE);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_cond_switch_rpm(void) {
|
||||
test_sparkmode_cond_switch_positive(SPARK2_CONDITION_RPM, 3499);
|
||||
test_sparkmode_cond_switch_negative(SPARK2_CONDITION_RPM, 3501);
|
||||
test_sparkmode_cond_switch_positive(SPARK2_CONDITION_RPM, 3499);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_cond_switch_tps(void) {
|
||||
test_sparkmode_cond_switch_positive(SPARK2_CONDITION_TPS, 49);
|
||||
test_sparkmode_cond_switch_negative(SPARK2_CONDITION_TPS, 51);
|
||||
test_sparkmode_cond_switch_positive(SPARK2_CONDITION_TPS, 49);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_cond_switch_map(void) {
|
||||
test_sparkmode_cond_switch_positive(SPARK2_CONDITION_MAP, 49);
|
||||
test_sparkmode_cond_switch_negative(SPARK2_CONDITION_MAP, 51);
|
||||
test_sparkmode_cond_switch_positive(SPARK2_CONDITION_MAP, 49);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_cond_switch_ethanol_pct(void) {
|
||||
test_sparkmode_cond_switch_positive(SPARK2_CONDITION_ETH, 49);
|
||||
test_sparkmode_cond_switch_negative(SPARK2_CONDITION_ETH, 51);
|
||||
test_sparkmode_cond_switch_positive(SPARK2_CONDITION_ETH, 49);
|
||||
}
|
||||
|
||||
static void __attribute__((noinline)) test_sparkmode_input_switch(void) {
|
||||
config2 page2 = {};
|
||||
config10 page10 = {};
|
||||
statuses current = {};
|
||||
table3d16RpmLoad lookupTable;
|
||||
|
||||
setup_test_mode_simple(page2, page10, current, lookupTable, SPARK2_MODE_INPUT_SWITCH);
|
||||
|
||||
page10.spark2InputPolarity = HIGH;
|
||||
pinSpark2Input = 3;
|
||||
pinMode(pinSpark2Input, OUTPUT);
|
||||
|
||||
// On
|
||||
digitalWrite(pinSpark2Input, page10.spark2InputPolarity);
|
||||
calculateSecondarySpark(page2, page10, lookupTable, current);
|
||||
assert_2nd_spark_is_on(current, SIMPLE_ADVANCE1, SIMPLE_LOAD_VALUE, SIMPLE_LOAD_VALUE);
|
||||
|
||||
// Off
|
||||
digitalWrite(pinSpark2Input, !page10.spark2InputPolarity);
|
||||
current.advance = current.advance1;
|
||||
calculateSecondarySpark(page2, page10, lookupTable, current);
|
||||
assert_2nd_spark_is_off(current, SIMPLE_ADVANCE1);
|
||||
|
||||
// On again
|
||||
digitalWrite(pinSpark2Input, page10.spark2InputPolarity);
|
||||
calculateSecondarySpark(page2, page10, lookupTable, current);
|
||||
assert_2nd_spark_is_on(current, SIMPLE_ADVANCE1, SIMPLE_LOAD_VALUE, SIMPLE_LOAD_VALUE);
|
||||
}
|
||||
|
||||
void test_calculateSecondarySpark(void)
|
||||
{
|
||||
SET_UNITY_FILENAME() {
|
||||
RUN_TEST(test_mode_off_no_secondary_spark);
|
||||
RUN_TEST(test_fixed_timing_no_secondary_spark);
|
||||
RUN_TEST(test_cranking_no_secondary_spark);
|
||||
RUN_TEST(test_sparkmode_multiply_0);
|
||||
RUN_TEST(test_sparkmode_multiply_50);
|
||||
RUN_TEST(test_sparkmode_multiply_100);
|
||||
RUN_TEST(test_sparkmode_multiply_150);
|
||||
RUN_TEST(test_sparkmode_multiply_200);
|
||||
RUN_TEST(test_sparkmode_multiply_215);
|
||||
RUN_TEST(test_sparkmode_multiply_cap_INT8_MAX);
|
||||
RUN_TEST(test_sparkmode_add);
|
||||
RUN_TEST(test_sparkmode_add_cap_INT8_MAX);
|
||||
RUN_TEST(test_sparkmode_cond_switch_rpm);
|
||||
RUN_TEST(test_sparkmode_cond_switch_tps);
|
||||
RUN_TEST(test_sparkmode_cond_switch_map);
|
||||
RUN_TEST(test_sparkmode_cond_switch_ethanol_pct);
|
||||
RUN_TEST(test_sparkmode_input_switch);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,5 +1,6 @@
|
|||
|
||||
#pragma once
|
||||
#include "table3d.h"
|
||||
|
||||
#include <stdint.h>
|
||||
#include <unity.h>
|
||||
|
|
@ -67,6 +68,39 @@ for ( UNITY_FILENAME_RESTORE, _ufname_done = ufname_set(__FILE__);
|
|||
#define TEST_DATA_P static constexpr
|
||||
#endif
|
||||
|
||||
template <typename table3d_t>
|
||||
static inline void fill_table_values(table3d_t &table, table3d_value_t value) {
|
||||
// for (uint8_t i=0; i<table.values.row_size*table.values.num_rows; ++i) {
|
||||
// table.values.values[i] = value;
|
||||
// }
|
||||
table_value_iterator itZ = table.values.begin();
|
||||
while (!itZ.at_end())
|
||||
{
|
||||
table_row_iterator itRow = *itZ;
|
||||
while (!itRow.at_end())
|
||||
{
|
||||
*itRow = value;
|
||||
++itRow;
|
||||
}
|
||||
++itZ;
|
||||
}
|
||||
invalidate_cache(&table.get_value_cache);
|
||||
}
|
||||
|
||||
static inline void populate_table_axis_P(table_axis_iterator it,
|
||||
const table3d_axis_t *pXValues) { // PROGMEM if available
|
||||
while (!it.at_end())
|
||||
{
|
||||
#if defined(PROGMEM)
|
||||
*it = (table3d_axis_t)pgm_read_word(pXValues);
|
||||
#else
|
||||
*it = *pXValues;
|
||||
#endif
|
||||
++pXValues;
|
||||
++it;
|
||||
}
|
||||
}
|
||||
|
||||
// Populate a 3d table (from PROGMEM if available)
|
||||
// You wuld typically declare the 3 source arrays usin TEST_DATA_P
|
||||
template <typename table3d_t>
|
||||
|
|
@ -75,32 +109,8 @@ static inline void populate_table_P(table3d_t &table,
|
|||
const table3d_axis_t *pYValues, // PROGMEM if available
|
||||
const table3d_value_t *pZValues) // PROGMEM if available
|
||||
{
|
||||
{
|
||||
table_axis_iterator itX = table.axisX.begin();
|
||||
while (!itX.at_end())
|
||||
{
|
||||
#if defined(PROGMEM)
|
||||
*itX = (table3d_axis_t)pgm_read_word(pXValues);
|
||||
#else
|
||||
*itX = *pXValues;
|
||||
#endif
|
||||
++pXValues;
|
||||
++itX;
|
||||
}
|
||||
}
|
||||
{
|
||||
table_axis_iterator itY = table.axisY.begin();
|
||||
while (!itY.at_end())
|
||||
{
|
||||
#if defined(PROGMEM)
|
||||
*itY = (table3d_axis_t)pgm_read_word(pYValues);
|
||||
#else
|
||||
*itY = *pYValues;
|
||||
#endif
|
||||
++pYValues;
|
||||
++itY;
|
||||
}
|
||||
}
|
||||
populate_table_axis_P(table.axisX.begin(), pXValues);
|
||||
populate_table_axis_P(table.axisY.begin(), pYValues);
|
||||
{
|
||||
table_value_iterator itZ = table.values.begin();
|
||||
while (!itZ.at_end())
|
||||
|
|
@ -121,7 +131,6 @@ static inline void populate_table_P(table3d_t &table,
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
// Populate a 2d table with constant values
|
||||
static inline void populate_2dtable(table2D *pTable, uint8_t value, uint8_t bin) {
|
||||
for (uint8_t index=0; index<pTable->xSize; ++index) {
|
||||
|
|
@ -149,4 +158,6 @@ static inline void populate_2dtable_P(table2D *pTable, const TValue values[], co
|
|||
#else
|
||||
populate_2dtable(pTable, values, bins)
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
void populateTable(table3d16RpmLoad &table, const table3d_value_t values[], const table3d_axis_t xAxis[], const table3d_axis_t yAxis[]);
|
||||
|
|
|
|||
Loading…
Reference in New Issue