//draw icons and set status by current mode.
void drawIconsByMode(int iTotalPage)
{
// freeze toolbar
tbDisableUpdate(toolbarChannel, ER_SCRIBBLE_UA_ID);
// clear the toolbar
tbClearIconSet(toolbarChannel, ER_SCRIBBLE_UA_ID);
switch ( getOperationMode() )
{
case MODE_INVALID:
addIconsByListMode(ICONS_FLDALL);
break;
case MODE_DRAW:
addIconsByListMode(ICONS_FLDALL);
activeIcon( iconID_pen );
break;
case MODE_SELSIZE:
addIconsByListMode(ICONLIST_UNFLDSIZE);
activeIcon( getIconfromPenSize(getPenSize(), LIST_INDEX_ICONLOW) );
activeIcon( iconID_pen );
break;
case MODE_SELCOLOR:
addIconsByListMode(ICONLIST_UNFLDCOLOR);
activeIcon( getIconfromPenColor(getPenColor(), LIST_INDEX_ICONLOW) );
activeIcon( iconID_pen );
break;
case MODE_ERASE:
addIconsByListMode(ICONS_FLDALL);
activeIcon( iconID_eraseline );
break;
case MODE_DELPAGE:
addIconsByListMode(ICONS_FLDALL);
activeIcon( iconID_trashcan );
break;
default:
SB_ERRORPRINTF("Error Mode[%d]\n", getOperationMode());
return;
}
if( iTotalPage<=1 )
{
disableIcon(iconID_trashcan);
}
// redraw toolbar now
tbEnableUpdate(toolbarChannel, ER_SCRIBBLE_UA_ID);
}
//reinit the toolbar,reset all the status,include the pages
void toolbar_reinit(int iTotalPage)
{
//change the current mode only if current is mode_draw or erase.
if( MODE_DELPAGE==getOperationMode() )
{
setOperationMode(MODE_DRAW);
}
drawIconsByMode(iTotalPage);
}
void TriggerCentral::handleShaftSignal(trigger_event_e signal DECLARE_ENGINE_PARAMETER_S) {
efiAssertVoid(engine!=NULL, "configuration");
nowNt = getTimeNowNt();
efiAssertVoid(engine->engineConfiguration!=NULL, "engineConfiguration");
efiAssertVoid(engine->engineConfiguration2!=NULL, "engineConfiguration2");
engine->onTriggerEvent(nowNt);
#if EFI_HISTOGRAMS && EFI_PROD_CODE
int beforeCallback = hal_lld_get_counter_value();
#endif
int eventIndex = (int) signal;
efiAssertVoid(eventIndex >= 0 && eventIndex < HW_EVENT_TYPES, "signal type");
hwEventCounters[eventIndex]++;
if (nowNt - previousShaftEventTimeNt > US2NT(US_PER_SECOND_LL)) {
/**
* We are here if there is a time gap between now and previous shaft event - that means the engine is not runnig.
* That means we have lost synchronization since the engine is not running :)
*/
triggerState.shaft_is_synchronized = false;
}
previousShaftEventTimeNt = nowNt;
/**
* This invocation changes the state of triggerState
*/
triggerState.decodeTriggerEvent(signal, nowNt PASS_ENGINE_PARAMETER);
if (!triggerState.shaft_is_synchronized) {
// we should not propagate event if we do not know where we are
return;
}
/**
* If we only have a crank position sensor, here we are extending crank revolutions with a 360 degree
* cycle into a four stroke, 720 degrees cycle. TODO
*/
int triggerIndexForListeners;
if (getOperationMode(engine->engineConfiguration) == FOUR_STROKE_CAM_SENSOR) {
// That's easy - trigger cycle matches engine cycle
triggerIndexForListeners = triggerState.getCurrentIndex();
} else {
bool isEven = triggerState.getTotalRevolutionCounter() & 1;
triggerIndexForListeners = triggerState.getCurrentIndex() + (isEven ? 0 : TRIGGER_SHAPE(size));
}
reportEventToWaveChart(signal, triggerIndexForListeners);
if (triggerState.current_index >= TRIGGER_SHAPE(size)) {
warning(OBD_PCM_Processor_Fault, "unexpected eventIndex=%d", triggerState.current_index);
} else {
/**
* Here we invoke all the listeners - the main engine control logic is inside these listeners
*/
for (int i = 0; i < triggerListeneres.currentListenersCount; i++) {
ShaftPositionListener listener = (ShaftPositionListener) triggerListeneres.callbacks[i];
(listener)(signal, triggerIndexForListeners PASS_ENGINE_PARAMETER);
}
}
#if EFI_HISTOGRAMS && EFI_PROD_CODE
int afterCallback = hal_lld_get_counter_value();
int diff = afterCallback - beforeCallback;
// this counter is only 32 bits so it overflows every minute, let's ignore the value in case of the overflow for simplicity
if (diff > 0) {
hsAdd(&triggerCallback, diff);
}
#endif /* EFI_HISTOGRAMS */
}
/**
* Trigger event count equals engine cycle event count if we have a cam sensor.
* Two trigger cycles make one engine cycle in case of a four stroke engine If we only have a cranksensor.
*/
int getEngineCycleEventCount(engine_configuration_s const *engineConfiguration, trigger_shape_s * s) {
return getEngineCycleEventCount2(getOperationMode(engineConfiguration), s);
}
/**
* External logger is needed because at this point our logger is not yet initialized
*/
void initializeTriggerShape(Logging *logger, engine_configuration_s *engineConfiguration,
engine_configuration2_s *engineConfiguration2) {
#if EFI_PROD_CODE
scheduleMsg(logger, "initializeTriggerShape()");
#endif
trigger_config_s *triggerConfig = &engineConfiguration->triggerConfig;
trigger_shape_s *triggerShape = &engineConfiguration2->triggerShape;
setTriggerSynchronizationGap(triggerShape, 2);
triggerShape->useRiseEdge = TRUE;
switch (triggerConfig->triggerType) {
case TT_TOOTHED_WHEEL:
// todo: move to into configuration definition engineConfiguration2->triggerShape.needSecondTriggerInput = false;
engineConfiguration2->triggerShape.isSynchronizationNeeded =
engineConfiguration->triggerConfig.customIsSynchronizationNeeded;
initializeSkippedToothTriggerShapeExt(triggerShape, triggerConfig->customTotalToothCount,
triggerConfig->customSkippedToothCount, getOperationMode(engineConfiguration));
return;
case TT_MAZDA_MIATA_NA:
initializeMazdaMiataNaShape(triggerShape);
return;
case TT_MAZDA_MIATA_NB:
initializeMazdaMiataNbShape(triggerShape);
return;
case TT_DODGE_NEON:
configureNeonTriggerShape(triggerShape);
return;
case TT_FORD_ASPIRE:
configureFordAspireTriggerShape(triggerConfig, triggerShape);
return;
case TT_GM_7X:
configureGmTriggerShape(triggerConfig, triggerShape);
return;
case TT_FORD_ESCORT_GT:
configureMazdaProtegeLx(triggerShape);
return;
case TT_MINI_COOPER_R50:
configureMiniCooperTriggerShape(triggerShape);
return;
case TT_TOOTHED_WHEEL_60_2:
setToothedWheelConfiguration(triggerShape, 60, 2, engineConfiguration);
setTriggerSynchronizationGap(triggerShape, 2.5);
return;
case TT_TOOTHED_WHEEL_36_1:
setToothedWheelConfiguration(triggerShape, 36, 1, engineConfiguration);
return;
case TT_HONDA_ACCORD_CD_TWO_WIRES:
configureHondaAccordCD(triggerShape, false);
return;
case TT_HONDA_ACCORD_CD:
configureHondaAccordCD(triggerShape, true);
return;
case TT_HONDA_ACCORD_CD_DIP:
configureHondaAccordCDDip(triggerShape);
return;
case TT_MITSU:
initializeMitsubishi4g18(triggerShape);
return;
default:
firmwareError("initializeTriggerShape() not implemented: %d", triggerConfig->triggerType);
;
}
if (engineConfiguration2->triggerShape.shaftPositionEventCount != engineConfiguration2->triggerShape.getSize())
firmwareError("trigger size or shaftPositionEventCount?");
}
void toolbar_key_selected(int iconID, int iconState,PScribbleUICtx pScribbleUICtx)
{
if( iconState_grey==iconState )
{
return;//donothing.
}
SB_IPCPRINTF("\n====iconID=%d[mode=%d,pensize=%d,color=%d]\n",
iconID,getOperationMode(),getPenSize(),getPenColor());
gboolean bNeedFlushWithFullQlt=FALSE;
//need full update when return from erase mode.
if( getOperationMode()== MODE_ERASE)
{
//every erase stroke ,we do it, so it's useless
//core_redrawBgAndStrks(pScribbleUICtx);
bNeedFlushWithFullQlt=TRUE;
}
//we should add deal to pageup/pagedown
switch (iconID)
{
case iconID_pen:
//we switch by whether or not user is drawing
if( !toolbar_is_drawing() )
{
setOperationMode(MODE_DRAW);
}
else
{
setOperationMode(MODE_INVALID);
}
break;
case iconID_pen1pixel:
case iconID_pen3pixel:
case iconID_pen5pixel:
case iconID_pen7pixel:
//enter select mode
setOperationMode(MODE_SELSIZE);
break;
case iconID_pen1pixelLow:
case iconID_pen3pixelLow:
case iconID_pen5pixelLow:
case iconID_pen7pixelLow:
//confirm the select
setPenSize(getPenSizefromIcon(iconID));
setOperationMode(MODE_DRAW);
break;
case iconID_penwhite://WHITE
case iconID_penlightgrey://LIGHT_GRAY
case iconID_pendarkgrey://DARK_GRAY
case iconID_penblack://BLACK
//enter select mode
setOperationMode(MODE_SELCOLOR);
break;
case iconID_penwhiteLow://WHITE
case iconID_penlightgreyLow://LIGHT_GRAY
case iconID_pendarkgreyLow://DARK_GRAY
case iconID_penblackLow://BLACK
//confirm the select
setPenColor(getPenColorfromIcon(iconID));
setOperationMode(MODE_DRAW);
break;
case iconID_eraseline:
if( MODE_ERASE==getOperationMode())
{
setOperationMode(MODE_DRAW);
}
else
{
setOperationMode(MODE_ERASE);
}
break;
case iconID_trashcan://delete page
if(MODE_DELPAGE==getOperationMode())
{
setOperationMode(MODE_DRAW);
if(ispagedel_confirmed)
{
//delete page
delOnepage(pScribbleUICtx);
ispagedel_confirmed=FALSE;
return;//tool bar will be updated when jumping
}
ispagedel_confirmed=FALSE;
}
else
{
SB_IPCPRINTF("enter MODE_DELPAGE\n");
setOperationMode(MODE_DELPAGE);
ispagedel_confirmed=FALSE;
}
break;
case iconID_npage:
addOnepage(pScribbleUICtx);
return;//tool bar will be updated when jumping
default:
SB_IPCPRINTF("Unknown iconID [%d]\n", iconID);
return;
}
drawIconsByMode(getTotalPage(&pScribbleUICtx->fileManager));
//flush the pixmap to gdk_buffer,but now every stroke is flush,so it's useless.
//flushPixMap(pScribbleUICtx);
if(bNeedFlushWithFullQlt)
{
display_update_request_screen_refresh
(MAIN_WINDOW_EXPOSE_LEVEL,(gpointer)dmQFull);
}
else
{
display_update_request_screen_refresh
(MAIN_WINDOW_EXPOSE_LEVEL,(gpointer)dmQTyping);
}
SB_IPCPRINTF("\n===end===[mode=%d,pensize=%d,color=%d]\n",
getOperationMode(),getPenSize(),getPenColor());
return;
}
