rusefi
/
custom-board-bundle-sample-fork-of-rusefi
mirror of https://github.com/rusefi/custom-board-bundle-sample-fork-of-rusefi.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

it's going to be painful

This commit is contained in:
Andrey 2023-04-29 00:13:13 -04:00 committed by rusefillc
parent ea43e867c0
commit 51d0f6e347
26 changed files with 112 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
firmware/console/eficonsole.cpp
View File

@ -33,7 +33,7 @@ static void testCritical() {
} }
static void myerror() { static void myerror() {
firmwareError(CUSTOM_ERR_TEST_ERROR, "firmwareError: %d", getRusEfiVersion()); firmwareError(ObdCode::CUSTOM_ERR_TEST_ERROR, "firmwareError: %d", getRusEfiVersion());
} }
static void sayHello() { static void sayHello() {
@ -77,7 +77,7 @@ static void sayHello() {
int flashSize = TM_ID_GetFlashSize(); int flashSize = TM_ID_GetFlashSize();
if (flashSize < MIN_FLASH_SIZE) { if (flashSize < MIN_FLASH_SIZE) {
firmwareError(OBD_PCM_Processor_Fault, "rusEFI expected at least %dK of flash", MIN_FLASH_SIZE); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "rusEFI expected at least %dK of flash", MIN_FLASH_SIZE);
} }
// todo: bug, at the moment we report 1MB on dual-bank F7 // todo: bug, at the moment we report 1MB on dual-bank F7
@ -183,7 +183,7 @@ static void cmd_threads() {
efiPrintf("%s\t%08x\t%lu\t%d", tp->name, tp->wabase, tp->time, freeBytes); efiPrintf("%s\t%08x\t%lu\t%d", tp->name, tp->wabase, tp->time, freeBytes);
if (freeBytes < 100) { if (freeBytes < 100) {
firmwareError(OBD_PCM_Processor_Fault, "Ran out of stack on thread %s, %d bytes remain", tp->name, freeBytes); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "Ran out of stack on thread %s, %d bytes remain", tp->name, freeBytes);
} }
tp = chRegNextThread(tp); tp = chRegNextThread(tp);

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

@ -125,7 +125,7 @@ void Engine::updateTriggerWaveform() {
#if ANALOG_HW_CHECK_MODE #if ANALOG_HW_CHECK_MODE
static void assertCloseTo(const char* msg, float actual, float expected) { static void assertCloseTo(const char* msg, float actual, float expected) {
if (actual < 0.95f * expected || actual > 1.05f * expected) { if (actual < 0.95f * expected || actual > 1.05f * expected) {
firmwareError(OBD_PCM_Processor_Fault, "%s validation failed actual=%f vs expected=%f", msg, actual, expected); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "%s validation failed actual=%f vs expected=%f", msg, actual, expected);
} }
} }
#endif // ANALOG_HW_CHECK_MODE #endif // ANALOG_HW_CHECK_MODE
@ -401,7 +401,7 @@ void Engine::efiWatchdog() {
if (mostRecentMs != 0) { if (mostRecentMs != 0) {
efitimems_t gapInMs = msNow - mostRecentMs; efitimems_t gapInMs = msNow - mostRecentMs;
if (gapInMs > 500) { if (gapInMs > 500) {
firmwareError(WATCH_DOG_SECONDS, "gap in time: now=%d mS, was %d mS, gap=%dmS", firmwareError(ObdCode::WATCH_DOG_SECONDS, "gap in time: now=%d mS, was %d mS, gap=%dmS",
msNow, mostRecentMs, gapInMs); msNow, mostRecentMs, gapInMs);
} }
} }

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

@ -167,7 +167,7 @@ __attribute__((weak)) void boardOnConfigurationChange(engine_configuration_s* /*
*/ */
void incrementGlobalConfigurationVersion(const char * msg) { void incrementGlobalConfigurationVersion(const char * msg) {
if (!hasRememberedConfiguration) { if (!hasRememberedConfiguration) {
firmwareError(OBD_PCM_Processor_Fault, "too early to invoke incrementGlobalConfigurationVersion %s", msg); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "too early to invoke incrementGlobalConfigurationVersion %s", msg);
} }
engine->globalConfigurationVersion++; engine->globalConfigurationVersion++;
#if EFI_DEFAILED_LOGGING #if EFI_DEFAILED_LOGGING

6
firmware/controllers/engine_cycle/aux_valves.cpp
View File

@ -39,7 +39,7 @@ void auxPlainPinTurnOn(AuxActor *current) {
angle_t duration = engine->engineState.auxValveEnd - engine->engineState.auxValveStart; angle_t duration = engine->engineState.auxValveEnd - engine->engineState.auxValveStart;
fixAngle(duration, "duration", CUSTOM_ERR_6557); fixAngle(duration, "duration", ObdCode::CUSTOM_ERR_6557);
engine->module<TriggerScheduler>()->schedule(&current->close, engine->module<TriggerScheduler>()->schedule(&current->close,
current->extra + engine->engineState.auxValveEnd, current->extra + engine->engineState.auxValveEnd,
@ -53,7 +53,7 @@ void initAuxValves() {
} }
if (!Sensor::hasSensor(SensorType::DriverThrottleIntent)) { if (!Sensor::hasSensor(SensorType::DriverThrottleIntent)) {
firmwareError(CUSTOM_OBD_91, "No TPS for Aux Valves"); firmwareError(ObdCode::CUSTOM_OBD_91, "No TPS for Aux Valves");
return; return;
} }
@ -93,7 +93,7 @@ void recalculateAuxValveTiming() {
if (engine->engineState.auxValveStart >= engine->engineState.auxValveEnd) { if (engine->engineState.auxValveStart >= engine->engineState.auxValveEnd) {
// this is a fatal error to make this really visible // this is a fatal error to make this really visible
firmwareError(CUSTOM_AUX_OUT_OF_ORDER, "out of order at %.2f %.2f %.2f", tps, firmwareError(ObdCode::CUSTOM_AUX_OUT_OF_ORDER, "out of order at %.2f %.2f %.2f", tps,
engine->engineState.auxValveStart, engine->engineState.auxValveStart,
engine->engineState.auxValveEnd); engine->engineState.auxValveEnd);
} }

2
firmware/controllers/engine_cycle/fuel_schedule.cpp
View File

@ -186,7 +186,7 @@ bool FuelSchedule::addFuelEventsForCylinder(int i) {
if (!isSimultaneous && !output->isInitialized()) { if (!isSimultaneous && !output->isInitialized()) {
// todo: extract method for this index math // todo: extract method for this index math
warning(CUSTOM_OBD_INJECTION_NO_PIN_ASSIGNED, "no_pin_inj #%s", output->name); warning(ObdCode::CUSTOM_OBD_INJECTION_NO_PIN_ASSIGNED, "no_pin_inj #%s", output->name);
} }
return true; return true;

36
firmware/controllers/engine_cycle/spark_logic.cpp
View File

@ -54,7 +54,7 @@ static void fireSparkBySettingPinLow(IgnitionEvent *event, IgnitionOutputPin *ou
output->signalFallSparkId = event->sparkId; output->signalFallSparkId = event->sparkId;
if (!output->currentLogicValue && !event->wasSparkLimited) { if (!output->currentLogicValue && !event->wasSparkLimited) {
warning(CUSTOM_OUT_OF_ORDER_COIL, "out-of-order coil off %s", output->getName()); warning(ObdCode::CUSTOM_OUT_OF_ORDER_COIL, "out-of-order coil off %s", output->getName());
output->outOfOrder = true; output->outOfOrder = true;
} }
output->setLow(); output->setLow();
@ -62,7 +62,7 @@ static void fireSparkBySettingPinLow(IgnitionEvent *event, IgnitionOutputPin *ou
static void assertPinAssigned(IgnitionOutputPin* output) { static void assertPinAssigned(IgnitionOutputPin* output) {
if (!output->isInitialized()) { if (!output->isInitialized()) {
warning(CUSTOM_OBD_COIL_PIN_NOT_ASSIGNED, "Pin Not Assigned check configuration #%s", output->getName()); \ warning(ObdCode::CUSTOM_OBD_COIL_PIN_NOT_ASSIGNED, "Pin Not Assigned check configuration #%s", output->getName()); \
} }
} }
@ -86,7 +86,7 @@ static int getIgnitionPinForIndex(int cylinderIndex, ignition_mode_e ignitionMod
return cylinderIndex % 2; return cylinderIndex % 2;
default: default:
firmwareError(CUSTOM_OBD_IGNITION_MODE, "Invalid ignition mode getIgnitionPinForIndex(): %d", engineConfiguration->ignitionMode); firmwareError(ObdCode::CUSTOM_OBD_IGNITION_MODE, "Invalid ignition mode getIgnitionPinForIndex(): %d", engineConfiguration->ignitionMode);
return 0; return 0;
} }
} }
@ -107,7 +107,7 @@ static void prepareCylinderIgnitionSchedule(angle_t dwellAngleDuration, floatms_
// Offset by this cylinder's position in the cycle // Offset by this cylinder's position in the cycle
+ getPerCylinderFiringOrderOffset(event->cylinderIndex, event->cylinderNumber); + getPerCylinderFiringOrderOffset(event->cylinderIndex, event->cylinderNumber);
efiAssertVoid(CUSTOM_SPARK_ANGLE_1, !cisnan(sparkAngle), "sparkAngle#1"); efiAssertVoid(ObdCode::CUSTOM_SPARK_ANGLE_1, !cisnan(sparkAngle), "sparkAngle#1");
auto ignitionMode = getCurrentIgnitionMode(); auto ignitionMode = getCurrentIgnitionMode();
@ -135,17 +135,17 @@ static void prepareCylinderIgnitionSchedule(angle_t dwellAngleDuration, floatms_
event->outputs[0] = output; event->outputs[0] = output;
event->outputs[1] = secondOutput; event->outputs[1] = secondOutput;
wrapAngle2(sparkAngle, "findAngle#2", CUSTOM_ERR_6550, getEngineCycle(getEngineRotationState()->getOperationMode())); wrapAngle2(sparkAngle, "findAngle#2", ObdCode::CUSTOM_ERR_6550, getEngineCycle(getEngineRotationState()->getOperationMode()));
event->sparkAngle = sparkAngle; event->sparkAngle = sparkAngle;
// Stash which cylinder we're scheduling so that knock sensing knows which // Stash which cylinder we're scheduling so that knock sensing knows which
// cylinder just fired // cylinder just fired
event->cylinderNumber = coilIndex; event->cylinderNumber = coilIndex;
angle_t dwellStartAngle = sparkAngle - dwellAngleDuration; angle_t dwellStartAngle = sparkAngle - dwellAngleDuration;
efiAssertVoid(CUSTOM_ERR_6590, !cisnan(dwellStartAngle), "findAngle#5"); efiAssertVoid(ObdCode::CUSTOM_ERR_6590, !cisnan(dwellStartAngle), "findAngle#5");
assertAngleRange(dwellStartAngle, "findAngle dwellStartAngle", CUSTOM_ERR_6550); assertAngleRange(dwellStartAngle, "findAngle dwellStartAngle", ObdCode::CUSTOM_ERR_6550);
wrapAngle2(dwellStartAngle, "findAngle#7", CUSTOM_ERR_6550, getEngineCycle(getEngineRotationState()->getOperationMode())); wrapAngle2(dwellStartAngle, "findAngle#7", ObdCode::CUSTOM_ERR_6550, getEngineCycle(getEngineRotationState()->getOperationMode()));
event->dwellAngle = dwellStartAngle; event->dwellAngle = dwellStartAngle;
#if FUEL_MATH_EXTREME_LOGGING #if FUEL_MATH_EXTREME_LOGGING
@ -269,7 +269,7 @@ static void startDwellByTurningSparkPinHigh(IgnitionEvent *event, IgnitionOutput
if (Sensor::getOrZero(SensorType::Rpm) > 2 * engineConfiguration->cranking.rpm) { if (Sensor::getOrZero(SensorType::Rpm) > 2 * engineConfiguration->cranking.rpm) {
const char *outputName = output->getName(); const char *outputName = output->getName();
if (prevSparkName == outputName && getCurrentIgnitionMode() != IM_ONE_COIL) { if (prevSparkName == outputName && getCurrentIgnitionMode() != IM_ONE_COIL) {
warning(CUSTOM_OBD_SKIPPED_SPARK, "looks like skipped spark event %d %s", getRevolutionCounter(), outputName); warning(ObdCode::CUSTOM_OBD_SKIPPED_SPARK, "looks like skipped spark event %d %s", getRevolutionCounter(), outputName);
} }
prevSparkName = outputName; prevSparkName = outputName;
} }
@ -324,11 +324,11 @@ static void scheduleSparkEvent(bool limitedSpark, IgnitionEvent *event,
angle_t sparkAngle = event->sparkAngle; angle_t sparkAngle = event->sparkAngle;
const floatms_t dwellMs = engine->ignitionState.sparkDwell; const floatms_t dwellMs = engine->ignitionState.sparkDwell;
if (cisnan(dwellMs) || dwellMs <= 0) { if (cisnan(dwellMs) || dwellMs <= 0) {
warning(CUSTOM_DWELL, "invalid dwell to handle: %.2f at %d", dwellMs, rpm); warning(ObdCode::CUSTOM_DWELL, "invalid dwell to handle: %.2f at %d", dwellMs, rpm);
return; return;
} }
if (cisnan(sparkAngle)) { if (cisnan(sparkAngle)) {
warning(CUSTOM_ADVANCE_SPARK, "NaN advance"); warning(ObdCode::CUSTOM_ADVANCE_SPARK, "NaN advance");
return; return;
} }
@ -372,8 +372,8 @@ static void scheduleSparkEvent(bool limitedSpark, IgnitionEvent *event,
* Spark event is often happening during a later trigger event timeframe * Spark event is often happening during a later trigger event timeframe
*/ */
efiAssertVoid(CUSTOM_ERR_6591, !cisnan(sparkAngle), "findAngle#4"); efiAssertVoid(ObdCode::CUSTOM_ERR_6591, !cisnan(sparkAngle), "findAngle#4");
assertAngleRange(sparkAngle, "findAngle#a5", CUSTOM_ERR_6549); assertAngleRange(sparkAngle, "findAngle#a5", ObdCode::CUSTOM_ERR_6549);
bool scheduled = engine->module<TriggerScheduler>()->scheduleOrQueue( bool scheduled = engine->module<TriggerScheduler>()->scheduleOrQueue(
&event->sparkEvent, edgeTimestamp, sparkAngle, &event->sparkEvent, edgeTimestamp, sparkAngle,
@ -415,7 +415,7 @@ void initializeIgnitionActions() {
list->isReady = false; list->isReady = false;
return; return;
} }
efiAssertVoid(CUSTOM_ERR_6592, engineConfiguration->cylindersCount > 0, "cylindersCount"); efiAssertVoid(ObdCode::CUSTOM_ERR_6592, engineConfiguration->cylindersCount > 0, "cylindersCount");
for (size_t cylinderIndex = 0; cylinderIndex < engineConfiguration->cylindersCount; cylinderIndex++) { for (size_t cylinderIndex = 0; cylinderIndex < engineConfiguration->cylindersCount; cylinderIndex++) {
list->elements[cylinderIndex].cylinderIndex = cylinderIndex; list->elements[cylinderIndex].cylinderIndex = cylinderIndex;
@ -442,10 +442,10 @@ static void prepareIgnitionSchedule() {
} }
if (engine->ignitionState.dwellAngle == 0) { if (engine->ignitionState.dwellAngle == 0) {
warning(CUSTOM_ZERO_DWELL, "dwell is zero?"); warning(ObdCode::CUSTOM_ZERO_DWELL, "dwell is zero?");
} }
if (engine->ignitionState.dwellAngle > maxAllowedDwellAngle) { if (engine->ignitionState.dwellAngle > maxAllowedDwellAngle) {
warning(CUSTOM_DWELL_TOO_LONG, "dwell angle too long: %.2f", engine->ignitionState.dwellAngle); warning(ObdCode::CUSTOM_DWELL_TOO_LONG, "dwell angle too long: %.2f", engine->ignitionState.dwellAngle);
} }
// todo: add some check for dwell overflow? like 4 times 6 ms while engine cycle is less then that // todo: add some check for dwell overflow? like 4 times 6 ms while engine cycle is less then that
@ -491,7 +491,7 @@ void onTriggerEventSparkLogic(int rpm, efitick_t edgeTimestamp, float currentPha
// artificial misfire on cylinder #1 for testing purposes // artificial misfire on cylinder #1 for testing purposes
// enable artificialMisfire // enable artificialMisfire
// set_fsio_setting 6 20 // set_fsio_setting 6 20
warning(CUSTOM_ARTIFICIAL_MISFIRE, "artificial misfire on cylinder #1 for testing purposes %d", engine->engineState.sparkCounter); warning(ObdCode::CUSTOM_ARTIFICIAL_MISFIRE, "artificial misfire on cylinder #1 for testing purposes %d", engine->engineState.sparkCounter);
continue; continue;
} }
#if EFI_LAUNCH_CONTROL #if EFI_LAUNCH_CONTROL
@ -537,7 +537,7 @@ int getNumberOfSparks(ignition_mode_e mode) {
case IM_WASTED_SPARK: case IM_WASTED_SPARK:
return 2; return 2;
default: default:
firmwareError(CUSTOM_ERR_IGNITION_MODE, "Unexpected ignition_mode_e %d", mode); firmwareError(ObdCode::CUSTOM_ERR_IGNITION_MODE, "Unexpected ignition_mode_e %d", mode);
return 1; return 1;
} }
} }

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

@ -85,7 +85,7 @@ floatms_t IgnitionState::getSparkDwell(int rpm) {
if (engine->rpmCalculator.isCranking()) { if (engine->rpmCalculator.isCranking()) {
dwellMs = engineConfiguration->ignitionDwellForCrankingMs; dwellMs = engineConfiguration->ignitionDwellForCrankingMs;
} else { } else {
efiAssert(CUSTOM_ERR_ASSERT, !cisnan(rpm), "invalid rpm", NAN); efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !cisnan(rpm), "invalid rpm", NAN);
baseDwell = interpolate2d(rpm, config->sparkDwellRpmBins, config->sparkDwellValues); baseDwell = interpolate2d(rpm, config->sparkDwellRpmBins, config->sparkDwellValues);
dwellVoltageCorrection = interpolate2d( dwellVoltageCorrection = interpolate2d(
@ -104,7 +104,7 @@ floatms_t IgnitionState::getSparkDwell(int rpm) {
if (cisnan(dwellMs) || dwellMs <= 0) { if (cisnan(dwellMs) || dwellMs <= 0) {
// this could happen during engine configuration reset // this could happen during engine configuration reset
warning(CUSTOM_ERR_DWELL_DURATION, "invalid dwell: %.2f at rpm=%d", dwellMs, rpm); warning(ObdCode::CUSTOM_ERR_DWELL_DURATION, "invalid dwell: %.2f at rpm=%d", dwellMs, rpm);
return 0; return 0;
} }
return dwellMs; return dwellMs;
@ -227,7 +227,7 @@ static size_t getFiringOrderLength() {
return 16; return 16;
default: default:
firmwareError(CUSTOM_OBD_UNKNOWN_FIRING_ORDER, "Invalid firing order: %d", engineConfiguration->firingOrder); firmwareError(ObdCode::CUSTOM_OBD_UNKNOWN_FIRING_ORDER, "Invalid firing order: %d", engineConfiguration->firingOrder);
} }
return 1; return 1;
} }
@ -319,7 +319,7 @@ static const uint8_t* getFiringOrderTable()
return order_1_14_9_4_7_12_15_6_13_8_3_16_11_2_5_10; return order_1_14_9_4_7_12_15_6_13_8_3_16_11_2_5_10;
default: default:
firmwareError(CUSTOM_OBD_UNKNOWN_FIRING_ORDER, "Invalid firing order: %d", engineConfiguration->firingOrder); firmwareError(ObdCode::CUSTOM_OBD_UNKNOWN_FIRING_ORDER, "Invalid firing order: %d", engineConfiguration->firingOrder);
} }
return NULL; return NULL;
@ -333,18 +333,18 @@ size_t getCylinderId(size_t index) {
const size_t firingOrderLength = getFiringOrderLength(); const size_t firingOrderLength = getFiringOrderLength();
if (firingOrderLength < 1 || firingOrderLength > MAX_CYLINDER_COUNT) { if (firingOrderLength < 1 || firingOrderLength > MAX_CYLINDER_COUNT) {
firmwareError(CUSTOM_FIRING_LENGTH, "fol %d", firingOrderLength); firmwareError(ObdCode::CUSTOM_FIRING_LENGTH, "fol %d", firingOrderLength);
return 1; return 1;
} }
if (engineConfiguration->cylindersCount != firingOrderLength) { if (engineConfiguration->cylindersCount != firingOrderLength) {
// May 2020 this somehow still happens with functional tests, maybe race condition? // May 2020 this somehow still happens with functional tests, maybe race condition?
firmwareError(CUSTOM_OBD_WRONG_FIRING_ORDER, "Wrong cyl count for firing order, expected %d cylinders", firingOrderLength); firmwareError(ObdCode::CUSTOM_OBD_WRONG_FIRING_ORDER, "Wrong cyl count for firing order, expected %d cylinders", firingOrderLength);
return 1; return 1;
} }
if (index >= firingOrderLength) { if (index >= firingOrderLength) {
// May 2020 this somehow still happens with functional tests, maybe race condition? // May 2020 this somehow still happens with functional tests, maybe race condition?
warning(CUSTOM_ERR_6686, "firing order index %d", index); warning(ObdCode::CUSTOM_ERR_6686, "firing order index %d", index);
return 1; return 1;
} }
@ -423,7 +423,7 @@ angle_t getPerCylinderFiringOrderOffset(uint8_t cylinderIndex, uint8_t cylinderN
// We get a cylinder every n-th of an engine cycle where N is the number of cylinders // We get a cylinder every n-th of an engine cycle where N is the number of cylinders
auto firingOrderOffset = engine->engineState.engineCycle * cylinderIndex / engineConfiguration->cylindersCount; auto firingOrderOffset = engine->engineState.engineCycle * cylinderIndex / engineConfiguration->cylindersCount;
assertAngleRange(firingOrderOffset, "getPerCylinderFiringOrderOffset", CUSTOM_ERR_6566); assertAngleRange(firingOrderOffset, "getPerCylinderFiringOrderOffset", ObdCode::CUSTOM_ERR_6566);
return firingOrderOffset; return firingOrderOffset;
} }

14
firmware/controllers/system/efi_gpio.cpp
View File

@ -461,7 +461,7 @@ bool OutputPin::getAndSet(int logicValue) {
void OutputPin::setOnchipValue(int electricalValue) { void OutputPin::setOnchipValue(int electricalValue) {
if (brainPin == Gpio::Unassigned || brainPin == Gpio::Invalid) { if (brainPin == Gpio::Unassigned || brainPin == Gpio::Invalid) {
// todo: make 'setOnchipValue' or 'reportsetOnchipValueError' virtual and override for NamedOutputPin? // todo: make 'setOnchipValue' or 'reportsetOnchipValueError' virtual and override for NamedOutputPin?
warning(CUSTOM_ERR_6586, "attempting to change unassigned pin"); warning(ObdCode::CUSTOM_ERR_6586, "attempting to change unassigned pin");
return; return;
} }
palWritePad(port, pin, electricalValue); palWritePad(port, pin, electricalValue);
@ -491,9 +491,9 @@ void OutputPin::setValue(int logicValue) {
return; return;
} }
efiAssertVoid(CUSTOM_ERR_6621, modePtr!=NULL, "pin mode not initialized"); efiAssertVoid(ObdCode::CUSTOM_ERR_6621, modePtr!=NULL, "pin mode not initialized");
pin_output_mode_e mode = *modePtr; pin_output_mode_e mode = *modePtr;
efiAssertVoid(CUSTOM_ERR_6622, mode <= OM_OPENDRAIN_INVERTED, "invalid pin_output_mode_e"); efiAssertVoid(ObdCode::CUSTOM_ERR_6622, mode <= OM_OPENDRAIN_INVERTED, "invalid pin_output_mode_e");
int electricalValue = getElectricalValue(logicValue, mode); int electricalValue = getElectricalValue(logicValue, mode);
#if EFI_PROD_CODE #if EFI_PROD_CODE
@ -576,12 +576,12 @@ void OutputPin::initPin(const char *msg, brain_pin_e brainPin, const pin_output_
// Check that this OutputPin isn't already assigned to another pin (reinit is allowed to change mode) // Check that this OutputPin isn't already assigned to another pin (reinit is allowed to change mode)
// To avoid this error, call deInit() first // To avoid this error, call deInit() first
if (isBrainPinValid(this->brainPin) && this->brainPin != brainPin) { if (isBrainPinValid(this->brainPin) && this->brainPin != brainPin) {
firmwareError(CUSTOM_OBD_PIN_CONFLICT, "outputPin [%s] already assigned, cannot reassign without unregister first", msg); firmwareError(ObdCode::CUSTOM_OBD_PIN_CONFLICT, "outputPin [%s] already assigned, cannot reassign without unregister first", msg);
return; return;
} }
if (*outputMode > OM_OPENDRAIN_INVERTED) { if (*outputMode > OM_OPENDRAIN_INVERTED) {
firmwareError(CUSTOM_INVALID_MODE_SETTING, "%s invalid pin_output_mode_e %d %s", firmwareError(ObdCode::CUSTOM_INVALID_MODE_SETTING, "%s invalid pin_output_mode_e %d %s",
msg, msg,
*outputMode, *outputMode,
hwPortname(brainPin) hwPortname(brainPin)
@ -602,7 +602,7 @@ void OutputPin::initPin(const char *msg, brain_pin_e brainPin, const pin_output_
// Validate port // Validate port
if (port == GPIO_NULL) { if (port == GPIO_NULL) {
firmwareError(OBD_PCM_Processor_Fault, "OutputPin::initPin got invalid port for pin idx %d", static_cast<int>(brainPin)); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "OutputPin::initPin got invalid port for pin idx %d", static_cast<int>(brainPin));
return; return;
} }
@ -640,7 +640,7 @@ void OutputPin::initPin(const char *msg, brain_pin_e brainPin, const pin_output_
#ifndef DISABLE_PIN_STATE_VALIDATION #ifndef DISABLE_PIN_STATE_VALIDATION
// if the pin was set to logical 1, then set an error and disable the pin so that things don't catch fire // if the pin was set to logical 1, then set an error and disable the pin so that things don't catch fire
if (logicalValue) { if (logicalValue) {
firmwareError(OBD_PCM_Processor_Fault, "HARDWARE VALIDATION FAILED %s: unexpected startup pin state %s actual value=%d logical value=%d mode=%s", msg, hwPortname(brainPin), actualValue, logicalValue, getPin_output_mode_e(*outputMode)); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "HARDWARE VALIDATION FAILED %s: unexpected startup pin state %s actual value=%d logical value=%d mode=%s", msg, hwPortname(brainPin), actualValue, logicalValue, getPin_output_mode_e(*outputMode));
OutputPin::deInit(); OutputPin::deInit();
} }
#endif #endif

30
firmware/controllers/trigger/decoders/trigger_structure.cpp
View File

@ -123,7 +123,7 @@ bool TriggerWaveform::needsDisambiguation() const {
case TWO_STROKE: case TWO_STROKE:
return false; return false;
default: default:
firmwareError(OBD_PCM_Processor_Fault, "bad operationMode() in needsDisambiguation"); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "bad operationMode() in needsDisambiguation");
return true; return true;
} }
} }
@ -153,7 +153,7 @@ angle_t TriggerWaveform::getAngle(int index) const {
* See also trigger_central.cpp * See also trigger_central.cpp
* See also getEngineCycleEventCount() * See also getEngineCycleEventCount()
*/ */
efiAssert(CUSTOM_ERR_ASSERT, wave.phaseCount != 0, "shapeSize=0", NAN); efiAssert(ObdCode::CUSTOM_ERR_ASSERT, wave.phaseCount != 0, "shapeSize=0", NAN);
int crankCycle = index / wave.phaseCount; int crankCycle = index / wave.phaseCount;
int remainder = index % wave.phaseCount; int remainder = index % wave.phaseCount;
@ -192,7 +192,7 @@ void TriggerWaveform::calculateExpectedEventCounts() {
if (!useOnlyRisingEdges) { if (!useOnlyRisingEdges) {
for (size_t i = 0; i < efi::size(expectedEventCount); i++) { for (size_t i = 0; i < efi::size(expectedEventCount); i++) {
if (getExpectedEventCount((TriggerWheel)i) % 2 != 0) { if (getExpectedEventCount((TriggerWheel)i) % 2 != 0) {
firmwareError(ERROR_TRIGGER_DRAMA, "Trigger: should be even number of events index=%d count=%d", i, getExpectedEventCount((TriggerWheel)i)); firmwareError(ObdCode::ERROR_TRIGGER_DRAMA, "Trigger: should be even number of events index=%d count=%d", i, getExpectedEventCount((TriggerWheel)i));
} }
} }
} }
@ -200,13 +200,13 @@ void TriggerWaveform::calculateExpectedEventCounts() {
bool isSingleToothOnPrimaryChannel = useOnlyRisingEdges ? getExpectedEventCount(TriggerWheel::T_PRIMARY) == 1 : getExpectedEventCount(TriggerWheel::T_PRIMARY) == 2; bool isSingleToothOnPrimaryChannel = useOnlyRisingEdges ? getExpectedEventCount(TriggerWheel::T_PRIMARY) == 1 : getExpectedEventCount(TriggerWheel::T_PRIMARY) == 2;
// todo: next step would be to set 'isSynchronizationNeeded' automatically based on the logic we have here // todo: next step would be to set 'isSynchronizationNeeded' automatically based on the logic we have here
if (!shapeWithoutTdc && isSingleToothOnPrimaryChannel != !isSynchronizationNeeded) { if (!shapeWithoutTdc && isSingleToothOnPrimaryChannel != !isSynchronizationNeeded) {
firmwareError(ERROR_TRIGGER_DRAMA, "shapeWithoutTdc isSynchronizationNeeded isSingleToothOnPrimaryChannel constraint violation"); firmwareError(ObdCode::ERROR_TRIGGER_DRAMA, "shapeWithoutTdc isSynchronizationNeeded isSingleToothOnPrimaryChannel constraint violation");
} }
if (isSingleToothOnPrimaryChannel) { if (isSingleToothOnPrimaryChannel) {
useOnlyPrimaryForSync = true; useOnlyPrimaryForSync = true;
} else { } else {
if (getExpectedEventCount(TriggerWheel::T_SECONDARY) == 0 && useOnlyPrimaryForSync) { if (getExpectedEventCount(TriggerWheel::T_SECONDARY) == 0 && useOnlyPrimaryForSync) {
firmwareError(ERROR_TRIGGER_DRAMA, "why would you set useOnlyPrimaryForSync with only one trigger wheel?"); firmwareError(ObdCode::ERROR_TRIGGER_DRAMA, "why would you set useOnlyPrimaryForSync with only one trigger wheel?");
} }
} }
@ -225,7 +225,7 @@ void TriggerWaveform::addEvent720(angle_t angle, TriggerValue const state, Trigg
} }
void TriggerWaveform::addEvent360(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex) { void TriggerWaveform::addEvent360(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex) {
efiAssertVoid(CUSTOM_OMODE_UNDEF, operationMode == FOUR_STROKE_CAM_SENSOR || operationMode == FOUR_STROKE_CRANK_SENSOR, "Not a mode for 360"); efiAssertVoid(ObdCode::CUSTOM_OMODE_UNDEF, operationMode == FOUR_STROKE_CAM_SENSOR || operationMode == FOUR_STROKE_CRANK_SENSOR, "Not a mode for 360");
addEvent(CRANK_MODE_MULTIPLIER * angle / FOUR_STROKE_CYCLE_DURATION, state, channelIndex); addEvent(CRANK_MODE_MULTIPLIER * angle / FOUR_STROKE_CYCLE_DURATION, state, channelIndex);
} }
@ -234,7 +234,7 @@ void TriggerWaveform::addEventAngle(angle_t angle, TriggerValue const state, Tri
} }
void TriggerWaveform::addEvent(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex) { void TriggerWaveform::addEvent(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex) {
efiAssertVoid(CUSTOM_OMODE_UNDEF, operationMode != OM_NONE, "operationMode not set"); efiAssertVoid(ObdCode::CUSTOM_OMODE_UNDEF, operationMode != OM_NONE, "operationMode not set");
if (channelIndex == TriggerWheel:: T_SECONDARY) { if (channelIndex == TriggerWheel:: T_SECONDARY) {
needSecondTriggerInput = true; needSecondTriggerInput = true;
@ -261,12 +261,12 @@ void TriggerWaveform::addEvent(angle_t angle, TriggerValue const state, TriggerW
} }
if (angle <= 0 || angle > 1) { if (angle <= 0 || angle > 1) {
firmwareError(CUSTOM_ERR_6599, "angle should be positive not above 1: index=%d angle %f", channelIndex, angle); firmwareError(ObdCode::CUSTOM_ERR_6599, "angle should be positive not above 1: index=%d angle %f", channelIndex, angle);
return; return;
} }
if (wave.phaseCount > 0) { if (wave.phaseCount > 0) {
if (angle <= previousAngle) { if (angle <= previousAngle) {
warning(CUSTOM_ERR_TRG_ANGLE_ORDER, "invalid angle order %s %s: new=%.2f/%f and prev=%.2f/%f, size=%d", warning(ObdCode::CUSTOM_ERR_TRG_ANGLE_ORDER, "invalid angle order %s %s: new=%.2f/%f and prev=%.2f/%f, size=%d",
getTriggerWheel(channelIndex), getTriggerWheel(channelIndex),
getTrigger_value_e(state), getTrigger_value_e(state),
angle, angle * getCycleDuration(), angle, angle * getCycleDuration(),
@ -290,7 +290,7 @@ void TriggerWaveform::addEvent(angle_t angle, TriggerValue const state, TriggerW
} }
if (wave.findAngleMatch(angle)) { if (wave.findAngleMatch(angle)) {
warning(CUSTOM_ERR_SAME_ANGLE, "same angle: not supported"); warning(ObdCode::CUSTOM_ERR_SAME_ANGLE, "same angle: not supported");
setShapeDefinitionError(true); setShapeDefinitionError(true);
return; return;
} }
@ -313,7 +313,7 @@ void TriggerWaveform::addEvent(angle_t angle, TriggerValue const state, TriggerW
isRiseEvent[index] = TriggerValue::RISE == state; isRiseEvent[index] = TriggerValue::RISE == state;
if ((unsigned)index != wave.phaseCount) { if ((unsigned)index != wave.phaseCount) {
firmwareError(ERROR_TRIGGER_DRAMA, "are we ever here?"); firmwareError(ObdCode::ERROR_TRIGGER_DRAMA, "are we ever here?");
} }
wave.phaseCount++; wave.phaseCount++;
@ -336,7 +336,7 @@ void TriggerWaveform::setTriggerSynchronizationGap2(float syncRatioFrom, float s
void TriggerWaveform::setTriggerSynchronizationGap3(int gapIndex, float syncRatioFrom, float syncRatioTo) { void TriggerWaveform::setTriggerSynchronizationGap3(int gapIndex, float syncRatioFrom, float syncRatioTo) {
isSynchronizationNeeded = true; isSynchronizationNeeded = true;
efiAssertVoid(OBD_PCM_Processor_Fault, gapIndex >= 0 && gapIndex < GAP_TRACKING_LENGTH, "gapIndex out of range"); efiAssertVoid(ObdCode::OBD_PCM_Processor_Fault, gapIndex >= 0 && gapIndex < GAP_TRACKING_LENGTH, "gapIndex out of range");
syncronizationRatioFrom[gapIndex] = syncRatioFrom; syncronizationRatioFrom[gapIndex] = syncRatioFrom;
syncronizationRatioTo[gapIndex] = syncRatioTo; syncronizationRatioTo[gapIndex] = syncRatioTo;
if (gapIndex == 0) { if (gapIndex == 0) {
@ -356,7 +356,7 @@ void TriggerWaveform::setTriggerSynchronizationGap3(int gapIndex, float syncRati
uint16_t TriggerWaveform::findAngleIndex(TriggerFormDetails *details, angle_t targetAngle) const { uint16_t TriggerWaveform::findAngleIndex(TriggerFormDetails *details, angle_t targetAngle) const {
size_t engineCycleEventCount = getLength(); size_t engineCycleEventCount = getLength();
efiAssert(CUSTOM_ERR_ASSERT, engineCycleEventCount != 0 && engineCycleEventCount <= 0xFFFF, efiAssert(ObdCode::CUSTOM_ERR_ASSERT, engineCycleEventCount != 0 && engineCycleEventCount <= 0xFFFF,
"engineCycleEventCount", 0); "engineCycleEventCount", 0);
uint32_t left = 0; uint32_t left = 0;
@ -408,7 +408,7 @@ void TriggerWaveform::setThirdTriggerSynchronizationGap(float syncRatio) {
void TriggerWaveform::initializeTriggerWaveform(operation_mode_e triggerOperationMode, const trigger_config_s &triggerType) { void TriggerWaveform::initializeTriggerWaveform(operation_mode_e triggerOperationMode, const trigger_config_s &triggerType) {
#if EFI_PROD_CODE #if EFI_PROD_CODE
efiAssertVoid(CUSTOM_ERR_6641, getCurrentRemainingStack() > EXPECTED_REMAINING_STACK, "init t"); efiAssertVoid(ObdCode::CUSTOM_ERR_6641, getCurrentRemainingStack() > EXPECTED_REMAINING_STACK, "init t");
efiPrintf("initializeTriggerWaveform(%s/%d)", getTrigger_type_e(triggerType.type), (int)triggerType.type); efiPrintf("initializeTriggerWaveform(%s/%d)", getTrigger_type_e(triggerType.type), (int)triggerType.type);
#endif #endif
@ -720,7 +720,7 @@ void TriggerWaveform::initializeTriggerWaveform(operation_mode_e triggerOperatio
default: default:
setShapeDefinitionError(true); setShapeDefinitionError(true);
warning(CUSTOM_ERR_NO_SHAPE, "initializeTriggerWaveform() not implemented: %d", triggerType.type); warning(ObdCode::CUSTOM_ERR_NO_SHAPE, "initializeTriggerWaveform() not implemented: %d", triggerType.type);
} }
/** /**

8
firmware/controllers/trigger/instant_rpm_calculator.cpp
View File

@ -54,11 +54,11 @@ float InstantRpmCalculator::calculateInstantRpm(
// Determine where we currently are in the revolution // Determine where we currently are in the revolution
angle_t currentAngle = triggerFormDetails->eventAngles[current_index]; angle_t currentAngle = triggerFormDetails->eventAngles[current_index];
efiAssert(OBD_PCM_Processor_Fault, !cisnan(currentAngle), "eventAngles", 0); efiAssert(ObdCode::OBD_PCM_Processor_Fault, !cisnan(currentAngle), "eventAngles", 0);
// Hunt for a tooth ~90 degrees ago to compare to the current time // Hunt for a tooth ~90 degrees ago to compare to the current time
angle_t previousAngle = currentAngle - 90; angle_t previousAngle = currentAngle - 90;
fixAngle(previousAngle, "prevAngle", CUSTOM_ERR_TRIGGER_ANGLE_RANGE); fixAngle(previousAngle, "prevAngle", ObdCode::CUSTOM_ERR_TRIGGER_ANGLE_RANGE);
int prevIndex = triggerShape.findAngleIndex(triggerFormDetails, previousAngle); int prevIndex = triggerShape.findAngleIndex(triggerFormDetails, previousAngle);
// now let's get precise angle for that event // now let's get precise angle for that event
@ -77,7 +77,7 @@ float InstantRpmCalculator::calculateInstantRpm(
angle_t angleDiff = currentAngle - prevIndexAngle; angle_t angleDiff = currentAngle - prevIndexAngle;
// Wrap the angle in to the correct range (ie, could be -630 when we want +90) // Wrap the angle in to the correct range (ie, could be -630 when we want +90)
fixAngle(angleDiff, "angleDiff", CUSTOM_ERR_6561); fixAngle(angleDiff, "angleDiff", ObdCode::CUSTOM_ERR_6561);
// just for safety, avoid divide-by-0 // just for safety, avoid divide-by-0
if (time == 0) { if (time == 0) {
@ -137,4 +137,4 @@ void InstantRpmCalculator::updateInstantRpm(
#endif /* EFI_SENSOR_CHART */ #endif /* EFI_SENSOR_CHART */
} }
#endif // EFI_SHAFT_POSITION_INPUT #endif // EFI_SHAFT_POSITION_INPUT

2
firmware/controllers/trigger/trigger_central.cpp
View File

@ -969,7 +969,7 @@ static void resetRunningTriggerCounters() {
void onConfigurationChangeTriggerCallback() { void onConfigurationChangeTriggerCallback() {
bool changed = false; bool changed = false;
// todo: how do we static_assert here? // todo: how do we static_assert here?
efiAssertVoid(OBD_PCM_Processor_Fault, efi::size(engineConfiguration->camInputs) == efi::size(engineConfiguration->vvtOffsets), "sizes"); efiAssertVoid(ObdCode::OBD_PCM_Processor_Fault, efi::size(engineConfiguration->camInputs) == efi::size(engineConfiguration->vvtOffsets), "sizes");
for (size_t camIndex = 0; camIndex < efi::size(engineConfiguration->camInputs); camIndex++) { for (size_t camIndex = 0; camIndex < efi::size(engineConfiguration->camInputs); camIndex++) {
changed |= isConfigurationChanged(camInputs[camIndex]); changed |= isConfigurationChanged(camInputs[camIndex]);

2
firmware/hw_layer/adc/mcp3208.cpp
View File

@ -69,7 +69,7 @@ MCP3208_CS_PIN,
}; };
static void createRequest(McpAdcState *state, int channel) { static void createRequest(McpAdcState *state, int channel) {
efiAssertVoid(CUSTOM_ERR_6680, channel < 8, "Invalid ADC channel"); efiAssertVoid(ObdCode::CUSTOM_ERR_6680, channel < 8, "Invalid ADC channel");
state->requestedChannel = channel; state->requestedChannel = channel;

5
firmware/hw_layer/drivers/sent/sent_hw_icu.cpp
View File

@ -9,8 +9,7 @@
#if EFI_PROD_CODE #if EFI_PROD_CODE
#include "ch.h" #include "pch.h"
#include "hal.h"
#include "sent.h" #include "sent.h"
#include "sent_hw_icu.h" #include "sent_hw_icu.h"
@ -62,7 +61,7 @@ void startSent() {
if (getIcuParams(sentPin, &pinAF, &icu, &cfg->channel, &baseClock) != true) { if (getIcuParams(sentPin, &pinAF, &icu, &cfg->channel, &baseClock) != true) {
/* this pin has no ICU functionality, of ICU driver is not enabled for TIM on this pin */ /* this pin has no ICU functionality, of ICU driver is not enabled for TIM on this pin */
firmwareError(OBD_PCM_Processor_Fault, "No ICU on selected SENT pin"); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "No ICU on selected SENT pin");
continue; continue;
} }

10
firmware/hw_layer/ports/stm32/stm32_common.cpp
View File

@ -481,7 +481,7 @@ static int getSpiAf(SPIDriver *driver) {
return EFI_SPI3_AF; return EFI_SPI3_AF;
} }
#endif #endif
firmwareError(OBD_PCM_Processor_Fault, "SPI AF not available"); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "SPI AF not available");
return -1; return -1;
} }
@ -542,7 +542,7 @@ void turnOnSpi(spi_device_e device) {
engineConfiguration->spi1MosiMode, engineConfiguration->spi1MosiMode,
engineConfiguration->spi1MisoMode); engineConfiguration->spi1MisoMode);
#else #else
firmwareError(OBD_PCM_Processor_Fault, "SPI1 not available in this binary"); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "SPI1 not available in this binary");
#endif /* STM32_SPI_USE_SPI1 */ #endif /* STM32_SPI_USE_SPI1 */
} }
if (device == SPI_DEVICE_2) { if (device == SPI_DEVICE_2) {
@ -555,7 +555,7 @@ void turnOnSpi(spi_device_e device) {
engineConfiguration->spi2MosiMode, engineConfiguration->spi2MosiMode,
engineConfiguration->spi2MisoMode); engineConfiguration->spi2MisoMode);
#else #else
firmwareError(OBD_PCM_Processor_Fault, "SPI2 not available in this binary"); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "SPI2 not available in this binary");
#endif /* STM32_SPI_USE_SPI2 */ #endif /* STM32_SPI_USE_SPI2 */
} }
if (device == SPI_DEVICE_3) { if (device == SPI_DEVICE_3) {
@ -568,7 +568,7 @@ void turnOnSpi(spi_device_e device) {
engineConfiguration->spi3MosiMode, engineConfiguration->spi3MosiMode,
engineConfiguration->spi3MisoMode); engineConfiguration->spi3MisoMode);
#else #else
firmwareError(OBD_PCM_Processor_Fault, "SPI3 not available in this binary"); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "SPI3 not available in this binary");
#endif /* STM32_SPI_USE_SPI3 */ #endif /* STM32_SPI_USE_SPI3 */
} }
if (device == SPI_DEVICE_4) { if (device == SPI_DEVICE_4) {
@ -577,7 +577,7 @@ void turnOnSpi(spi_device_e device) {
/* there are no configuration fields for SPI4 in engineConfiguration, rely on board init code /* there are no configuration fields for SPI4 in engineConfiguration, rely on board init code
* it should set proper functions for SPI4 pins */ * it should set proper functions for SPI4 pins */
#else #else
firmwareError(OBD_PCM_Processor_Fault, "SPI4 not available in this binary"); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "SPI4 not available in this binary");
#endif /* STM32_SPI_USE_SPI4 */ #endif /* STM32_SPI_USE_SPI4 */
} }
} }

4
firmware/hw_layer/sensors/hip9011.cpp
View File

@ -397,7 +397,7 @@ static int hip_init() {
ret = hip_testAdvMode(); ret = hip_testAdvMode();
if (ret) { if (ret) {
warning(CUSTOM_OBD_KNOCK_PROCESSOR, "TPIC/HIP does not support advanced mode"); warning(ObdCode::CUSTOM_OBD_KNOCK_PROCESSOR, "TPIC/HIP does not support advanced mode");
instance.adv_mode = false; instance.adv_mode = false;
} }
} }
@ -440,7 +440,7 @@ static msg_t hipThread(void *arg) {
/* retry until success */ /* retry until success */
ret = hip_init(); ret = hip_init();
if (ret) { if (ret) {
warning(CUSTOM_OBD_KNOCK_PROCESSOR, "TPIC/HIP does not respond: %d", ret); warning(ObdCode::CUSTOM_OBD_KNOCK_PROCESSOR, "TPIC/HIP does not respond: %d", ret);
chThdSleepMilliseconds(10 * 1000); chThdSleepMilliseconds(10 * 1000);
} }
} while (ret); } while (ret);

2
firmware/hw_layer/sensors/hip9011_logic.cpp
View File

@ -143,7 +143,7 @@ void HIP9011::setAngleWindowWidth(DEFINE_HIP_PARAMS) {
GET_CONFIG_VALUE(knockDetectionWindowStart); GET_CONFIG_VALUE(knockDetectionWindowStart);
if (new_angleWindowWidth < 0) { if (new_angleWindowWidth < 0) {
#if EFI_PROD_CODE #if EFI_PROD_CODE
warning(CUSTOM_KNOCK_WINDOW, "invalid knock window"); warning(ObdCode::CUSTOM_KNOCK_WINDOW, "invalid knock window");
#endif #endif
new_angleWindowWidth = 0; new_angleWindowWidth = 0;
} }

2
firmware/init/sensor/init_sensors.cpp
View File

@ -42,7 +42,7 @@ void deInitIfValid(const char* msg, adc_channel_e channel) {
static void initOldAnalogInputs() { static void initOldAnalogInputs() {
if (isAdcChannelValid(engineConfiguration->afr.hwChannel) && engineConfiguration->enableAemXSeries) { if (isAdcChannelValid(engineConfiguration->afr.hwChannel) && engineConfiguration->enableAemXSeries) {
firmwareError(OBD_PCM_Processor_Fault, "Please pick either analog AFR or CAN AFR input not both."); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "Please pick either analog AFR or CAN AFR input not both.");
} }
initIfValid("AFR", engineConfiguration->afr.hwChannel); initIfValid("AFR", engineConfiguration->afr.hwChannel);
initIfValid("AUXF#1", engineConfiguration->auxFastSensor1_adcChannel); initIfValid("AUXF#1", engineConfiguration->auxFastSensor1_adcChannel);

2
firmware/util/histogram.cpp
View File

@ -88,7 +88,7 @@ int histogramGetIndex(int64_t value) {
*/ */
void initHistogram(histogram_s *h, const char *name) { void initHistogram(histogram_s *h, const char *name) {
if (efiStrlen(name) > sizeof(h->name) - 1) { if (efiStrlen(name) > sizeof(h->name) - 1) {
firmwareError(ERROR_HISTO_NAME, "Histogram name [%s] too long", name); firmwareError(ObdCode::ERROR_HISTO_NAME, "Histogram name [%s] too long", name);
} }
strcpy(h->name, name); strcpy(h->name, name);
h->total_value = 0; h->total_value = 0;

2
firmware/util/math/interpolation.cpp
View File

@ -103,7 +103,7 @@ float interpolateMsg(const char *msg, float x1, float y1, float x2, float y2, fl
float interpolateClampedWithValidation(float x1, float y1, float x2, float y2, float x) { float interpolateClampedWithValidation(float x1, float y1, float x2, float y2, float x) {
if (x1 >= x2) { if (x1 >= x2) {
firmwareError(OBD_PCM_Processor_Fault, "interpolateClamped %f has to be smaller than %f", x1, x2); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "interpolateClamped %f has to be smaller than %f", x1, x2);
} }
return interpolateClamped(x1, y1, x2, y2, x); return interpolateClamped(x1, y1, x2, y2, x);
} }

4
misc/stm32f1_test_project/timer/event_queue.cpp
View File

@ -104,7 +104,7 @@ void EventQueue::remove(scheduling_s* scheduling) {
// Walked off the end, this is an error since this *should* have been scheduled // Walked off the end, this is an error since this *should* have been scheduled
if (!current) { if (!current) {
firmwareError(OBD_PCM_Processor_Fault, "EventQueue::remove didn't find element"); firmwareError(ObdCode::OBD_PCM_Processor_Fault, "EventQueue::remove didn't find element");
return; return;
} }
@ -239,7 +239,7 @@ int EventQueue::size(void) const {
void EventQueue::assertListIsSorted() const { void EventQueue::assertListIsSorted() const {
scheduling_s *current = head; scheduling_s *current = head;
while (current != NULL && current->nextScheduling_s != NULL) { while (current != NULL && current->nextScheduling_s != NULL) {
efiAssertVoid(CUSTOM_ERR_6623, current->momentX <= current->nextScheduling_s->momentX, "list order"); efiAssertVoid(ObdCode::CUSTOM_ERR_6623, current->momentX <= current->nextScheduling_s->momentX, "list order");
current = current->nextScheduling_s; current = current->nextScheduling_s;
} }
} }

4
misc/stm32f1_test_project/timer/event_queue.h
View File

@ -20,7 +20,7 @@
int counter = 0; \ int counter = 0; \
LL_FOREACH2(head, current, field) { \ LL_FOREACH2(head, current, field) { \
if (++counter > QUEUE_LENGTH_LIMIT) { \ if (++counter > QUEUE_LENGTH_LIMIT) { \
firmwareError(CUSTOM_ERR_LOOPED_QUEUE, "Looped queue?"); \ firmwareError(ObdCode::CUSTOM_ERR_LOOPED_QUEUE, "Looped queue?"); \
return false; \ return false; \
} \ } \
if (current == element) { \ if (current == element) { \
@ -29,7 +29,7 @@
* was not scheduled by angle but was scheduled by time. In case of scheduling \ * was not scheduled by angle but was scheduled by time. In case of scheduling \
* by time with slow RPM the whole next fast revolution might be within the wait period \ * by time with slow RPM the whole next fast revolution might be within the wait period \
*/ \ */ \
warning(CUSTOM_RE_ADDING_INTO_EXECUTION_QUEUE, "re-adding element into event_queue"); \ warning(ObdCode::CUSTOM_RE_ADDING_INTO_EXECUTION_QUEUE, "re-adding element into event_queue"); \
return true; \ return true; \
} \ } \
} \ } \

12
misc/stm32f1_test_project/timer/microsecond_timer.cpp
View File

@ -63,7 +63,7 @@ void setHardwareSchedulerTimer(efitick_t nowNt, efitick_t setTimeNt) {
*/ */
if (timeDeltaNt <= 0) { if (timeDeltaNt <= 0) {
timerFreezeCounter++; timerFreezeCounter++;
warning(CUSTOM_OBD_LOCAL_FREEZE, "local freeze cnt=%d", timerFreezeCounter); warning(ObdCode::CUSTOM_OBD_LOCAL_FREEZE, "local freeze cnt=%d", timerFreezeCounter);
} }
// We need the timer to fire after we return - 1 doesn't work as it may actually schedule in the past // We need the timer to fire after we return - 1 doesn't work as it may actually schedule in the past
@ -73,7 +73,7 @@ void setHardwareSchedulerTimer(efitick_t nowNt, efitick_t setTimeNt) {
if (timeDeltaNt >= TOO_FAR_INTO_FUTURE_NT) { if (timeDeltaNt >= TOO_FAR_INTO_FUTURE_NT) {
// we are trying to set callback for too far into the future. This does not look right at all // we are trying to set callback for too far into the future. This does not look right at all
firmwareError(CUSTOM_ERR_TIMER_OVERFLOW, "setHardwareSchedulerTimer() too far: %d", timeDeltaNt); firmwareError(ObdCode::CUSTOM_ERR_TIMER_OVERFLOW, "setHardwareSchedulerTimer() too far: %d", timeDeltaNt);
return; return;
} }
@ -108,13 +108,13 @@ class MicrosecondTimerWatchdogController : public PeriodicTimerController {
void PeriodicTask() override { void PeriodicTask() override {
efitick_t nowNt = getTimeNowNt(); efitick_t nowNt = getTimeNowNt();
if (nowNt >= lastSetTimerTimeNt + 2 * CORE_CLOCK) { if (nowNt >= lastSetTimerTimeNt + 2 * CORE_CLOCK) {
firmwareError(CUSTOM_ERR_SCHEDULING_ERROR, "watchdog: no events since %d", lastSetTimerTimeNt); firmwareError(ObdCode::CUSTOM_ERR_SCHEDULING_ERROR, "watchdog: no events since %d", lastSetTimerTimeNt);
return; return;
} }
msg = isTimerPending ? "No_cb too long" : "Timer not awhile"; msg = isTimerPending ? "No_cb too long" : "Timer not awhile";
// 2 seconds of inactivity would not look right // 2 seconds of inactivity would not look right
efiAssertVoid(CUSTOM_TIMER_WATCHDOG, nowNt < lastSetTimerTimeNt + 2 * CORE_CLOCK, msg); efiAssertVoid(ObdCode::CUSTOM_TIMER_WATCHDOG, nowNt < lastSetTimerTimeNt + 2 * CORE_CLOCK, msg);
} }
int getPeriodMs() override { int getPeriodMs() override {
@ -143,7 +143,7 @@ static void timerValidationCallback(void*) {
efitimems_t actualTimeSinceScheduling = (currentTimeMillis() - testSchedulingStart); efitimems_t actualTimeSinceScheduling = (currentTimeMillis() - testSchedulingStart);
if (absI(actualTimeSinceScheduling - TEST_CALLBACK_DELAY) > TEST_CALLBACK_DELAY * TIMER_PRECISION_THRESHOLD) { if (absI(actualTimeSinceScheduling - TEST_CALLBACK_DELAY) > TEST_CALLBACK_DELAY * TIMER_PRECISION_THRESHOLD) {
firmwareError(CUSTOM_ERR_TIMER_TEST_CALLBACK_WRONG_TIME, "hwTimer broken precision: %ld ms", actualTimeSinceScheduling); firmwareError(ObdCode::CUSTOM_ERR_TIMER_TEST_CALLBACK_WRONG_TIME, "hwTimer broken precision: %ld ms", actualTimeSinceScheduling);
} }
} }
@ -162,7 +162,7 @@ static void validateHardwareTimer() {
chThdSleepMilliseconds(TEST_CALLBACK_DELAY + 2); chThdSleepMilliseconds(TEST_CALLBACK_DELAY + 2);
if (!testSchedulingHappened) { if (!testSchedulingHappened) {
firmwareError(CUSTOM_ERR_TIMER_TEST_CALLBACK_NOT_HAPPENED, "hwTimer not alive"); firmwareError(ObdCode::CUSTOM_ERR_TIMER_TEST_CALLBACK_NOT_HAPPENED, "hwTimer not alive");
} }
} }

4
misc/stm32f1_test_project/timer/microsecond_timer_gpt.cpp
View File

@ -12,7 +12,7 @@ void portSetHardwareSchedulerTimer(efitick_t nowNt, efitick_t setTimeNt) {
} }
if (GPTDEVICE.state != GPT_READY) { if (GPTDEVICE.state != GPT_READY) {
firmwareError(CUSTOM_HW_TIMER, "HW timer state %d", GPTDEVICE.state); firmwareError(ObdCode::CUSTOM_HW_TIMER, "HW timer state %d", GPTDEVICE.state);
return; return;
} }
@ -34,7 +34,7 @@ static constexpr GPTConfig gpt5cfg = { 1000000, /* 1 MHz timer clock.*/
void portInitMicrosecondTimer() { void portInitMicrosecondTimer() {
gptStart(&GPTDEVICE, &gpt5cfg); gptStart(&GPTDEVICE, &gpt5cfg);
efiAssertVoid(CUSTOM_ERR_TIMER_STATE, GPTDEVICE.state == GPT_READY, "hw state"); efiAssertVoid(ObdCode::CUSTOM_ERR_TIMER_STATE, GPTDEVICE.state == GPT_READY, "hw state");
} }
#endif // EFI_PROD_CODE #endif // EFI_PROD_CODE

34
misc/stm32f1_test_project/timer/pwm_generator_logic.cpp
View File

@ -53,13 +53,13 @@ void SimplePwm::setSimplePwmDutyCycle(float dutyCycle) {
return; return;
} }
if (cisnan(dutyCycle)) { if (cisnan(dutyCycle)) {
warning(CUSTOM_DUTY_INVALID, "%s spwd:dutyCycle %.2f", name, dutyCycle); warning(ObdCode::CUSTOM_DUTY_INVALID, "%s spwd:dutyCycle %.2f", name, dutyCycle);
return; return;
} else if (dutyCycle < 0) { } else if (dutyCycle < 0) {
warning(CUSTOM_DUTY_TOO_LOW, "%s dutyCycle too low %.2f", name, dutyCycle); warning(ObdCode::CUSTOM_DUTY_TOO_LOW, "%s dutyCycle too low %.2f", name, dutyCycle);
dutyCycle = 0; dutyCycle = 0;
} else if (dutyCycle > 1) { } else if (dutyCycle > 1) {
warning(CUSTOM_PWM_DUTY_TOO_HIGH, "%s duty too high %.2f", name, dutyCycle); warning(ObdCode::CUSTOM_PWM_DUTY_TOO_HIGH, "%s duty too high %.2f", name, dutyCycle);
dutyCycle = 1; dutyCycle = 1;
} }
@ -134,7 +134,7 @@ void PwmConfig::stop() {
void PwmConfig::handleCycleStart() { void PwmConfig::handleCycleStart() {
if (safe.phaseIndex != 0) { if (safe.phaseIndex != 0) {
// https://github.com/rusefi/rusefi/issues/1030 // https://github.com/rusefi/rusefi/issues/1030
firmwareError(CUSTOM_PWM_CYCLE_START, "handleCycleStart %d", safe.phaseIndex); firmwareError(ObdCode::CUSTOM_PWM_CYCLE_START, "handleCycleStart %d", safe.phaseIndex);
return; return;
} }
@ -144,8 +144,8 @@ void PwmConfig::handleCycleStart() {
// Compute the maximum number of iterations without overflowing a uint32_t worth of timestamp // Compute the maximum number of iterations without overflowing a uint32_t worth of timestamp
uint32_t iterationLimit = (0xFFFFFFFF / periodNt) - 2; uint32_t iterationLimit = (0xFFFFFFFF / periodNt) - 2;
efiAssertVoid(CUSTOM_ERR_6580, periodNt != 0, "period not initialized"); efiAssertVoid(ObdCode::CUSTOM_ERR_6580, periodNt != 0, "period not initialized");
efiAssertVoid(CUSTOM_ERR_6580, iterationLimit > 0, "iterationLimit invalid"); efiAssertVoid(ObdCode::CUSTOM_ERR_6580, iterationLimit > 0, "iterationLimit invalid");
if (forceCycleStart || safe.periodNt != periodNt || safe.iteration == iterationLimit) { if (forceCycleStart || safe.periodNt != periodNt || safe.iteration == iterationLimit) {
/** /**
* period length has changed - we need to reset internal state * period length has changed - we need to reset internal state
@ -243,7 +243,7 @@ static void timerCallback(PwmConfig *state) {
ScopePerf perf(PE::PwmGeneratorCallback); ScopePerf perf(PE::PwmGeneratorCallback);
state->dbgNestingLevel++; state->dbgNestingLevel++;
efiAssertVoid(CUSTOM_ERR_6581, state->dbgNestingLevel < 25, "PWM nesting issue"); efiAssertVoid(ObdCode::CUSTOM_ERR_6581, state->dbgNestingLevel < 25, "PWM nesting issue");
efitick_t switchTimeNt = state->togglePwmState(); efitick_t switchTimeNt = state->togglePwmState();
if (switchTimeNt == 0) { if (switchTimeNt == 0) {
@ -251,7 +251,7 @@ static void timerCallback(PwmConfig *state) {
return; return;
} }
if (state->executor == nullptr) { if (state->executor == nullptr) {
firmwareError(CUSTOM_NULL_EXECUTOR, "exec on %s", state->name); firmwareError(ObdCode::CUSTOM_NULL_EXECUTOR, "exec on %s", state->name);
return; return;
} }
@ -281,16 +281,16 @@ void PwmConfig::weComplexInit(const char *msg, ExecutorInterface *executor,
this->executor = executor; this->executor = executor;
isStopRequested = false; isStopRequested = false;
efiAssertVoid(CUSTOM_ERR_6582, periodNt != 0, "period is not initialized"); efiAssertVoid(ObdCode::CUSTOM_ERR_6582, periodNt != 0, "period is not initialized");
if (seq->phaseCount == 0) { if (seq->phaseCount == 0) {
firmwareError(CUSTOM_ERR_PWM_1, "signal length cannot be zero"); firmwareError(ObdCode::CUSTOM_ERR_PWM_1, "signal length cannot be zero");
return; return;
} }
if (seq->phaseCount > PWM_PHASE_MAX_COUNT) { if (seq->phaseCount > PWM_PHASE_MAX_COUNT) {
firmwareError(CUSTOM_ERR_PWM_2, "too many phases in PWM"); firmwareError(ObdCode::CUSTOM_ERR_PWM_2, "too many phases in PWM");
return; return;
} }
efiAssertVoid(CUSTOM_ERR_6583, seq->waveCount > 0, "waveCount should be positive"); efiAssertVoid(ObdCode::CUSTOM_ERR_6583, seq->waveCount > 0, "waveCount should be positive");
this->pwmCycleCallback = pwmCycleCallback; this->pwmCycleCallback = pwmCycleCallback;
this->stateChangeCallback = stateChangeCallback; this->stateChangeCallback = stateChangeCallback;
@ -307,10 +307,10 @@ void PwmConfig::weComplexInit(const char *msg, ExecutorInterface *executor,
void startSimplePwm(SimplePwm *state, const char *msg, ExecutorInterface *executor, void startSimplePwm(SimplePwm *state, const char *msg, ExecutorInterface *executor,
OutputPin *output, float frequency, float dutyCycle) { OutputPin *output, float frequency, float dutyCycle) {
efiAssertVoid(CUSTOM_ERR_PWM_STATE_ASSERT, state != NULL, "state"); efiAssertVoid(ObdCode::CUSTOM_ERR_PWM_STATE_ASSERT, state != NULL, "state");
efiAssertVoid(CUSTOM_ERR_PWM_DUTY_ASSERT, dutyCycle >= 0 && dutyCycle <= 1, "dutyCycle"); efiAssertVoid(ObdCode::CUSTOM_ERR_PWM_DUTY_ASSERT, dutyCycle >= 0 && dutyCycle <= 1, "dutyCycle");
if (frequency < 1) { if (frequency < 1) {
warning(CUSTOM_OBD_LOW_FREQUENCY, "low frequency %.2f %s", frequency, msg); warning(ObdCode::CUSTOM_OBD_LOW_FREQUENCY, "low frequency %.2f %s", frequency, msg);
return; return;
} }
@ -372,8 +372,8 @@ void applyPinState(int stateIndex, PwmConfig *state) /* pwm_gen_callback */ {
} }
#endif // EFI_PROD_CODE #endif // EFI_PROD_CODE
efiAssertVoid(CUSTOM_ERR_6663, stateIndex < PWM_PHASE_MAX_COUNT, "invalid stateIndex"); efiAssertVoid(ObdCode::CUSTOM_ERR_6663, stateIndex < PWM_PHASE_MAX_COUNT, "invalid stateIndex");
efiAssertVoid(CUSTOM_ERR_6664, state->multiChannelStateSequence->waveCount <= PWM_PHASE_MAX_WAVE_PER_PWM, "invalid waveCount"); efiAssertVoid(ObdCode::CUSTOM_ERR_6664, state->multiChannelStateSequence->waveCount <= PWM_PHASE_MAX_WAVE_PER_PWM, "invalid waveCount");
for (int channelIndex = 0; channelIndex < state->multiChannelStateSequence->waveCount; channelIndex++) { for (int channelIndex = 0; channelIndex < state->multiChannelStateSequence->waveCount; channelIndex++) {
OutputPin *output = state->outputPins[channelIndex]; OutputPin *output = state->outputPins[channelIndex];
int value = state->multiChannelStateSequence->getChannelState(channelIndex, stateIndex); int value = state->multiChannelStateSequence->getChannelState(channelIndex, stateIndex);

2
misc/stm32f1_test_project/timer/scheduler.cpp
View File

@ -8,7 +8,7 @@
#include "scheduler.h" #include "scheduler.h"
void action_s::execute() { void action_s::execute() {
efiAssertVoid(CUSTOM_ERR_ASSERT, callback != NULL, "callback==null1"); efiAssertVoid(ObdCode::CUSTOM_ERR_ASSERT, callback != NULL, "callback==null1");
callback(param); callback(param);
} }

10
misc/stm32f1_test_project/timer/single_timer_executor.cpp
View File

@ -34,7 +34,7 @@
uint32_t hwSetTimerDuration; uint32_t hwSetTimerDuration;
void globalTimerCallback() { void globalTimerCallback() {
efiAssertVoid(CUSTOM_ERR_6624, getCurrentRemainingStack() > EXPECTED_REMAINING_STACK, "lowstck#2y"); efiAssertVoid(ObdCode::CUSTOM_ERR_6624, getCurrentRemainingStack() > EXPECTED_REMAINING_STACK, "lowstck#2y");
___engine.executor.onTimerCallback(); ___engine.executor.onTimerCallback();
} }
@ -71,7 +71,7 @@ void SingleTimerExecutor::scheduleByTimestampNt(const char *msg, scheduling_s* s
if (deltaTimeNt >= TOO_FAR_INTO_FUTURE_NT) { if (deltaTimeNt >= TOO_FAR_INTO_FUTURE_NT) {
// we are trying to set callback for too far into the future. This does not look right at all // we are trying to set callback for too far into the future. This does not look right at all
firmwareError(CUSTOM_ERR_TASK_TIMER_OVERFLOW, "scheduleByTimestampNt() too far: %d %s", deltaTimeNt, msg); firmwareError(ObdCode::CUSTOM_ERR_TASK_TIMER_OVERFLOW, "scheduleByTimestampNt() too far: %d %s", deltaTimeNt, msg);
return; return;
} }
#endif #endif
@ -136,7 +136,7 @@ void SingleTimerExecutor::executeAllPendingActions() {
// if we're stuck in a loop executing lots of events, panic! // if we're stuck in a loop executing lots of events, panic!
if (executeCounter++ == 500) { if (executeCounter++ == 500) {
firmwareError(CUSTOM_ERR_LOCK_ISSUE, "Maximum scheduling run length exceeded - CPU load too high"); firmwareError(ObdCode::CUSTOM_ERR_LOCK_ISSUE, "Maximum scheduling run length exceeded - CPU load too high");
} }
} while (didExecute); } while (didExecute);
@ -144,7 +144,7 @@ void SingleTimerExecutor::executeAllPendingActions() {
maxExecuteCounter = maxI(maxExecuteCounter, executeCounter); maxExecuteCounter = maxI(maxExecuteCounter, executeCounter);
if (!isLocked()) { if (!isLocked()) {
firmwareError(CUSTOM_ERR_LOCK_ISSUE, "Someone has stolen my lock"); firmwareError(ObdCode::CUSTOM_ERR_LOCK_ISSUE, "Someone has stolen my lock");
return; return;
} }
reentrantFlag = false; reentrantFlag = false;
@ -166,7 +166,7 @@ void SingleTimerExecutor::scheduleTimerCallback() {
return; // no pending events in the queue return; // no pending events in the queue
} }
efiAssertVoid(CUSTOM_ERR_6625, nextEventTimeNt.Value > nowNt, "setTimer constraint"); efiAssertVoid(ObdCode::CUSTOM_ERR_6625, nextEventTimeNt.Value > nowNt, "setTimer constraint");
setHardwareSchedulerTimer(nowNt, nextEventTimeNt.Value); setHardwareSchedulerTimer(nowNt, nextEventTimeNt.Value);
} }