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 2015-09-08 23:01:07 -04:00
parent d48f35ada3
commit 81eb37f58c
5 changed files with 53 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -177,8 +177,8 @@ void TriggerCentral::handleShaftSignal(trigger_event_e signal DECLARE_ENGINE_PAR
return;
}
if (triggerState.current_index >= TRIGGER_SHAPE(size)) {
warning(OBD_PCM_Processor_Fault, "unexpected eventIndex=%d", triggerState.current_index);
if (triggerState.currentCycle.current_index >= TRIGGER_SHAPE(size)) {
warning(OBD_PCM_Processor_Fault, "unexpected eventIndex=%d", triggerState.currentCycle.current_index);
} else {
/**

38
firmware/controllers/trigger/trigger_decoder.cpp
View File

@ -75,27 +75,27 @@ static trigger_wheel_e eventIndex[6] = { T_PRIMARY, T_PRIMARY, T_SECONDARY, T_SE
#define nextTriggerEvent() \
{ \
efitime_t prevTime = timeOfPreviousEventNt[triggerWheel]; \
efitime_t prevTime = currentCycle.timeOfPreviousEventNt[triggerWheel]; \
if (prevTime != 0) { \
/* even event - apply the value*/ \
totalTimeNt[triggerWheel] += (nowNt - prevTime); \
timeOfPreviousEventNt[triggerWheel] = 0; \
currentCycle.totalTimeNt[triggerWheel] += (nowNt - prevTime); \
currentCycle.timeOfPreviousEventNt[triggerWheel] = 0; \
} else { \
/* odd event - start accumulation */ \
timeOfPreviousEventNt[triggerWheel] = nowNt; \
currentCycle.timeOfPreviousEventNt[triggerWheel] = nowNt; \
} \
if (engineConfiguration->useOnlyFrontForTrigger) {current_index++;} \
current_index++; \
if (engineConfiguration->useOnlyFrontForTrigger) {currentCycle.current_index++;} \
currentCycle.current_index++; \
}
#define nextRevolution() { \
if (cycleCallback != NULL) { \
cycleCallback(this); \
} \
memcpy(prevTotalTime, totalTimeNt, sizeof(prevTotalTime)); \
memcpy(prevTotalTime, currentCycle.totalTimeNt, sizeof(prevTotalTime)); \
prevCycleDuration = nowNt - startOfCycleNt; \
startOfCycleNt = nowNt; \
clear(); \
resetCurrentCycleState(); \
totalRevolutionCounter++; \
runningRevolutionCounter++; \
totalEventCountBase += TRIGGER_SHAPE(size); \
@ -120,7 +120,7 @@ void TriggerState::decodeTriggerEvent(trigger_event_e const signal, efitime_t no
prevSignal = curSignal;
curSignal = signal;
eventCount[triggerWheel]++;
currentCycle.eventCount[triggerWheel]++;
efitime_t currentDurationLong = getCurrentGapDuration(nowNt);
@ -181,7 +181,7 @@ void TriggerState::decodeTriggerEvent(trigger_event_e const signal, efitime_t no
#endif /* EFI_PROD_CODE */
float gap = 1.0 * currentDuration / toothed_previous_duration;
#if EFI_PROD_CODE
scheduleMsg(logger, "gap=%f @ %d", gap, current_index);
scheduleMsg(logger, "gap=%f @ %d", gap, currentCycle.current_index);
#else
actualSynchGap = gap;
print("current gap %f\r\n", gap);
@ -193,7 +193,7 @@ void TriggerState::decodeTriggerEvent(trigger_event_e const signal, efitime_t no
* in case of noise the counter could be above the expected number of events
*/
int d = engineConfiguration->useOnlyFrontForTrigger ? 2 : 1;
isSynchronizationPoint = !shaft_is_synchronized || (current_index >= TRIGGER_SHAPE(size) - d);
isSynchronizationPoint = !shaft_is_synchronized || (currentCycle.current_index >= TRIGGER_SHAPE(size) - d);
}
@ -201,7 +201,7 @@ void TriggerState::decodeTriggerEvent(trigger_event_e const signal, efitime_t no
if (printTriggerDebug) {
printf("%s isSynchronizationPoint=%d index=%d %s\r\n",
getTrigger_type_e(engineConfiguration->trigger.type),
isSynchronizationPoint, current_index,
isSynchronizationPoint, currentCycle.current_index,
getTrigger_event_e(signal));
}
#endif
@ -211,9 +211,9 @@ void TriggerState::decodeTriggerEvent(trigger_event_e const signal, efitime_t no
/**
* We can check if things are fine by comparing the number of events in a cycle with the expected number of event.
*/
bool isDecodingError = eventCount[0] != TRIGGER_SHAPE(expectedEventCount[0])
|| eventCount[1] != TRIGGER_SHAPE(expectedEventCount[1])
|| eventCount[2] != TRIGGER_SHAPE(expectedEventCount[2]);
bool isDecodingError = currentCycle.eventCount[0] != TRIGGER_SHAPE(expectedEventCount[0])
|| currentCycle.eventCount[1] != TRIGGER_SHAPE(expectedEventCount[1])
|| currentCycle.eventCount[2] != TRIGGER_SHAPE(expectedEventCount[2]);
triggerDecoderErrorPin.setValue(isDecodingError);
if (isDecodingError) {
@ -221,9 +221,9 @@ void TriggerState::decodeTriggerEvent(trigger_event_e const signal, efitime_t no
totalTriggerErrorCounter++;
if (engineConfiguration->isPrintTriggerSynchDetails) {
#if EFI_PROD_CODE
scheduleMsg(logger, "error: synchronizationPoint @ index %d expected %d/%d/%d got %d/%d/%d", current_index,
scheduleMsg(logger, "error: synchronizationPoint @ index %d expected %d/%d/%d got %d/%d/%d", currentCycle.current_index,
TRIGGER_SHAPE(expectedEventCount[0]), TRIGGER_SHAPE(expectedEventCount[1]),
TRIGGER_SHAPE(expectedEventCount[2]), eventCount[0], eventCount[1], eventCount[2]);
TRIGGER_SHAPE(expectedEventCount[2]), currentCycle.eventCount[0], currentCycle.eventCount[1], currentCycle.eventCount[2]);
#endif /* EFI_PROD_CODE */
}
}
@ -233,7 +233,7 @@ void TriggerState::decodeTriggerEvent(trigger_event_e const signal, efitime_t no
if (isTriggerDecoderError()) {
warning(OBD_PCM_Processor_Fault, "trigger decoding issue. expected %d/%d/%d got %d/%d/%d",
TRIGGER_SHAPE(expectedEventCount[0]), TRIGGER_SHAPE(expectedEventCount[1]),
TRIGGER_SHAPE(expectedEventCount[2]), eventCount[0], eventCount[1], eventCount[2]);
TRIGGER_SHAPE(expectedEventCount[2]), currentCycle.eventCount[0], currentCycle.eventCount[1], currentCycle.eventCount[2]);
}
shaft_is_synchronized = true;
@ -484,7 +484,7 @@ void TriggerStimulatorHelper::nextStep(TriggerState *state, TriggerShape * shape
static void onFindIndex(TriggerState *state) {
for (int i = 0; i < PWM_PHASE_MAX_WAVE_PER_PWM; i++) {
// todo: that's not the best place for this intermediate data storage, fix it!
state->expectedTotalTime[i] = state->totalTimeNt[i];
state->expectedTotalTime[i] = state->currentCycle.totalTimeNt[i];
}
}

38
firmware/controllers/trigger/trigger_decoder.h
View File

@ -19,6 +19,24 @@ class TriggerState;
typedef void (*TriggerStateCallback)(TriggerState *);
typedef struct {
/**
* Here we accumulate the amount of time this signal was ON within current trigger cycle
*/
int totalTimeNt[PWM_PHASE_MAX_WAVE_PER_PWM];
/**
* index within trigger revolution, from 0 to trigger event count
*/
uint32_t current_index;
/**
* Number of actual events within current trigger cycle
* see TriggerShape
*/
uint32_t eventCount[PWM_PHASE_MAX_WAVE_PER_PWM];
efitime_t timeOfPreviousEventNt[PWM_PHASE_MAX_WAVE_PER_PWM];
} current_cycle_state_s;
class TriggerState {
public:
TriggerState();
@ -43,10 +61,7 @@ public:
uint32_t currentDuration;
efitime_t toothed_previous_time;
/**
* Here we accumulate the amount of time this signal was ON within current trigger cycle
*/
int totalTimeNt[PWM_PHASE_MAX_WAVE_PER_PWM];
current_cycle_state_s currentCycle;
/**
* Total time result for previous trigger cycle
*/
@ -62,23 +77,12 @@ public:
void resetRunningCounters();
/**
* index within trigger revolution, from 0 to trigger event count
*/
uint32_t current_index;
uint32_t runningRevolutionCounter;
private:
void clear();
/**
* Number of actual events within current trigger cycle
* see TriggerShape
*/
uint32_t eventCount[PWM_PHASE_MAX_WAVE_PER_PWM];
void resetCurrentCycleState();
trigger_event_e curSignal;
trigger_event_e prevSignal;
uint32_t eventCountExt[2 * PWM_PHASE_MAX_WAVE_PER_PWM];
efitime_t timeOfPreviousEventNt[PWM_PHASE_MAX_WAVE_PER_PWM];
efitime_t totalEventCountBase;
uint32_t totalRevolutionCounter;
bool isFirstEvent;

16
firmware/controllers/trigger/trigger_structure.cpp
View File

@ -164,14 +164,14 @@ TriggerState::TriggerState() {
startOfCycleNt = 0;
resetRunningCounters();
clear();
resetCurrentCycleState();
memset(expectedTotalTime, 0, sizeof(expectedTotalTime));
totalEventCountBase = 0;
isFirstEvent = true;
}
int TriggerState::getCurrentIndex() {
return current_index;
return currentCycle.current_index;
}
efitime_t TriggerState::getStartOfRevolutionIndex() {
@ -185,18 +185,18 @@ void TriggerState::resetRunningCounters() {
}
efitime_t TriggerState::getTotalEventCounter() {
return totalEventCountBase + current_index;
return totalEventCountBase + currentCycle.current_index;
}
int TriggerState::getTotalRevolutionCounter() {
return totalRevolutionCounter;
}
void TriggerState::clear() {
memset(eventCount, 0, sizeof(eventCount));
memset(timeOfPreviousEventNt, 0, sizeof(timeOfPreviousEventNt));
memset(totalTimeNt, 0, sizeof(totalTimeNt));
current_index = 0;
void TriggerState::resetCurrentCycleState() {
memset(currentCycle.eventCount, 0, sizeof(currentCycle.eventCount));
memset(currentCycle.timeOfPreviousEventNt, 0, sizeof(currentCycle.timeOfPreviousEventNt));
memset(currentCycle.totalTimeNt, 0, sizeof(currentCycle.totalTimeNt));
currentCycle.current_index = 0;
}
/**

3
firmware/controllers/trigger/trigger_structure.h
View File

@ -90,6 +90,9 @@ public:
*/
float eventAngles[PWM_PHASE_MAX_COUNT];
uint32_t timeOfLastEvent[PWM_PHASE_MAX_COUNT];
float instantRpmValue[PWM_PHASE_MAX_COUNT];
int8_t isFrontEvent[PWM_PHASE_MAX_COUNT];
/**
* this table translates trigger definition index into 'front-only' index. This translation is not so trivial