andreika-git
/
rusefi
mirror of https://github.com/andreika-git/rusefi.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

auto-sync

This commit is contained in:
rusEfi 2014-11-07 23:07:22 -06:00
parent 06cc8915ef
commit 51a379a6b1
17 changed files with 154 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
firmware/console/status_loop.cpp
View File

@ -173,10 +173,10 @@ void printState(Engine *engine, int currentCkpEventCounter) {
debugFloat(&logger, "fuel_base", baseFuel, 2); debugFloat(&logger, "fuel_base", baseFuel, 2);
// debugFloat(&logger, "fuel_iat", getIatCorrection(getIntakeAirTemperature()), 2); // debugFloat(&logger, "fuel_iat", getIatCorrection(getIntakeAirTemperature()), 2);
// debugFloat(&logger, "fuel_clt", getCltCorrection(getCoolantTemperature()), 2); // debugFloat(&logger, "fuel_clt", getCltCorrection(getCoolantTemperature()), 2);
debugFloat(&logger, "fuel_lag", getInjectorLag(engineConfiguration, getVBatt(engineConfiguration)), 2); debugFloat(&logger, "fuel_lag", getInjectorLag(getVBatt(engineConfiguration) PASS_ENGINE_PARAMETER), 2);
debugFloat(&logger, "fuel", getFuelMs(rpm PASS_ENGINE_PARAMETER), 2); debugFloat(&logger, "fuel", getFuelMs(rpm PASS_ENGINE_PARAMETER), 2);
debugFloat(&logger, "timing", getAdvance(engineConfiguration, rpm, engineLoad), 2); debugFloat(&logger, "timing", getAdvance(rpm, engineLoad PASS_ENGINE_PARAMETER), 2);
// float map = getMap(); // float map = getMap();
@ -317,16 +317,16 @@ static void showFuelInfo2(float rpm, float engineLoad, Engine *engine) {
scheduleMsg(&logger2, "cranking fuel: %f", getCrankingFuel(engine)); scheduleMsg(&logger2, "cranking fuel: %f", getCrankingFuel(engine));
if (engine->rpmCalculator->isRunning()) { if (engine->rpmCalculator->isRunning()) {
float iatCorrection = getIatCorrection(engineConfiguration, getIntakeAirTemperature(engine)); float iatCorrection = getIatCorrection(getIntakeAirTemperature(engine) PASS_ENGINE_PARAMETER);
float cltCorrection = getCltCorrection(engineConfiguration, getCoolantTemperature(engine)); float cltCorrection = getCltCorrection(getCoolantTemperature(engine) PASS_ENGINE_PARAMETER);
float injectorLag = getInjectorLag(engineConfiguration, getVBatt(engineConfiguration)); float injectorLag = getInjectorLag(getVBatt(engineConfiguration) PASS_ENGINE_PARAMETER);
scheduleMsg(&logger2, "rpm=%f engineLoad=%f", rpm, engineLoad); scheduleMsg(&logger2, "rpm=%f engineLoad=%f", rpm, engineLoad);
scheduleMsg(&logger2, "baseFuel=%f", baseFuelMs); scheduleMsg(&logger2, "baseFuel=%f", baseFuelMs);
scheduleMsg(&logger2, "iatCorrection=%f cltCorrection=%f injectorLag=%f", iatCorrection, cltCorrection, scheduleMsg(&logger2, "iatCorrection=%f cltCorrection=%f injectorLag=%f", iatCorrection, cltCorrection,
injectorLag); injectorLag);
float value = getRunningFuel(baseFuelMs, engine, (int) rpm); float value = getRunningFuel(baseFuelMs, (int) rpm PASS_ENGINE_PARAMETER);
scheduleMsg(&logger2, "injection pulse width: %f", value); scheduleMsg(&logger2, "injection pulse width: %f", value);
} }
} }
@ -452,8 +452,8 @@ void updateTunerStudioState(Engine *engine, TunerStudioOutputChannels *tsOutputC
tsOutputChannels->isIatError = !isValidIntakeAirTemperature(getIntakeAirTemperature(engine)); tsOutputChannels->isIatError = !isValidIntakeAirTemperature(getIntakeAirTemperature(engine));
#endif #endif
tsOutputChannels->tCharge = getTCharge(rpm, tps, coolant, intake); tsOutputChannels->tCharge = getTCharge(rpm, tps, coolant, intake);
tsOutputChannels->sparkDwell = getSparkDwellMsT(engineConfiguration, rpm); tsOutputChannels->sparkDwell = getSparkDwellMsT(rpm PASS_ENGINE_PARAMETER);
tsOutputChannels->pulseWidthMs = getRunningFuel(baseFuelMs, engine, rpm); tsOutputChannels->pulseWidthMs = getRunningFuel(baseFuelMs, rpm PASS_ENGINE_PARAMETER);
tsOutputChannels->crankingFuelMs = getCrankingFuel(engine); tsOutputChannels->crankingFuelMs = getCrankingFuel(engine);
} }

2
firmware/console_util/datalogging.c
View File

@ -66,7 +66,7 @@ static bool intermediateLoggingBufferInited = FALSE;
/** /**
* @returns true if data does not fit into this buffer * @returns true if data does not fit into this buffer
*/ */
static bool validateBuffer(Logging *logging, uint32_t extraLen) { static INLINE bool validateBuffer(Logging *logging, uint32_t extraLen) {
if (logging->buffer == NULL) { if (logging->buffer == NULL) {
firmwareError("Logging not initialized: %s", logging->name); firmwareError("Logging not initialized: %s", logging->name);
return true; return true;

2
firmware/controllers/algo/advance_map.cpp
View File

@ -43,7 +43,7 @@ float getBaseAdvance(int rpm, float engineLoad) {
engineConfiguration->ignitionRpmBins); engineConfiguration->ignitionRpmBins);
} }
float getAdvance(engine_configuration_s *engineConfiguration, int rpm, float engineLoad) { float getAdvance(int rpm, float engineLoad DECLATE_ENGINE_PARAMETER) {
float angle; float angle;
if (isCrankingR(rpm)) { if (isCrankingR(rpm)) {
angle = engineConfiguration->crankingTimingAngle; angle = engineConfiguration->crankingTimingAngle;

4
firmware/controllers/algo/advance_map.h
View File

@ -11,9 +11,9 @@
#define AD_LOAD_COUNT 16 #define AD_LOAD_COUNT 16
#define AD_RPM_COUNT 16 #define AD_RPM_COUNT 16
#include "engine_configuration.h" #include "engine.h"
float getAdvance(engine_configuration_s *engineConfiguration, int rpm, float engineLoad); float getAdvance(int rpm, float engineLoad DECLATE_ENGINE_PARAMETER);
void prepareTimingMap(void); void prepareTimingMap(void);
#endif /* ADVANCE_H_ */ #endif /* ADVANCE_H_ */

15
firmware/controllers/algo/ec2.h
View File

@ -20,10 +20,10 @@ class FuelSchedule {
public: public:
ActuatorEventList events; ActuatorEventList events;
void addFuelEvents(engine_configuration_s const *e, trigger_shape_s *s, void addFuelEvents(trigger_shape_s *s,
injection_mode_e mode); injection_mode_e mode DECLATE_ENGINE_PARAMETER);
void registerInjectionEvent(engine_configuration_s const *e, trigger_shape_s *s, void registerInjectionEvent(trigger_shape_s *s,
io_pin_e pin, float angle); io_pin_e pin, float angle DECLATE_ENGINE_PARAMETER);
}; };
@ -51,13 +51,10 @@ public:
IgnitionEventList ignitionEvents[2]; IgnitionEventList ignitionEvents[2];
}; };
void initializeIgnitionActions(float advance, float dwellAngle, engine_configuration_s *engineConfiguration, void initializeIgnitionActions(float advance, float dwellAngle,
engine_configuration2_s *engineConfiguration2, IgnitionEventList *list); engine_configuration2_s *engineConfiguration2, IgnitionEventList *list DECLATE_ENGINE_PARAMETER);
void setDefaultNonPersistentConfiguration(engine_configuration2_s *engineConfiguration2); void setDefaultNonPersistentConfiguration(engine_configuration2_s *engineConfiguration2);
void printConfiguration(engine_configuration_s *engineConfiguration, engine_configuration2_s *engineConfiguration2); void printConfiguration(engine_configuration_s *engineConfiguration, engine_configuration2_s *engineConfiguration2);
void registerActuatorEventExt(engine_configuration_s const *engineConfiguration, trigger_shape_s * s, ActuatorEvent *e,
OutputSignal *actuator, float angleOffset);
#endif /* EC2_H_ */ #endif /* EC2_H_ */

4
firmware/controllers/algo/engine_configuration.cpp
View File

@ -578,8 +578,8 @@ void applyNonPersistentConfiguration(Logging * logger, Engine *engine) {
prepareOutputSignals(engine); prepareOutputSignals(engine);
// todo: looks like this is here only for unit tests. todo: remove // todo: looks like this is here only for unit tests. todo: remove
initializeIgnitionActions(0, 0, engineConfiguration, engineConfiguration2, initializeIgnitionActions(0, 0, engineConfiguration2,
&engineConfiguration2->ignitionEvents[0]); &engineConfiguration2->ignitionEvents[0] PASS_ENGINE_PARAMETER);
} }

17
firmware/controllers/algo/fuel_math.cpp
View File

@ -79,17 +79,16 @@ float getFuelMs(int rpm DECLATE_ENGINE_PARAMETER) {
theoreticalInjectionLength = getCrankingFuel(engine) / getNumberOfInjections(engineConfiguration, engineConfiguration->crankingInjectionMode); theoreticalInjectionLength = getCrankingFuel(engine) / getNumberOfInjections(engineConfiguration, engineConfiguration->crankingInjectionMode);
} else { } else {
float baseFuel = getBaseFuel(engine, rpm); float baseFuel = getBaseFuel(engine, rpm);
float fuelPerCycle = getRunningFuel(baseFuel, engine, rpm); float fuelPerCycle = getRunningFuel(baseFuel, rpm PASS_ENGINE_PARAMETER);
theoreticalInjectionLength = fuelPerCycle / getNumberOfInjections(engineConfiguration, engine->engineConfiguration->injectionMode); theoreticalInjectionLength = fuelPerCycle / getNumberOfInjections(engineConfiguration, engine->engineConfiguration->injectionMode);
} }
float injectorLag = getInjectorLag(engineConfiguration, getVBatt(engineConfiguration)); float injectorLag = getInjectorLag(getVBatt(engineConfiguration) PASS_ENGINE_PARAMETER);
return theoreticalInjectionLength + injectorLag; return theoreticalInjectionLength + injectorLag;
} }
float getRunningFuel(float baseFuelMs, Engine *engine, int rpm) { float getRunningFuel(float baseFuelMs, int rpm DECLATE_ENGINE_PARAMETER) {
engine_configuration_s *engineConfiguration = engine->engineConfiguration; float iatCorrection = getIatCorrection(getIntakeAirTemperature(engine) PASS_ENGINE_PARAMETER);
float iatCorrection = getIatCorrection(engineConfiguration, getIntakeAirTemperature(engine)); float cltCorrection = getCltCorrection(getCoolantTemperature(engine) PASS_ENGINE_PARAMETER);
float cltCorrection = getCltCorrection(engineConfiguration, getCoolantTemperature(engine));
#if EFI_ACCEL_ENRICHMENT #if EFI_ACCEL_ENRICHMENT
float accelEnrichment = getAccelEnrichment(); float accelEnrichment = getAccelEnrichment();
@ -106,7 +105,7 @@ static Map3D1616 fuelMap;
* @param vBatt Battery voltage. * @param vBatt Battery voltage.
* @return Time in ms for injection opening time based on current battery voltage * @return Time in ms for injection opening time based on current battery voltage
*/ */
float getInjectorLag(engine_configuration_s *engineConfiguration, float vBatt) { float getInjectorLag(float vBatt DECLATE_ENGINE_PARAMETER) {
if (cisnan(vBatt)) { if (cisnan(vBatt)) {
warning(OBD_System_Voltage_Malfunction, "vBatt=%f", vBatt); warning(OBD_System_Voltage_Malfunction, "vBatt=%f", vBatt);
return engineConfiguration->injectorLag; return engineConfiguration->injectorLag;
@ -128,13 +127,13 @@ void prepareFuelMap(engine_configuration_s *engineConfiguration) {
/** /**
* @brief Engine warm-up fuel correction. * @brief Engine warm-up fuel correction.
*/ */
float getCltCorrection(engine_configuration_s *engineConfiguration, float clt) { float getCltCorrection(float clt DECLATE_ENGINE_PARAMETER) {
if (cisnan(clt)) if (cisnan(clt))
return 1; // this error should be already reported somewhere else, let's just handle it return 1; // this error should be already reported somewhere else, let's just handle it
return interpolate2d(clt, engineConfiguration->cltFuelCorrBins, engineConfiguration->cltFuelCorr, CLT_CURVE_SIZE); return interpolate2d(clt, engineConfiguration->cltFuelCorrBins, engineConfiguration->cltFuelCorr, CLT_CURVE_SIZE);
} }
float getIatCorrection(engine_configuration_s *engineConfiguration, float iat) { float getIatCorrection(float iat DECLATE_ENGINE_PARAMETER) {
if (cisnan(iat)) if (cisnan(iat))
return 1; // this error should be already reported somewhere else, let's just handle it return 1; // this error should be already reported somewhere else, let's just handle it
return interpolate2d(iat, engineConfiguration->iatFuelCorrBins, engineConfiguration->iatFuelCorr, IAT_CURVE_SIZE); return interpolate2d(iat, engineConfiguration->iatFuelCorrBins, engineConfiguration->iatFuelCorr, IAT_CURVE_SIZE);

8
firmware/controllers/algo/fuel_math.h
View File

@ -14,10 +14,10 @@ void prepareFuelMap(engine_configuration_s *engineConfiguration);
float getBaseFuel(Engine *engine, int rpm); float getBaseFuel(Engine *engine, int rpm);
float getBaseTableFuel(engine_configuration_s *engineConfiguration, int rpm, float engineLoad); float getBaseTableFuel(engine_configuration_s *engineConfiguration, int rpm, float engineLoad);
float getIatCorrection(engine_configuration_s *engineConfiguration, float iat); float getIatCorrection(float iat DECLATE_ENGINE_PARAMETER);
float getInjectorLag(engine_configuration_s *engineConfiguration, float vBatt); float getInjectorLag(float vBatt DECLATE_ENGINE_PARAMETER);
float getCltCorrection(engine_configuration_s *engineConfiguration, float clt); float getCltCorrection(float clt DECLATE_ENGINE_PARAMETER);
float getRunningFuel(float baseFuel, Engine *engine, int rpm); float getRunningFuel(float baseFuel, int rpm DECLATE_ENGINE_PARAMETER);
float getCrankingFuel(Engine *engine); float getCrankingFuel(Engine *engine);
float getCrankingFuel3(engine_configuration_s *engineConfiguration, float coolantTemperature, uint32_t revolutionCounterSinceStart); float getCrankingFuel3(engine_configuration_s *engineConfiguration, float coolantTemperature, uint32_t revolutionCounterSinceStart);
float getFuelMs(int rpm DECLATE_ENGINE_PARAMETER); float getFuelMs(int rpm DECLATE_ENGINE_PARAMETER);

93
firmware/controllers/math/engine_math.cpp
View File

@ -30,6 +30,8 @@
#include "event_registry.h" #include "event_registry.h"
#include "efiGpio.h" #include "efiGpio.h"
EXTERN_ENGINE;
/* /*
* default Volumetric Efficiency * default Volumetric Efficiency
*/ */
@ -106,8 +108,8 @@ int isCrankingRT(engine_configuration_s *engineConfiguration, int rpm) {
OutputSignalList injectonSignals CCM_OPTIONAL OutputSignalList injectonSignals CCM_OPTIONAL
; ;
static void registerSparkEvent(engine_configuration_s const *engineConfiguration, trigger_shape_s * s, static void registerSparkEvent(trigger_shape_s * s,
IgnitionEventList *list, io_pin_e pin, float localAdvance, float dwell) { IgnitionEventList *list, io_pin_e pin, float localAdvance, float dwell DECLATE_ENGINE_PARAMETER) {
IgnitionEvent *event = list->getNextActuatorEvent(); IgnitionEvent *event = list->getNextActuatorEvent();
if (event == NULL) if (event == NULL)
@ -121,11 +123,11 @@ static void registerSparkEvent(engine_configuration_s const *engineConfiguration
event->advance = localAdvance; event->advance = localAdvance;
findTriggerPosition(engineConfiguration, s, &event->dwellPosition, localAdvance - dwell); findTriggerPosition(s, &event->dwellPosition, localAdvance - dwell PASS_ENGINE_PARAMETER);
} }
void initializeIgnitionActions(float advance, float dwellAngle, engine_configuration_s *engineConfiguration, void initializeIgnitionActions(float advance, float dwellAngle,
engine_configuration2_s *engineConfiguration2, IgnitionEventList *list) { engine_configuration2_s *engineConfiguration2, IgnitionEventList *list DECLATE_ENGINE_PARAMETER) {
efiAssertVoid(engineConfiguration->cylindersCount > 0, "cylindersCount"); efiAssertVoid(engineConfiguration->cylindersCount > 0, "cylindersCount");
@ -137,8 +139,8 @@ void initializeIgnitionActions(float advance, float dwellAngle, engine_configura
// todo: extract method // todo: extract method
float localAdvance = advance + 720.0f * i / engineConfiguration->cylindersCount; float localAdvance = advance + 720.0f * i / engineConfiguration->cylindersCount;
registerSparkEvent(engineConfiguration, &engineConfiguration2->triggerShape, list, SPARKOUT_1_OUTPUT, registerSparkEvent(&engineConfiguration2->triggerShape, list, SPARKOUT_1_OUTPUT,
localAdvance, dwellAngle); localAdvance, dwellAngle PASS_ENGINE_PARAMETER);
} }
break; break;
case IM_WASTED_SPARK: case IM_WASTED_SPARK:
@ -150,8 +152,8 @@ void initializeIgnitionActions(float advance, float dwellAngle, engine_configura
int id = getCylinderId(engineConfiguration->firingOrder, wastedIndex) - 1; int id = getCylinderId(engineConfiguration->firingOrder, wastedIndex) - 1;
io_pin_e ioPin = (io_pin_e) (SPARKOUT_1_OUTPUT + id); io_pin_e ioPin = (io_pin_e) (SPARKOUT_1_OUTPUT + id);
registerSparkEvent(engineConfiguration, &engineConfiguration2->triggerShape, list, ioPin, localAdvance, registerSparkEvent(&engineConfiguration2->triggerShape, list, ioPin, localAdvance,
dwellAngle); dwellAngle PASS_ENGINE_PARAMETER);
} }
@ -161,8 +163,8 @@ void initializeIgnitionActions(float advance, float dwellAngle, engine_configura
float localAdvance = advance + 720.0f * i / engineConfiguration->cylindersCount; float localAdvance = advance + 720.0f * i / engineConfiguration->cylindersCount;
io_pin_e pin = (io_pin_e) ((int) SPARKOUT_1_OUTPUT + getCylinderId(engineConfiguration->firingOrder, i) - 1); io_pin_e pin = (io_pin_e) ((int) SPARKOUT_1_OUTPUT + getCylinderId(engineConfiguration->firingOrder, i) - 1);
registerSparkEvent(engineConfiguration, &engineConfiguration2->triggerShape, list, pin, localAdvance, registerSparkEvent(&engineConfiguration2->triggerShape, list, pin, localAdvance,
dwellAngle); dwellAngle PASS_ENGINE_PARAMETER);
} }
break; break;
@ -171,8 +173,16 @@ void initializeIgnitionActions(float advance, float dwellAngle, engine_configura
} }
} }
void FuelSchedule::registerInjectionEvent(engine_configuration_s const *e, trigger_shape_s *s, static void registerActuatorEventExt(trigger_shape_s * s, ActuatorEvent *ev,
io_pin_e pin, float angle) { OutputSignal *actuator, float angle DECLATE_ENGINE_PARAMETER) {
findTriggerPosition(s, &ev->position, angle PASS_ENGINE_PARAMETER);
}
void FuelSchedule::registerInjectionEvent(trigger_shape_s *s,
io_pin_e pin, float angle DECLATE_ENGINE_PARAMETER) {
ActuatorEventList *list = &events; ActuatorEventList *list = &events;
if (!isPinAssigned(pin)) { if (!isPinAssigned(pin)) {
@ -191,47 +201,47 @@ void FuelSchedule::registerInjectionEvent(engine_configuration_s const *e, trigg
} }
ev->actuator = actuator; ev->actuator = actuator;
registerActuatorEventExt(e, s, ev, actuator, angle); registerActuatorEventExt(s, ev, actuator, angle PASS_ENGINE_PARAMETER);
} }
void FuelSchedule::addFuelEvents(engine_configuration_s const *e, trigger_shape_s *s, void FuelSchedule::addFuelEvents(trigger_shape_s *s,
injection_mode_e mode) { injection_mode_e mode DECLATE_ENGINE_PARAMETER) {
ActuatorEventList *list = &events; ActuatorEventList *list = &events;
; ;
list->resetEventList(); list->resetEventList();
float baseAngle = e->globalTriggerAngleOffset + e->injectionOffset; float baseAngle = engineConfiguration->globalTriggerAngleOffset + engineConfiguration->injectionOffset;
switch (mode) { switch (mode) {
case IM_SEQUENTIAL: case IM_SEQUENTIAL:
for (int i = 0; i < e->cylindersCount; i++) { for (int i = 0; i < engineConfiguration->cylindersCount; i++) {
io_pin_e pin = (io_pin_e) ((int) INJECTOR_1_OUTPUT + getCylinderId(e->firingOrder, i) - 1); io_pin_e pin = (io_pin_e) ((int) INJECTOR_1_OUTPUT + getCylinderId(engineConfiguration->firingOrder, i) - 1);
float angle = baseAngle + i * 720.0 / e->cylindersCount; float angle = baseAngle + i * 720.0 / engineConfiguration->cylindersCount;
registerInjectionEvent(e, s, pin, angle); registerInjectionEvent(s, pin, angle PASS_ENGINE_PARAMETER);
} }
break; break;
case IM_SIMULTANEOUS: case IM_SIMULTANEOUS:
for (int i = 0; i < e->cylindersCount; i++) { for (int i = 0; i < engineConfiguration->cylindersCount; i++) {
float angle = baseAngle + i * 720.0 / e->cylindersCount; float angle = baseAngle + i * 720.0 / engineConfiguration->cylindersCount;
for (int j = 0; j < e->cylindersCount; j++) { for (int j = 0; j < engineConfiguration->cylindersCount; j++) {
io_pin_e pin = (io_pin_e) ((int) INJECTOR_1_OUTPUT + j); io_pin_e pin = (io_pin_e) ((int) INJECTOR_1_OUTPUT + j);
registerInjectionEvent(e, s, pin, angle); registerInjectionEvent(s, pin, angle PASS_ENGINE_PARAMETER);
} }
} }
break; break;
case IM_BATCH: case IM_BATCH:
for (int i = 0; i < e->cylindersCount; i++) { for (int i = 0; i < engineConfiguration->cylindersCount; i++) {
int index = i % (e->cylindersCount / 2); int index = i % (engineConfiguration->cylindersCount / 2);
io_pin_e pin = (io_pin_e) ((int) INJECTOR_1_OUTPUT + index); io_pin_e pin = (io_pin_e) ((int) INJECTOR_1_OUTPUT + index);
float angle = baseAngle + i * 720.0 / e->cylindersCount; float angle = baseAngle + i * 720.0 / engineConfiguration->cylindersCount;
registerInjectionEvent(e, s, pin, angle); registerInjectionEvent(s, pin, angle PASS_ENGINE_PARAMETER);
/** /**
* also fire the 2nd half of the injectors so that we can implement a batch mode on individual wires * also fire the 2nd half of the injectors so that we can implement a batch mode on individual wires
*/ */
pin = (io_pin_e) ((int) INJECTOR_1_OUTPUT + index + (e->cylindersCount / 2)); pin = (io_pin_e) ((int) INJECTOR_1_OUTPUT + index + (engineConfiguration->cylindersCount / 2));
registerInjectionEvent(e, s, pin, angle); registerInjectionEvent(s, pin, angle PASS_ENGINE_PARAMETER);
} }
break; break;
default: default:
@ -242,7 +252,7 @@ void FuelSchedule::addFuelEvents(engine_configuration_s const *e, trigger_shape_
/** /**
* @return Spark dwell time, in milliseconds. * @return Spark dwell time, in milliseconds.
*/ */
float getSparkDwellMsT(engine_configuration_s *engineConfiguration, int rpm) { float getSparkDwellMsT(int rpm DECLATE_ENGINE_PARAMETER) {
if (isCrankingR(rpm)) { if (isCrankingR(rpm)) {
if(engineConfiguration->useConstantDwellDuringCranking) { if(engineConfiguration->useConstantDwellDuringCranking) {
return engineConfiguration->ignitionDwellForCrankingMs; return engineConfiguration->ignitionDwellForCrankingMs;
@ -269,8 +279,8 @@ int getEngineCycleEventCount(engine_configuration_s const *engineConfiguration,
return getEngineCycleEventCount2(getOperationMode(engineConfiguration), s); return getEngineCycleEventCount2(getOperationMode(engineConfiguration), s);
} }
void findTriggerPosition(engine_configuration_s const *engineConfiguration, trigger_shape_s * s, void findTriggerPosition(trigger_shape_s * s,
event_trigger_position_s *position, float angleOffset) { event_trigger_position_s *position, float angleOffset DECLATE_ENGINE_PARAMETER) {
angleOffset = fixAngle(engineConfiguration, angleOffset + engineConfiguration->globalTriggerAngleOffset); angleOffset = fixAngle(engineConfiguration, angleOffset + engineConfiguration->globalTriggerAngleOffset);
@ -315,13 +325,6 @@ void findTriggerPosition(engine_configuration_s const *engineConfiguration, trig
position->angleOffset = angleOffset - eventAngle; position->angleOffset = angleOffset - eventAngle;
} }
void registerActuatorEventExt(engine_configuration_s const *e, trigger_shape_s * s, ActuatorEvent *ev,
OutputSignal *actuator, float angle) {
findTriggerPosition(e, s, &ev->position, angle);
}
static int order_1_THEN_3_THEN_4_THEN2[] = { 1, 3, 4, 2 }; static int order_1_THEN_3_THEN_4_THEN2[] = { 1, 3, 4, 2 };
static int order_1_THEN_5_THEN_3_THEN_6_THEN_2_THEN_4[] = { 1, 5, 3, 6, 2, 4 }; static int order_1_THEN_5_THEN_3_THEN_6_THEN_2_THEN_4[] = { 1, 5, 3, 6, 2, 4 };
@ -361,10 +364,10 @@ engine_configuration2_s *engineConfiguration2 = engine->engineConfiguration2;
trigger_shape_s * ts = &engineConfiguration2->triggerShape; trigger_shape_s * ts = &engineConfiguration2->triggerShape;
injectonSignals.clear(); injectonSignals.clear();
engineConfiguration2->crankingInjectionEvents.addFuelEvents(engineConfiguration, ts, engineConfiguration2->crankingInjectionEvents.addFuelEvents(ts,
engineConfiguration->crankingInjectionMode); engineConfiguration->crankingInjectionMode PASS_ENGINE_PARAMETER);
engineConfiguration2->injectionEvents.addFuelEvents(engineConfiguration, ts, engineConfiguration2->injectionEvents.addFuelEvents(ts,
engineConfiguration->injectionMode); engineConfiguration->injectionMode PASS_ENGINE_PARAMETER);
} }
void setFuelRpmBin(engine_configuration_s *engineConfiguration, float l, float r) { void setFuelRpmBin(engine_configuration_s *engineConfiguration, float l, float r) {

7
firmware/controllers/math/engine_math.h
View File

@ -11,13 +11,14 @@
#include "engine_configuration.h" #include "engine_configuration.h"
#ifdef __cplusplus #ifdef __cplusplus
#include "ec2.h" #include "ec2.h"
#include "trigger_structure.h" #include "trigger_structure.h"
#include "table_helper.h" #include "table_helper.h"
#include "engine.h" #include "engine.h"
void findTriggerPosition(engine_configuration_s const *engineConfiguration, trigger_shape_s * s, void findTriggerPosition(trigger_shape_s * s,
event_trigger_position_s *position, float angleOffset); event_trigger_position_s *position, float angleOffset DECLATE_ENGINE_PARAMETER);
int isInjectionEnabled(engine_configuration_s *engineConfiguration); int isInjectionEnabled(engine_configuration_s *engineConfiguration);
@ -56,7 +57,7 @@ int isCrankingRT(engine_configuration_s *engineConfiguration, int rpm);
float getEngineLoadT(Engine *engine); float getEngineLoadT(Engine *engine);
#define getEngineLoad() getEngineLoadT(engine) #define getEngineLoad() getEngineLoadT(engine)
float getSparkDwellMsT(engine_configuration_s *engineConfiguration, int rpm); float getSparkDwellMsT(int rpm DECLATE_ENGINE_PARAMETER);
int getCylinderId(firing_order_e firingOrder, int index); int getCylinderId(firing_order_e firingOrder, int index);

2
firmware/controllers/system/event_queue.cpp
View File

@ -27,7 +27,7 @@ void EventQueue::insertTask(scheduling_s *scheduling, uint64_t timeUs, schfunc_t
firmwareError("NULL callback"); firmwareError("NULL callback");
int alreadyPending = checkIfPending(scheduling); int alreadyPending = checkIfPending(scheduling);
if (alreadyPending || hasFirmwareError()) if (alreadyPending)
return; return;
scheduling->momentUs = timeUs; scheduling->momentUs = timeUs;

34
firmware/controllers/trigger/main_trigger_callback.cpp
View File

@ -81,8 +81,7 @@ static INLINE void handleFuelInjectionEvent(ActuatorEvent *event, int rpm DECLAT
/** /**
* todo: we do not really need to calculate fuel for each individual cylinder * todo: we do not really need to calculate fuel for each individual cylinder
*/ */
float fuelMs = getFuelMs(rpm PASS_ENGINE_PARAMETER) float fuelMs = getFuelMs(rpm PASS_ENGINE_PARAMETER) * engineConfiguration->globalFuelCorrection;
* engineConfiguration->globalFuelCorrection;
if (cisnan(fuelMs)) { if (cisnan(fuelMs)) {
warning(OBD_PCM_Processor_Fault, "NaN injection pulse"); warning(OBD_PCM_Processor_Fault, "NaN injection pulse");
return; return;
@ -132,7 +131,7 @@ static INLINE void handleSparkEvent(uint32_t eventIndex, IgnitionEvent *iEvent,
int rpm DECLATE_ENGINE_PARAMETER) { int rpm DECLATE_ENGINE_PARAMETER) {
engine_configuration2_s *engineConfiguration2 = engine->engineConfiguration2; engine_configuration2_s *engineConfiguration2 = engine->engineConfiguration2;
float dwellMs = getSparkDwellMsT(engineConfiguration, rpm); float dwellMs = getSparkDwellMsT(rpm PASS_ENGINE_PARAMETER);
if (cisnan(dwellMs) || dwellMs < 0) { if (cisnan(dwellMs) || dwellMs < 0) {
firmwareError("invalid dwell: %f at %d", dwellMs, rpm); firmwareError("invalid dwell: %f at %d", dwellMs, rpm);
return; return;
@ -170,8 +169,8 @@ static INLINE void handleSparkEvent(uint32_t eventIndex, IgnitionEvent *iEvent,
* TODO: improve precision * TODO: improve precision
*/ */
findTriggerPosition(engineConfiguration, &engineConfiguration2->triggerShape, &iEvent->sparkPosition, findTriggerPosition(&engineConfiguration2->triggerShape, &iEvent->sparkPosition,
iEvent->advance); iEvent->advance PASS_ENGINE_PARAMETER);
if (iEvent->sparkPosition.eventIndex == eventIndex) { if (iEvent->sparkPosition.eventIndex == eventIndex) {
/** /**
@ -240,12 +239,23 @@ void showMainHistogram(void) {
* Both injection and ignition are controlled from this method. * Both injection and ignition are controlled from this method.
*/ */
void onTriggerEvent(trigger_event_e ckpSignalType, uint32_t eventIndex, MainTriggerCallback *mtc) { void onTriggerEvent(trigger_event_e ckpSignalType, uint32_t eventIndex, MainTriggerCallback *mtc) {
if(hasFirmwareError()) {
/**
* In case on a major error we should not process any more events.
* TODO: add 'pin shutdown' invocation somewhere
*/
return;
}
Engine *engine = mtc->engine; Engine *engine = mtc->engine;
(void) ckpSignalType; (void) ckpSignalType;
efiAssertVoid(eventIndex < 2 * engine->engineConfiguration2->triggerShape.shaftPositionEventCount, efiAssertVoid(eventIndex < 2 * engine->engineConfiguration2->triggerShape.shaftPositionEventCount,
"event index"); "event index");
efiAssertVoid(getRemainingStack(chThdSelf()) > 64, "lowstck#2"); efiAssertVoid(getRemainingStack(chThdSelf()) > 64, "lowstck#2");
// todo: remove these local variables soon?
engine_configuration_s *engineConfiguration = engine->engineConfiguration;
int rpm = getRpmE(engine); int rpm = getRpmE(engine);
if (rpm == 0) { if (rpm == 0) {
// this happens while we just start cranking // this happens while we just start cranking
@ -283,12 +293,12 @@ void onTriggerEvent(trigger_event_e ckpSignalType, uint32_t eventIndex, MainTrig
* Within one engine cycle all cylinders are fired with same timing advance. * Within one engine cycle all cylinders are fired with same timing advance.
* todo: one day we can control cylinders individually * todo: one day we can control cylinders individually
*/ */
float dwellMs = getSparkDwellMsT(engine->engineConfiguration, rpm); float dwellMs = getSparkDwellMsT(rpm PASS_ENGINE_PARAMETER);
if (cisnan(dwellMs) || dwellMs < 0) { if (cisnan(dwellMs) || dwellMs < 0) {
firmwareError("invalid dwell: %f at %d", dwellMs, rpm); firmwareError("invalid dwell: %f at %d", dwellMs, rpm);
return; return;
} }
float advance = getAdvance(engine->engineConfiguration, rpm, getEngineLoadT(engine)); float advance = getAdvance(rpm, getEngineLoadT(engine) PASS_ENGINE_PARAMETER);
if (cisnan(advance)) { if (cisnan(advance)) {
// error should already be reported // error should already be reported
return; return;
@ -296,17 +306,13 @@ void onTriggerEvent(trigger_event_e ckpSignalType, uint32_t eventIndex, MainTrig
float dwellAngle = dwellMs / getOneDegreeTimeMs(rpm); float dwellAngle = dwellMs / getOneDegreeTimeMs(rpm);
initializeIgnitionActions(advance, dwellAngle, engine->engineConfiguration, initializeIgnitionActions(advance, dwellAngle,
engine->engineConfiguration2, engine->engineConfiguration2,
&engine->engineConfiguration2->ignitionEvents[revolutionIndex]); &engine->engineConfiguration2->ignitionEvents[revolutionIndex] PASS_ENGINE_PARAMETER);
} }
triggerEventsQueue.executeAll(getCrankEventCounter()); triggerEventsQueue.executeAll(getCrankEventCounter());
// todo: remove these local variables soon
engine_configuration_s *engineConfiguration = engine->engineConfiguration;
handleFuel(eventIndex, rpm PASS_ENGINE_PARAMETER); handleFuel(eventIndex, rpm PASS_ENGINE_PARAMETER);
handleSpark(eventIndex, rpm, handleSpark(eventIndex, rpm,
&engine->engineConfiguration2->ignitionEvents[revolutionIndex] PASS_ENGINE_PARAMETER); &engine->engineConfiguration2->ignitionEvents[revolutionIndex] PASS_ENGINE_PARAMETER);
@ -338,7 +344,7 @@ static void showMainInfo(Engine *engine) {
#if EFI_PROD_CODE #if EFI_PROD_CODE
scheduleMsg(&logger, "rpm %d engine_load %f", rpm, el); scheduleMsg(&logger, "rpm %d engine_load %f", rpm, el);
scheduleMsg(&logger, "fuel %fms timing %f", getFuelMs(rpm PASS_ENGINE_PARAMETER), scheduleMsg(&logger, "fuel %fms timing %f", getFuelMs(rpm PASS_ENGINE_PARAMETER),
getAdvance(mainTriggerCallbackInstance.engine->engineConfiguration, rpm, el)); getAdvance(rpm, el PASS_ENGINE_PARAMETER));
#endif #endif
} }

1
firmware/rusefi.cpp
View File

@ -230,6 +230,7 @@ void chDbgStackOverflowPanic(Thread *otp) {
chDbgPanic3(panicMessage, __FILE__, __LINE__); chDbgPanic3(panicMessage, __FILE__, __LINE__);
} }
// todo: make this a macro, noone can trust these compilers
bool hasFirmwareError(void) { bool hasFirmwareError(void) {
return hasFirmwareErrorFlag; return hasFirmwareErrorFlag;
} }

4
unit_tests/global.h
View File

@ -34,6 +34,10 @@ typedef void * Logging;
#define EXTERN_ENGINE #define EXTERN_ENGINE
#ifdef __cplusplus
class Engine;
#endif
#define DECLATE_ENGINE_PARAMETER , Engine *engine, engine_configuration_s *engineConfiguration #define DECLATE_ENGINE_PARAMETER , Engine *engine, engine_configuration_s *engineConfiguration
#define PASS_ENGINE_PARAMETER , engine, engineConfiguration #define PASS_ENGINE_PARAMETER , engine, engineConfiguration

4
unit_tests/test_basic_math/test_find_index.cpp
View File

@ -1,12 +1,12 @@
/* /*
* test_find_index.c * test_find_index.cpp
* *
* Created on: Oct 30, 2013 * Created on: Oct 30, 2013
* Author: Andrey Belomutskiy, (c) 2012-2013 * Author: Andrey Belomutskiy, (c) 2012-2013
*/ */
#include "engine_math.h"
#include "main.h" #include "main.h"
#include "engine_math.h"
#include "interpolation.h" #include "interpolation.h"
#include <stdio.h> #include <stdio.h>
#include "engine_configuration.h" #include "engine_configuration.h"

7
unit_tests/test_fuel_map.cpp
View File

@ -151,6 +151,8 @@ static ActuatorEventList ae;
void testAngleResolver(void) { void testAngleResolver(void) {
printf("*************************************************** testAngleResolver\r\n"); printf("*************************************************** testAngleResolver\r\n");
Engine *engine = NULL;
engineConfiguration->globalTriggerAngleOffset = 175; engineConfiguration->globalTriggerAngleOffset = 175;
trigger_shape_s * ts = &engineConfiguration2->triggerShape; trigger_shape_s * ts = &engineConfiguration2->triggerShape;
@ -171,15 +173,14 @@ void testAngleResolver(void) {
ae.resetEventList(); ae.resetEventList();
printf("*************************************************** testAngleResolver 0\r\n"); printf("*************************************************** testAngleResolver 0\r\n");
registerActuatorEventExt(engineConfiguration, &engineConfiguration2->triggerShape, ae.getNextActuatorEvent(), list.add(INJECTOR_1_OUTPUT), 53 - 175); findTriggerPosition(&engineConfiguration2->triggerShape, &ae.getNextActuatorEvent()->position, 53 - 175 PASS_ENGINE_PARAMETER);
assertEqualsM("size", 1, ae.size); assertEqualsM("size", 1, ae.size);
assertEquals(1, list.getSize());
assertEquals(0, ae.events[0].position.eventIndex); assertEquals(0, ae.events[0].position.eventIndex);
assertEquals(53, ae.events[0].position.angleOffset); assertEquals(53, ae.events[0].position.angleOffset);
printf("*************************************************** testAngleResolver 2\r\n"); printf("*************************************************** testAngleResolver 2\r\n");
ae.resetEventList(); ae.resetEventList();
registerActuatorEventExt(engineConfiguration, &engineConfiguration2->triggerShape, ae.getNextActuatorEvent(), list.add(INJECTOR_1_OUTPUT), 51 + 180 - 175); findTriggerPosition(&engineConfiguration2->triggerShape, &ae.getNextActuatorEvent()->position, 51 + 180 - 175 PASS_ENGINE_PARAMETER);
assertEquals(2, ae.events[0].position.eventIndex); assertEquals(2, ae.events[0].position.eventIndex);
assertEquals(109.1, ae.events[0].position.angleOffset); assertEquals(109.1, ae.events[0].position.angleOffset);
} }

72
unit_tests/test_trigger_decoder.cpp
View File

@ -118,21 +118,22 @@ static void test1995FordInline6TriggerDecoder(void) {
EngineTestHelper eth(FORD_INLINE_6_1995); EngineTestHelper eth(FORD_INLINE_6_1995);
engine_configuration_s *ec = eth.ec; engine_configuration_s *engineConfiguration = eth.engine.engineConfiguration;
Engine *engine = &eth.engine;
resetConfigurationExt(NULL, FORD_INLINE_6_1995, &eth.engine); resetConfigurationExt(NULL, FORD_INLINE_6_1995, &eth.engine);
assertEqualsM("triggerShapeSynchPointIndex", 0, eth.ec2.triggerShape.getTriggerShapeSynchPointIndex()); assertEqualsM("triggerShapeSynchPointIndex", 0, eth.ec2.triggerShape.getTriggerShapeSynchPointIndex());
trigger_shape_s * shape = &eth.ec2.triggerShape; trigger_shape_s * shape = &eth.ec2.triggerShape;
event_trigger_position_s position; event_trigger_position_s position;
assertEqualsM("globalTriggerAngleOffset", 0, ec->globalTriggerAngleOffset); assertEqualsM("globalTriggerAngleOffset", 0, engineConfiguration->globalTriggerAngleOffset);
findTriggerPosition(ec, shape, &position, 0); findTriggerPosition(shape, &position, 0 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 0, 0); assertTriggerPosition(&position, 0, 0);
findTriggerPosition(ec, shape, &position, 200); findTriggerPosition(shape, &position, 200 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 3, 20); assertTriggerPosition(&position, 3, 20);
findTriggerPosition(ec, shape, &position, 360); findTriggerPosition(shape, &position, 360 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 6, 0); assertTriggerPosition(&position, 6, 0);
@ -148,31 +149,31 @@ static void test1995FordInline6TriggerDecoder(void) {
assertFalseM("shaft_is_synchronized", state.shaft_is_synchronized); assertFalseM("shaft_is_synchronized", state.shaft_is_synchronized);
int r = 10; int r = 10;
state.decodeTriggerEvent(shape, &ec->triggerConfig, SHAFT_PRIMARY_DOWN, r); state.decodeTriggerEvent(shape, &engineConfiguration->triggerConfig, SHAFT_PRIMARY_DOWN, r);
assertFalseM("shaft_is_synchronized", state.shaft_is_synchronized); // still no synchronization assertFalseM("shaft_is_synchronized", state.shaft_is_synchronized); // still no synchronization
state.decodeTriggerEvent(shape, &ec->triggerConfig, SHAFT_PRIMARY_UP, ++r); state.decodeTriggerEvent(shape, &engineConfiguration->triggerConfig, SHAFT_PRIMARY_UP, ++r);
assertTrue(state.shaft_is_synchronized); // first signal rise synchronize assertTrue(state.shaft_is_synchronized); // first signal rise synchronize
assertEquals(0, state.getCurrentIndex()); assertEquals(0, state.getCurrentIndex());
state.decodeTriggerEvent(shape, &ec->triggerConfig, SHAFT_PRIMARY_DOWN, r++); state.decodeTriggerEvent(shape, &engineConfiguration->triggerConfig, SHAFT_PRIMARY_DOWN, r++);
assertEquals(1, state.getCurrentIndex()); assertEquals(1, state.getCurrentIndex());
for (int i = 2; i < 10;) { for (int i = 2; i < 10;) {
state.decodeTriggerEvent(shape, &ec->triggerConfig, SHAFT_PRIMARY_UP, r++); state.decodeTriggerEvent(shape, &engineConfiguration->triggerConfig, SHAFT_PRIMARY_UP, r++);
assertEqualsM("even", i++, state.getCurrentIndex()); assertEqualsM("even", i++, state.getCurrentIndex());
state.decodeTriggerEvent(shape, &ec->triggerConfig, SHAFT_PRIMARY_DOWN, r++); state.decodeTriggerEvent(shape, &engineConfiguration->triggerConfig, SHAFT_PRIMARY_DOWN, r++);
assertEqualsM("odd", i++, state.getCurrentIndex()); assertEqualsM("odd", i++, state.getCurrentIndex());
} }
state.decodeTriggerEvent(shape, &ec->triggerConfig, SHAFT_PRIMARY_UP, r++); state.decodeTriggerEvent(shape, &engineConfiguration->triggerConfig, SHAFT_PRIMARY_UP, r++);
assertEquals(10, state.getCurrentIndex()); assertEquals(10, state.getCurrentIndex());
state.decodeTriggerEvent(shape, &ec->triggerConfig, SHAFT_PRIMARY_DOWN, r++); state.decodeTriggerEvent(shape, &engineConfiguration->triggerConfig, SHAFT_PRIMARY_DOWN, r++);
assertEquals(11, state.getCurrentIndex()); assertEquals(11, state.getCurrentIndex());
state.decodeTriggerEvent(shape, &ec->triggerConfig, SHAFT_PRIMARY_UP, r++); state.decodeTriggerEvent(shape, &engineConfiguration->triggerConfig, SHAFT_PRIMARY_UP, r++);
assertEquals(0, state.getCurrentIndex()); // new revolution assertEquals(0, state.getCurrentIndex()); // new revolution
assertEqualsM("running dwell", 0.5, getSparkDwellMsT(ec, 2000)); assertEqualsM("running dwell", 0.5, getSparkDwellMsT(2000 PASS_ENGINE_PARAMETER));
} }
void testFordAspire(void) { void testFordAspire(void) {
@ -182,20 +183,21 @@ void testFordAspire(void) {
EngineTestHelper eth(FORD_ASPIRE_1996); EngineTestHelper eth(FORD_ASPIRE_1996);
engine_configuration_s *ec = eth.ec; Engine *engine = &eth.engine;
resetConfigurationExt(NULL, FORD_ASPIRE_1996, &eth.engine); engine_configuration_s *engineConfiguration = eth.ec;
resetConfigurationExt(NULL, FORD_ASPIRE_1996, engine);
assertEquals(4, eth.ec2.triggerShape.getTriggerShapeSynchPointIndex()); assertEquals(4, eth.ec2.triggerShape.getTriggerShapeSynchPointIndex());
assertEquals(800, ec->fuelRpmBins[0]); assertEquals(800, engineConfiguration->fuelRpmBins[0]);
assertEquals(7000, ec->fuelRpmBins[15]); assertEquals(7000, engineConfiguration->fuelRpmBins[15]);
ec->crankingChargeAngle = 65; engineConfiguration->crankingChargeAngle = 65;
ec->crankingTimingAngle = 31; engineConfiguration->crankingTimingAngle = 31;
assertEqualsM("cranking dwell", 54.166670, getSparkDwellMsT(ec, 200)); assertEqualsM("cranking dwell", 54.166670, getSparkDwellMsT(200 PASS_ENGINE_PARAMETER));
assertEqualsM("running dwell", 4, getSparkDwellMsT(ec, 2000)); assertEqualsM("running dwell", 4, getSparkDwellMsT(2000 PASS_ENGINE_PARAMETER));
assertEqualsM("higher rpm dwell", 3.25, getSparkDwellMsT(ec, 6000)); assertEqualsM("higher rpm dwell", 3.25, getSparkDwellMsT(6000 PASS_ENGINE_PARAMETER));
} }
void testMazda323(void) { void testMazda323(void) {
@ -213,6 +215,8 @@ void testMazdaMianaNbDecoder(void) {
EngineTestHelper eth(MAZDA_MIATA_NB); EngineTestHelper eth(MAZDA_MIATA_NB);
engine_configuration_s *ec = eth.ec; engine_configuration_s *ec = eth.ec;
Engine *engine = &eth.engine;
engine_configuration_s *engineConfiguration = ec;
resetConfigurationExt(NULL, MAZDA_MIATA_NB, &eth.engine); resetConfigurationExt(NULL, MAZDA_MIATA_NB, &eth.engine);
assertEquals(11, eth.ec2.triggerShape.getTriggerShapeSynchPointIndex()); assertEquals(11, eth.ec2.triggerShape.getTriggerShapeSynchPointIndex());
@ -256,39 +260,39 @@ void testMazdaMianaNbDecoder(void) {
event_trigger_position_s position; event_trigger_position_s position;
assertEqualsM("globalTriggerAngleOffset", 276, ec->globalTriggerAngleOffset); assertEqualsM("globalTriggerAngleOffset", 276, ec->globalTriggerAngleOffset);
findTriggerPosition(ec, shape, &position, 0); findTriggerPosition(shape, &position, 0 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 7, 46); assertTriggerPosition(&position, 7, 46);
findTriggerPosition(ec, shape, &position, 180); findTriggerPosition(shape, &position, 180 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 13, 46); assertTriggerPosition(&position, 13, 46);
findTriggerPosition(ec, shape, &position, 360); findTriggerPosition(shape, &position, 360 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 17, 46); assertTriggerPosition(&position, 17, 46);
findTriggerPosition(ec, shape, &position, 444); findTriggerPosition(shape, &position, 444 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 0, 0); assertTriggerPosition(&position, 0, 0);
findTriggerPosition(ec, shape, &position, 444.1); findTriggerPosition(shape, &position, 444.1 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 0, 0.1); assertTriggerPosition(&position, 0, 0.1);
findTriggerPosition(ec, shape, &position, 445); findTriggerPosition(shape, &position, 445 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 0, 1); assertTriggerPosition(&position, 0, 1);
findTriggerPosition(ec, shape, &position, 494); findTriggerPosition(shape, &position, 494 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 3, 0); assertTriggerPosition(&position, 3, 0);
findTriggerPosition(ec, shape, &position, 719); findTriggerPosition(shape, &position, 719 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 7, 45); assertTriggerPosition(&position, 7, 45);
ec->globalTriggerAngleOffset = 0; ec->globalTriggerAngleOffset = 0;
findTriggerPosition(ec, shape, &position, 0); findTriggerPosition(shape, &position, 0 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 0, 0); assertTriggerPosition(&position, 0, 0);
ec->globalTriggerAngleOffset = 10; ec->globalTriggerAngleOffset = 10;
findTriggerPosition(ec, shape, &position, 0); findTriggerPosition(shape, &position, 0 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 0, 10); assertTriggerPosition(&position, 0, 10);
findTriggerPosition(ec, shape, &position, -10); findTriggerPosition(shape, &position, -10 PASS_ENGINE_PARAMETER);
assertTriggerPosition(&position, 0, 0); assertTriggerPosition(&position, 0, 0);
} }