void KviTalFileDialog::setFileMode(FileMode m)
{
switch(m)
{
#if defined(COMPILE_KDE4_SUPPORT)
case AnyFile:
setMode(KFile::File | KFile::LocalOnly);
setOperationMode(Saving);
break;
case ExistingFile:
setMode(KFile::File | KFile::ExistingOnly | KFile::LocalOnly);
setOperationMode(Opening);
break;
case ExistingFiles:
setMode(KFile::Files | KFile::ExistingOnly | KFile::LocalOnly);
setOperationMode(Opening);
break;
case Directory:
setMode(KFile::Directory);
break;
case DirectoryOnly:
setMode(KFile::Directory);
break;
default:
setMode(KFile::File | KFile::LocalOnly);
setOperationMode(Saving);
break;
#else //!defined(COMPILE_KDE4_SUPPORT)
case AnyFile:
QFileDialog::setFileMode(QFileDialog::AnyFile);
setAcceptMode(QFileDialog::AcceptSave);
break;
case ExistingFile:
QFileDialog::setFileMode(QFileDialog::ExistingFile);
break;
case ExistingFiles:
QFileDialog::setFileMode(QFileDialog::ExistingFiles);
break;
case Directory:
QFileDialog::setFileMode(QFileDialog::Directory);
break;
case DirectoryOnly:
QFileDialog::setFileMode(QFileDialog::DirectoryOnly);
break;
default:
QFileDialog::setFileMode(QFileDialog::AnyFile);
setAcceptMode(QFileDialog::AcceptSave);
break;
#endif //!defined(COMPILE_KDE4_SUPPORT)
}
}
void setGm2_2(DECLARE_ENGINE_PARAMETER_F) {
setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR);
engineConfiguration->trigger.type = TT_ONE_PLUS_TOOTHED_WHEEL_60_2;
boardConfiguration->triggerInputPins[0] = GPIOC_6;
boardConfiguration->triggerInputPins[1] = GPIOA_8;
}
void BarabellaApp::spinTracking() {
if (!tracker.finished()) {
tracker.processFrame();
/* display results of current frame */
mainCloud = tracker.getCurrentCloud();
view3d.setMainCloud(mainCloud);
view3d.setCube(tracker.getSearchWindow());
view3d.setTrackedCenter(
//tracker.getSearchWindow()->getGlobalPosition());
(tracker.getTrace()->coordinateFrame.inverse() *
tracker.getTrace()->transforms.back() ).translation());
view3d.spinOnce();
//FIXME
#ifdef BB_VERBOSE
std::cout << "translation: " << std::endl;
std::cout << tracker.getTrace()->transforms.back().translation() << std::endl;
std::cout << "-------------" << std::endl;
#endif
} else { // finished tracking
tracker.getTrace()->writeToCSV(gOptions->traceCSVPath);
setOperationMode(STREAMING);
}
}
void BarabellaApp::spinStreaming() {
mainCloud = kinIface.getLastCloud();
if (!displayTemplate) {
view3d.setMainCloud(mainCloud);
}
view3d.spinOnce();
/* View3D events */
if (view3d.flagCaptureFloor) {
view3d.flagCaptureFloor = false;
updateFloor();
}
if (view3d.flagExtractTemplate) {
view3d.flagExtractTemplate = false;
if (!displayTemplate) {
extractTemplate();
saveTemplateSettings();
} else {
view3d.setDrawMode(View3D::NORMAL);
}
displayTemplate = !displayTemplate;
}
if (view3d.flagTrack) {
view3d.flagTrack = false;
setOperationMode(TRACKING);
}
}
TEST(sensors, testCamInput) {
// setting some weird engine
WITH_ENGINE_TEST_HELPER(FORD_ESCORT_GT);
// and now changing to ONE trigger on CRANK with CAM/VVT
setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
engineConfiguration->useOnlyRisingEdgeForTrigger = true;
eth.setTriggerType(TT_ONE PASS_ENGINE_PARAMETER_SUFFIX);
engineConfiguration->camInput = GPIOA_10; // we just need to indicate that we have CAM
ASSERT_EQ( 0, GET_RPM()) << "testCamInput RPM";
for (int i = 0; i < 5;i++) {
eth.fireRise(50);
}
ASSERT_EQ(1200, GET_RPM()) << "testCamInput RPM";
ASSERT_EQ(0, unitTestWarningCodeState.recentWarnings.getCount()) << "warningCounter#testCamInput";
for (int i = 0; i < 600;i++) {
eth.fireRise(50);
}
ASSERT_EQ(1, unitTestWarningCodeState.recentWarnings.getCount()) << "warningCounter#testCamInput #2";
ASSERT_EQ(OBD_Camshaft_Position_Sensor_Circuit_Range_Performance, unitTestWarningCodeState.recentWarnings.get(0)) << "@0";
unitTestWarningCodeState.recentWarnings.clear();
for (int i = 0; i < 600;i++) {
eth.fireRise(50);
hwHandleVvtCamSignal(TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
}
ASSERT_EQ(0, unitTestWarningCodeState.recentWarnings.getCount()) << "warningCounter#testCamInput #3";
}
//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 setRoverv8(DECLARE_ENGINE_PARAMETER_F) {
setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_36_1;
engineConfiguration->specs.displacement = 3.528;
engineConfiguration->specs.cylindersCount = 8;
engineConfiguration->specs.firingOrder = FO_1_8_4_3_6_5_7_2;
// set_rpm_hard_limit 4000
engineConfiguration->rpmHardLimit = 4000; // yes, 4k. let's play it safe for now
// set_cranking_rpm 550
engineConfiguration->cranking.rpm = 550;
// set_whole_fuel_map 3
setWholeFuelMap(3 PASS_ENGINE_PARAMETER);
// set_cranking_injection_mode 0
engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS;
// set_injection_mode 1
engineConfiguration->injectionMode = IM_SEQUENTIAL;
// set_ignition_mode 2
engineConfiguration->ignitionMode = IM_WASTED_SPARK;
// Frankenstein: low side - out #1: PC14
// Frankenstein: low side - out #2: PC15
// Frankenstein: low side - out #3: PE6
// Frankenstein: low side - out #4: PC13
// Frankenstein: low side - out #5: PE4
// Frankenstein: low side - out #6: PE5
// Frankenstein: low side - out #7: PE2
// Frankenstein: low side - out #8: PE3
// Frankenstein: low side - out #9: PE0
// Frankenstein: low side - out #10: PE1
// Frankenstein: low side - out #11: PB8
// Frankenstein: low side - out #12: PB9
boardConfiguration->injectionPins[0] = GPIOB_9; // Frankenstein: low side - out #12
boardConfiguration->injectionPins[1] = GPIOB_8; // Frankenstein: low side - out #11
boardConfiguration->injectionPins[2] = GPIOE_3; // Frankenstein: low side - out #8
boardConfiguration->injectionPins[3] = GPIOE_5; // Frankenstein: low side - out #6
boardConfiguration->fuelPumpPin = GPIOC_13; // Frankenstein: low side - out #4
boardConfiguration->fuelPumpPinMode = OM_DEFAULT;
// set_injection_pin_mode 0
boardConfiguration->injectionPinMode = OM_DEFAULT;
boardConfiguration->canTxPin = GPIOB_6;
boardConfiguration->canRxPin = GPIOB_12;
engineConfiguration->canWriteEnabled = true;
engineConfiguration->canReadEnabled = false;
engineConfiguration->isCanEnabled = true;
engineConfiguration->canNbcType = CAN_BUS_MAZDA_RX8;
}
void setVwAba(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
setWholeTimingTable_d(20 PASS_CONFIG_PARAMETER_SUFFIX);
engineConfiguration->cranking.baseFuel = 12;
// set cranking_timing_angle 10
engineConfiguration->crankingTimingAngle = 10;
engineConfiguration->isCylinderCleanupEnabled = true;
// set_whole_fuel_map 12
setWholeFuelMap(12 PASS_CONFIG_PARAMETER_SUFFIX);
// set global_trigger_offset_angle 93
engineConfiguration->globalTriggerAngleOffset = 93;
setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
// engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_60_2;
engineConfiguration->trigger.type = TT_60_2_VW;
engineConfiguration->mafAdcChannel = EFI_ADC_1;
//Base engine setting
engineConfiguration->specs.cylindersCount = 4;
engineConfiguration->specs.displacement = 2.0;
engineConfiguration->injector.flow = 320; // 30lb/h
// set algorithm 3
setAlgorithm(LM_SPEED_DENSITY PASS_CONFIG_PARAMETER_SUFFIX);
engineConfiguration->map.sensor.type = MT_GM_3_BAR;
engineConfiguration->ignitionMode = IM_ONE_COIL;
boardConfiguration->ignitionPins[0] = GPIOE_14; // Frankenso high side - pin 1G
boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED;
boardConfiguration->ignitionPins[2] = GPIO_UNASSIGNED;
boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED;
boardConfiguration->ignitionPinMode = OM_DEFAULT;
float mapRange = 110;
setEgoSensor(ES_PLX PASS_ENGINE_PARAMETER_SUFFIX);
setFuelTablesLoadBin(20, mapRange PASS_CONFIG_PARAMETER_SUFFIX);
setTimingLoadBin(20, mapRange PASS_CONFIG_PARAMETER_SUFFIX);
boardConfiguration->isSdCardEnabled = false;
engineConfiguration->tpsMin = 740;
engineConfiguration->tpsMax = 135;
}
void RobotWidget::modeButtonClicked()
{
if (current_mode_ > 0)
{
current_mode_ = 0;
}
else
{
current_mode_ = 1;
}
emit updateOperationIconSignal(current_mode_);
setOperationMode(current_mode_);
}
void setLadaKalina(DECLARE_ENGINE_PARAMETER_F) {
setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_F);
disableLCD(boardConfiguration);
boardConfiguration->HD44780_rs = GPIO_UNASSIGNED;
boardConfiguration->HD44780_e = GPIO_UNASSIGNED;
boardConfiguration->HD44780_db4 = GPIO_UNASSIGNED;
boardConfiguration->HD44780_db5 = GPIO_UNASSIGNED;
boardConfiguration->HD44780_db6 = GPIO_UNASSIGNED;
boardConfiguration->HD44780_db7 = GPIO_UNASSIGNED;
setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_60_2;
boardConfiguration->triggerInputPins[0] = GPIOA_5;
boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED;
engineConfiguration->globalTriggerAngleOffset = 114;
boardConfiguration->ignitionPins[0] = GPIOE_14;
boardConfiguration->ignitionPins[1] = GPIOC_7;
boardConfiguration->ignitionPins[2] = GPIOC_9;
boardConfiguration->ignitionPins[3] = GPIOE_12;
boardConfiguration->useStepperIdle = true;
boardConfiguration->fuelPumpPin = GPIOC_13;
boardConfiguration->mainRelayPin = GPIOD_7;
boardConfiguration->idle.stepperDirectionPin = GPIOE_15;
boardConfiguration->idle.stepperStepPin = GPIOE_13;
engineConfiguration->stepperEnablePin = GPIOE_11;
// starter relay solenoid
/**
* to test
* set_fsio_setting 0 5000
*/
engineConfiguration->bc.fsio_setting[0] = 500;
// set_fsio_expression 1 "rpm 0 fsio_setting <"
setFsioExt(0, GPIOE_3, "rpm 0 fsio_setting <", 0 PASS_ENGINE_PARAMETER);
}
void setTestEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
// setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
// engineConfiguration->trigger.type = TT_TOOTHED_WHEEL;
setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR);
engineConfiguration->trigger.type = TT_ONE_PLUS_ONE;
trigger_config_s *triggerConfig = &engineConfiguration->trigger;
triggerConfig->customTotalToothCount = 60;
triggerConfig->customSkippedToothCount = 0;
engineConfiguration->useOnlyFrontForTrigger = true;
engineConfiguration->mafAdcChannel = EFI_ADC_NONE;
engineConfiguration->vbattAdcChannel = EFI_ADC_NONE;
setWholeIatCorrTimingTable(0 PASS_ENGINE_PARAMETER);
engineConfiguration->ignitionMode = IM_ONE_COIL;
setConstantDwell(3 PASS_ENGINE_PARAMETER); // 50% duty cycle @ 5000 rpm
board_configuration_s *bc = &engineConfiguration->bc;
bc->malfunctionIndicatorPin = GPIO_UNASSIGNED;
bc->ignitionPins[0] = GPIOC_7; // #1
bc->ignitionPins[1] = GPIO_UNASSIGNED; // #2
bc->ignitionPins[2] = GPIO_UNASSIGNED; // #3
bc->ignitionPins[3] = GPIO_UNASSIGNED; // #4
bc->ignitionPins[4] = GPIO_UNASSIGNED; // #5
bc->ignitionPins[5] = GPIO_UNASSIGNED; // #6
bc->logicAnalyzerPins[0] = GPIO_UNASSIGNED;
bc->logicAnalyzerPins[1] = GPIO_UNASSIGNED;
bc->logicAnalyzerPins[2] = GPIO_UNASSIGNED;
bc->logicAnalyzerPins[3] = GPIO_UNASSIGNED;
engineConfiguration->hasCltSensor = false;
engineConfiguration->hasIatSensor = false;
}
void set1973c20(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->specs.displacement = 5.7;
engineConfiguration->specs.cylindersCount = 8;
setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR);
engineConfiguration->ignitionMode = IM_ONE_COIL;
engineConfiguration->specs.firingOrder = FO_1_8_4_3_6_5_7_2;
engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS;
engineConfiguration->injectionMode = IM_SIMULTANEOUS;
/**
* 8/0 toothed wheel
*/
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL;
engineConfiguration->trigger.customTotalToothCount = 8;
engineConfiguration->trigger.customSkippedToothCount = 0;
engineConfiguration->rpmHardLimit = 5000;
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER);
}
/**
* @brief Default values for persistent properties
*/
void setFordInline6(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->specs.cylindersCount = 6;
setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR);
engineConfiguration->ignitionMode = IM_ONE_COIL;
engineConfiguration->specs.firingOrder = FO_1_THEN_5_THEN_3_THEN_6_THEN_2_THEN_4;
engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS;
engineConfiguration->injectionMode = IM_BATCH;
engineConfiguration->twoWireBatchInjection = true;
/**
* 0.5ms dweel time just to be sure it would fit within camshaft revolution, dwell is not controlled by us anyway
*/
setConstantDwell(0.5 PASS_ENGINE_PARAMETER);
/**
* We treat the trigger as 6/0 toothed wheel
*/
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL;
engineConfiguration->trigger.customTotalToothCount = 6;
engineConfiguration->trigger.customSkippedToothCount = 0;
engineConfiguration->globalTriggerAngleOffset = 0;
engineConfiguration->ignitionOffset = 13;
engineConfiguration->injectionOffset = 207.269999;
setThermistorConfiguration(&engineConfiguration->clt, -10.0, 160310.0, 60.0, 7700.0, 120.0, 1180.0);
engineConfiguration->clt.config.bias_resistor = 2700;
setThermistorConfiguration(&engineConfiguration->iat, -10.0, 160310.0, 60.0, 7700.0, 120.0, 1180.0);
engineConfiguration->iat.config.bias_resistor = 2700;
// 12ch analog board pinout:
// input channel 3 is PA7, that's ADC7
// input channel 5 is PA4, that's ADC4
// input channel 6 is PA3, that's ADC3
// input channel 7 is PA2, that's ADC2
// input channel 8 is PA1, that's ADC1
// input channel 9 is PA0, that's ADC0
// input channel 10 is PC3, that's ADC13
// input channel 12 is PC1, that's ADC11
engineConfiguration->tpsAdcChannel = EFI_ADC_4;
engineConfiguration->iat.adcChannel = EFI_ADC_2;
engineConfiguration->clt.adcChannel = EFI_ADC_1;
engineConfiguration->afr.hwChannel = EFI_ADC_11;
engineConfiguration->map.sensor.type = MT_MPX4250;
engineConfiguration->map.sensor.hwChannel = EFI_ADC_15;
engineConfiguration->baroSensor.type = MT_MPX4250;
engineConfiguration->baroSensor.hwChannel = EFI_ADC_7;
// 6 channel output board
// output 1 is PB9
// output 3 is PE3
// output 5 is PC13
// output 6 is PC15
boardConfiguration->fuelPumpPin = GPIOC_13;
boardConfiguration->injectionPins[0] = GPIOB_9;
boardConfiguration->injectionPins[1] = GPIOE_3;
boardConfiguration->ignitionPins[0] = GPIOC_15;
boardConfiguration->injectionPins[2] = GPIO_UNASSIGNED;
boardConfiguration->fanPin = GPIO_UNASSIGNED;
engineConfiguration->tpsMin = convertVoltageTo10bitADC(1.250);
engineConfiguration->tpsMax = convertVoltageTo10bitADC(4.538);
// engineConfiguration->vbattAdcChannel = 0; //
engineConfiguration->mafAdcChannel = EFI_ADC_1;
engineConfiguration->hasMafSensor = true;
boardConfiguration->triggerInputPins[0] = GPIOA_8;
boardConfiguration->triggerInputPins[1] = GPIOA_5;
boardConfiguration->logicAnalyzerPins[0] = GPIOC_6;
boardConfiguration->logicAnalyzerPins[1] = GPIOE_5;
}
//first init the toolbar,set it to MODE_DRAW
void toolbar_firstinit(int iTotalPage)
{
setOperationMode(MODE_DRAW);
drawIconsByMode(iTotalPage);
}
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;
}
/**
* @brief Global default engine configuration
* This method sets the global engine configuration defaults. These default values are then
* overridden by engine-specific defaults and the settings are saved in flash memory.
*
* This method is invoked only when new configuration is needed:
* * recently re-flashed chip
* * flash version of configuration failed CRC check or appears to be older then FLASH_DATA_VERSION
* * 'rewriteconfig' command
* * 'set_engine_type X' command
*/
void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) {
#if (! EFI_UNIT_TEST) || defined(__DOXYGEN__)
memset(&persistentState.persistentConfiguration, 0, sizeof(persistentState.persistentConfiguration));
#endif
prepareVoidConfiguration(engineConfiguration);
boardConfiguration->mafSensorType = Bosch0280218037;
setBosch0280218037(config);
engineConfiguration->injector.lag = 1.0;
engineConfiguration->acCutoffLowRpm = 700;
engineConfiguration->acCutoffHighRpm = 5000;
initTemperatureCurve(IAT_CURVE_SIZE, config->iatFuelCorrBins, config->iatFuelCorr);
initTemperatureCurve(CLT_CURVE_SIZE, config->cltFuelCorrBins, config->cltFuelCorr);
initTemperatureCurve(CLT_CURVE_SIZE, config->cltIdleCorrBins, config->cltIdleCorr);
engineConfiguration->tachPulseDuractionMs = 4;
engineConfiguration->tachPulseTriggerIndex = 4;
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, -40, 1.5);
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, -30, 1.5);
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, -20, 1.42);
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, -10, 1.36);
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, 0, 1.28);
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, 10, 1.19);
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, 20, 1.12);
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, 30, 1.10);
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, 40, 1.06);
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, 50, 1.06);
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, 60, 1.03);
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, 70, 1.01);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, -40, 1.5);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, -30, 1.5);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, -20, 1.42);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, -10, 1.36);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, 0, 1.28);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, 10, 1.19);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, 20, 1.12);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, 30, 1.10);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, 40, 1.06);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, 50, 1.06);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, 60, 1.03);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, 70, 1.01);
for (int i = 0; i < VBAT_INJECTOR_CURVE_SIZE; i++) {
engineConfiguration->injector.battLagCorrBins[i] = 12 - VBAT_INJECTOR_CURVE_SIZE / 2 + i;
engineConfiguration->injector.battLagCorr[i] = 0; // zero extra time by default
}
setConstantDwell(4 PASS_ENGINE_PARAMETER); // 4ms is global default dwell
engineConfiguration->useConstantDwellDuringCranking = false;
setFuelLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER);
setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER);
setTimingLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER);
setTimingRpmBin(800, 7000 PASS_ENGINE_PARAMETER);
setTableBin2(engineConfiguration->map.samplingAngleBins, MAP_ANGLE_SIZE, 800, 7000, 1);
setTableBin2(engineConfiguration->map.samplingAngle, MAP_ANGLE_SIZE, 100, 130, 1);
setTableBin2(engineConfiguration->map.samplingWindowBins, MAP_ANGLE_SIZE, 800, 7000, 1);
setTableBin2(engineConfiguration->map.samplingWindow, MAP_ANGLE_SIZE, 50, 50, 1);
// set_whole_timing_map 3
setWholeFuelMap(3 PASS_ENGINE_PARAMETER);
setMap(config->afrTable, 14.7);
setDefaultVETable(PASS_ENGINE_PARAMETER_F);
setMap(config->injectionPhase, -180);
setRpmTableBin(config->injPhaseRpmBins, FUEL_RPM_COUNT);
setFuelTablesLoadBin(10, 160 PASS_ENGINE_PARAMETER);
setDefaultIatTimingCorrection(PASS_ENGINE_PARAMETER_F);
setThermistorConfiguration(&engineConfiguration->clt, 0, 9500, 23.8889, 2100, 48.8889, 1000);
engineConfiguration->clt.config.bias_resistor = 1500;
setThermistorConfiguration(&engineConfiguration->iat, 32, 9500, 75, 2100, 120, 1000);
// todo: this value is way off! I am pretty sure temp coeffs are off also
engineConfiguration->iat.config.bias_resistor = 2700;
engineConfiguration->step1rpm = 3000;
engineConfiguration->step1timing = 10;
engineConfiguration->step1RpmWindow = 500;
engineConfiguration->step1fuelCutEnable = false;
engineConfiguration->step1SparkCutEnable = false;
engineConfiguration->step1RpmWindow = 500;
engineConfiguration->rpmHardLimit = 7000;
engineConfiguration->cranking.rpm = 550;
engineConfiguration->cutFuelOnHardLimit = true;
engineConfiguration->cutSparkOnHardLimit = true;
engineConfiguration->noAccelAfterHardLimitPeriodSecs = 3;
setTableBin2(engineConfiguration->crankingTpsCoef, CRANKING_CURVE_SIZE, 1, 1, 1);
setTableBin2(engineConfiguration->crankingTpsBins, CRANKING_CURVE_SIZE, 0, 100, 1);
config->crankingFuelCoef[0] = 5; // base cranking fuel adjustment coefficient
config->crankingFuelBins[0] = -20; // temperature in C
config->crankingFuelCoef[1] = 3.7;
config->crankingFuelBins[1] = -10;
config->crankingFuelCoef[2] = 2.6;
config->crankingFuelBins[2] = 5;
config->crankingFuelCoef[3] = 2.4;
config->crankingFuelBins[3] = 20;
config->crankingFuelCoef[4] = 2.1;
config->crankingFuelBins[4] = 35;
config->crankingFuelCoef[5] = 1.8;
config->crankingFuelBins[5] = 50;
config->crankingFuelCoef[6] = 1.5;
config->crankingFuelBins[6] = 65;
config->crankingFuelCoef[7] = 1;
config->crankingFuelBins[7] = 90;
config->crankingCycleCoef[0] = 2;
config->crankingCycleBins[0] = 10;
config->crankingCycleCoef[1] = 1;
config->crankingCycleBins[1] = 31;
config->crankingCycleCoef[2] = 1;
config->crankingCycleBins[2] = 52;
config->crankingCycleCoef[3] = 0.5;
config->crankingCycleBins[3] = 73;
config->crankingCycleCoef[4] = 0.5;
config->crankingCycleBins[4] = 74;
config->crankingCycleCoef[5] = 0.5;
config->crankingCycleBins[5] = 75;
config->crankingCycleCoef[6] = 0.5;
config->crankingCycleBins[6] = 76;
config->crankingCycleCoef[7] = 0.5;
config->crankingCycleBins[7] = 77;
engineConfiguration->cranking.baseFuel = 5;
engineConfiguration->analogInputDividerCoefficient = 2;
engineConfiguration->crankingChargeAngle = 70;
engineConfiguration->timingMode = TM_DYNAMIC;
engineConfiguration->fixedModeTiming = 50;
// performance optimization
boardConfiguration->sensorChartMode = SC_OFF;
engineConfiguration->map.sensor.hwChannel = EFI_ADC_4;
engineConfiguration->baroSensor.hwChannel = EFI_ADC_NONE;
engineConfiguration->pedalPositionChannel = EFI_ADC_NONE;
engineConfiguration->specs.firingOrder = FO_1_THEN_3_THEN_4_THEN2;
engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS;
engineConfiguration->injectionMode = IM_SEQUENTIAL;
engineConfiguration->ignitionMode = IM_ONE_COIL;
engineConfiguration->globalTriggerAngleOffset = 0;
engineConfiguration->injectionOffset = 0;
engineConfiguration->ignitionOffset = 0;
engineConfiguration->overrideCrankingIgnition = true;
engineConfiguration->sensorChartFrequency = 20;
engineConfiguration->algorithm = LM_PLAIN_MAF;
engineConfiguration->vbattDividerCoeff = ((float) (15 + 65)) / 15;
engineConfiguration->fanOnTemperature = 75;
engineConfiguration->fanOffTemperature = 70;
engineConfiguration->tpsMin = convertVoltageTo10bitADC(1.250);
engineConfiguration->tpsMax = convertVoltageTo10bitADC(4.538);
engineConfiguration->tpsErrorLowValue = convertVoltageTo10bitADC(0.2);
engineConfiguration->tpsErrorHighValue = convertVoltageTo10bitADC(6);
engineConfiguration->canNbcType = CAN_BUS_NBC_BMW;
engineConfiguration->canSleepPeriod = 50;
engineConfiguration->canReadEnabled = true;
engineConfiguration->canWriteEnabled = false;
setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR);
engineConfiguration->specs.cylindersCount = 4;
engineConfiguration->specs.displacement = 2;
/**
* By the way http://users.erols.com/srweiss/tableifc.htm has a LOT of data
*/
engineConfiguration->injector.flow = 200;
engineConfiguration->displayMode = DM_HD44780;
engineConfiguration->logFormat = LF_NATIVE;
engineConfiguration->directSelfStimulation = false;
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_60_2;
engineConfiguration->HD44780width = 20;
engineConfiguration->HD44780height = 4;
engineConfiguration->vRefAdcChannel = EFI_ADC_NONE;
engineConfiguration->vbattAdcChannel = EFI_ADC_NONE;
engineConfiguration->clt.adcChannel = EFI_ADC_6;
engineConfiguration->iat.adcChannel = EFI_ADC_7;
engineConfiguration->mafAdcChannel = EFI_ADC_NONE;
engineConfiguration->afr.hwChannel = EFI_ADC_14;
engineConfiguration->cylinderBore = 87.5;
setEgoSensor(ES_14Point7_Free PASS_ENGINE_PARAMETER);
engineConfiguration->globalFuelCorrection = 1;
engineConfiguration->map.sensor.type = MT_MPX4250;
engineConfiguration->baroSensor.type = MT_CUSTOM;
engineConfiguration->baroSensor.valueAt0 = 0;
engineConfiguration->baroSensor.valueAt5 = 500;
engineConfiguration->hasMapSensor = true;
engineConfiguration->hasMafSensor = true;
engineConfiguration->hasTpsSensor = true;
engineConfiguration->hasAfrSensor = true;
engineConfiguration->hasIatSensor = true;
engineConfiguration->hasCltSensor = true;
engineConfiguration->hasBaroSensor = false;
engineConfiguration->isEngineChartEnabled = true;
engineConfiguration->useOnlyFrontForTrigger = false;
boardConfiguration->idle.solenoidFrequency = 200;
// set_idle_position 50
boardConfiguration->idlePosition = 50;
engineConfiguration->targetIdleRpm = 1200;
// engineConfiguration->idleMode = IM_AUTO;
engineConfiguration->idleMode = IM_MANUAL;
engineConfiguration->acSwitchAdc = EFI_ADC_NONE;
engineConfiguration->externalKnockSenseAdc = EFI_ADC_NONE;
boardConfiguration->useSerialPort = true;
boardConfiguration->useStepperIdle = false;
boardConfiguration->idle.stepperDirectionPin = GPIOE_10;
boardConfiguration->idle.stepperStepPin = GPIOE_12;
engineConfiguration->stepperEnablePin = GPIOE_14;
engineConfiguration->idleStepperReactionTime = 10;
engineConfiguration->idleStepperTotalSteps = 150;
#if EFI_PROD_CODE || defined(__DOXYGEN__)
engineConfiguration->engineChartSize = 300;
#else
// need more events for automated test
engineConfiguration->engineChartSize = 400;
#endif
engineConfiguration->engineCycle = 720;
engineConfiguration->primingSquirtDurationMs = 5;
engineConfiguration->isInjectionEnabled = true;
engineConfiguration->isIgnitionEnabled = true;
engineConfiguration->isCylinderCleanupEnabled = true;
engineConfiguration->secondTriggerChannelEnabled = true;
engineConfiguration->isMapAveragingEnabled = true;
engineConfiguration->isMilEnabled = true;
engineConfiguration->isFuelPumpEnabled = true;
engineConfiguration->isTunerStudioEnabled = true;
engineConfiguration->isWaveAnalyzerEnabled = true;
engineConfiguration->isIdleThreadEnabled = true;
engineConfiguration->acIdleRpmBump = 200;
engineConfiguration->knockDetectionWindowStart = 35;
engineConfiguration->knockDetectionWindowEnd = 135;
engineConfiguration->fuelLevelSensor = EFI_ADC_NONE;
boardConfiguration->fuelLevelEmptyTankVoltage = 0;
boardConfiguration->fuelLevelFullTankVoltage = 5;
engineConfiguration->hipOutputChannel = EFI_ADC_NONE;
/**
* this is RPM. 10000 rpm is only 166Hz, 800 rpm is 13Hz
*/
boardConfiguration->triggerSimulatorFrequency = 1200;
boardConfiguration->triggerErrorPin = GPIO_UNASSIGNED;
boardConfiguration->max31855spiDevice = SPI_NONE;
for (int i = 0; i < EGT_CHANNEL_COUNT; i++) {
boardConfiguration->max31855_cs[i] = GPIO_UNASSIGNED;
}
for (int i = 0; i < LE_COMMAND_COUNT; i++) {
boardConfiguration->fsioPins[i] = GPIO_UNASSIGNED;
config->le_formulas[i][0] = 0;
boardConfiguration->fsioDigitalInputs[i] = GPIO_UNASSIGNED;
engineConfiguration->fsioInputModes[i] = PI_DEFAULT;
}
boardConfiguration->triggerSimulatorPins[0] = GPIOD_1;
boardConfiguration->triggerSimulatorPins[1] = GPIOD_2;
boardConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED;
boardConfiguration->triggerSimulatorPinModes[0] = OM_DEFAULT;
boardConfiguration->triggerSimulatorPinModes[1] = OM_DEFAULT;
boardConfiguration->triggerSimulatorPinModes[2] = OM_DEFAULT;
setFrankenstein_01_LCD(boardConfiguration);
strcpy(config->timingMultiplier, "1");
strcpy(config->timingAdditive, "0");
engineConfiguration->hip9011SpiDevice = SPI_DEVICE_2;
engineConfiguration->isAlternatorControlEnabled = true;
engineConfiguration->isGpsEnabled = false;
boardConfiguration->gps_rx_pin = GPIOB_7;
boardConfiguration->gps_tx_pin = GPIOB_6;
boardConfiguration->triggerInputPins[0] = GPIOC_6;
boardConfiguration->triggerInputPins[1] = GPIOA_5;
boardConfiguration->logicAnalyzerPins[0] = GPIO_UNASSIGNED;
boardConfiguration->logicAnalyzerPins[1] = GPIO_UNASSIGNED; // GPIOE_5 is a popular option (if available)
boardConfiguration->logicAnalyzerPins[2] = GPIO_UNASSIGNED;
boardConfiguration->logicAnalyzerPins[3] = GPIO_UNASSIGNED;
boardConfiguration->vehicleSpeedSensorInputPin = GPIO_UNASSIGNED;
engineConfiguration->vehicleSpeedCoef = 1.0f;
boardConfiguration->logicAnalyzerMode[0] = false;
boardConfiguration->logicAnalyzerMode[1] = false;
engineConfiguration->mapErrorLowValue = 5;
engineConfiguration->mapErrorHighValue = 250;
boardConfiguration->idleThreadPeriod = 100;
boardConfiguration->consoleLoopPeriod = 200;
boardConfiguration->lcdThreadPeriod = 300;
boardConfiguration->generalPeriodicThreadPeriod = 50;
boardConfiguration->useLcdScreen = true;
boardConfiguration->boardTestModeJumperPin = GPIOB_0;
boardConfiguration->canDeviceMode = CD_USE_CAN2;
boardConfiguration->canTxPin = GPIOB_6;
boardConfiguration->canRxPin = GPIOB_12;
// set this to SPI_DEVICE_3 to enable stimulation
boardConfiguration->digitalPotentiometerSpiDevice = SPI_NONE;
boardConfiguration->digitalPotentiometerChipSelect[0] = GPIOD_7;
boardConfiguration->digitalPotentiometerChipSelect[1] = GPIO_UNASSIGNED;
boardConfiguration->digitalPotentiometerChipSelect[2] = GPIOD_5;
boardConfiguration->digitalPotentiometerChipSelect[3] = GPIO_UNASSIGNED;
boardConfiguration->is_enabled_spi_1 = false;
boardConfiguration->is_enabled_spi_2 = false;
boardConfiguration->is_enabled_spi_3 = true;
boardConfiguration->spi1mosiPin = GPIOB_5;
boardConfiguration->spi1misoPin = GPIOB_4;
boardConfiguration->spi1sckPin = GPIOB_3; // please note that this pin is also SWO/SWD - Single Wire debug Output
boardConfiguration->spi2mosiPin = GPIOB_15;
boardConfiguration->spi2misoPin = GPIOB_14;
boardConfiguration->spi2sckPin = GPIOB_13;
boardConfiguration->spi3mosiPin = GPIOB_5;
boardConfiguration->spi3misoPin = GPIOB_4;
boardConfiguration->spi3sckPin = GPIOB_3;
boardConfiguration->hip9011Gain = 1;
boardConfiguration->sdCardCsPin = GPIOD_4;
boardConfiguration->isSdCardEnabled = true;
boardConfiguration->isFastAdcEnabled = true;
boardConfiguration->isEngineControlEnabled = true;
boardConfiguration->isVerboseAlternator = false;
boardConfiguration->tunerStudioSerialSpeed = TS_DEFAULT_SPEED;
engineConfiguration->mapAccelLength = 6;
engineConfiguration->mapAccelEnrichmentThreshold = 5; // kPa
engineConfiguration->mapAccelEnrichmentMultiplier = 2;
engineConfiguration->tpsAccelLength = 12;
engineConfiguration->tpsAccelEnrichmentThreshold = 40; // TPS % change, per engine cycle
engineConfiguration->tpsAccelEnrichmentMultiplier = 0.05;
}
void setDodgeRam1996(DECLARE_ENGINE_PARAMETER_F) {
setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_F);
setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR);
engineConfiguration->trigger.type = TT_DODGE_RAM;
engineConfiguration->injector.flow = 243.6; // 23.2lb/h
engineConfiguration->map.sensor.type = MT_DODGE_NEON_2003;
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER);
// set cranking_charge_angle 30
engineConfiguration->crankingChargeAngle = 30;
// set_whole_fuel_map 6
setWholeFuelMap(6 PASS_ENGINE_PARAMETER);
//Base engine setting
engineConfiguration->specs.cylindersCount = 8;
engineConfiguration->specs.firingOrder = FO_1_8_4_3_6_5_7_2;
engineConfiguration->specs.displacement = 5.2;
boardConfiguration->triggerInputPins[0] = GPIOC_6;
boardConfiguration->triggerInputPins[1] = GPIOA_5;
boardConfiguration->injectionPins[0] = GPIOE_2;
boardConfiguration->injectionPins[1] = GPIOB_9;
boardConfiguration->injectionPins[2] = GPIOD_5;
boardConfiguration->injectionPins[3] = GPIOB_8;
boardConfiguration->injectionPins[4] = GPIOB_7;
boardConfiguration->injectionPins[5] = GPIOE_3;
boardConfiguration->injectionPins[6] = GPIOE_4;
boardConfiguration->injectionPins[7] = GPIOD_3;
boardConfiguration->ignitionPins[0] = GPIOC_9;
boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED;
boardConfiguration->ignitionPins[2] = GPIO_UNASSIGNED;
boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED;
boardConfiguration->mainRelayPin = GPIOE_5;
boardConfiguration->fuelPumpPin = GPIOE_6;
boardConfiguration->fanPin = GPIO_UNASSIGNED;
engineConfiguration->engineChartSize = 450;
// set cranking_fuel 7
engineConfiguration->cranking.baseFuel = 7;
// set global_trigger_offset_angle -50
engineConfiguration->globalTriggerAngleOffset = -50;
// set_global_fuel_correction 1
// set_whole_timing_map 10
setWholeTimingTable(10 PASS_ENGINE_PARAMETER);
boardConfiguration->alternatorControlPin = GPIOD_7;
engineConfiguration->alternatorControl.pFactor = 22;
boardConfiguration->idle.solenoidPin = GPIOC_13;
boardConfiguration->idle.solenoidFrequency = 300;
engineConfiguration->vbattAdcChannel = EFI_ADC_14;
// engineConfiguration->vbattDividerCoeff = ((float) (8.93 + 41.27)) / 8.93 * 2;
engineConfiguration->vbattDividerCoeff = 9.6;
setDodgeSensor(&engineConfiguration->clt);
engineConfiguration->clt.config.bias_resistor = 2700;
setDodgeSensor(&engineConfiguration->iat);
engineConfiguration->iat.config.bias_resistor = 2700;
boardConfiguration->useStepperIdle = true;
}
void KexiFileWidget::updateFilters()
{
if (d->filtersUpdated)
return;
d->filtersUpdated = true;
d->lastFileName.clear();
clearFilter();
QString filter;
KMimeType::Ptr mime;
QStringList allfilters;
const bool normalOpeningMode = d->mode & Opening && !(d->mode & Custom);
const bool normalSavingMode = d->mode & SavingFileBasedDB && !(d->mode & Custom);
if (normalOpeningMode || normalSavingMode) {
mime = KMimeType::mimeType(KexiDB::defaultFileBasedDriverMimeType());
if (mime && !d->excludedMimeTypes.contains(mime->name().toLower())) {
filter += KexiUtils::fileDialogFilterString(mime);
allfilters += mime->patterns();
}
}
if (normalOpeningMode || d->mode & SavingServerBasedDB) {
mime = KMimeType::mimeType("application/x-kexiproject-shortcut");
if (mime && !d->excludedMimeTypes.contains(mime->name().toLower())) {
filter += KexiUtils::fileDialogFilterString(mime);
allfilters += mime->patterns();
}
}
if (normalOpeningMode || d->mode & SavingServerBasedDB) {
mime = KMimeType::mimeType("application/x-kexi-connectiondata");
if (mime && !d->excludedMimeTypes.contains(mime->name().toLower())) {
filter += KexiUtils::fileDialogFilterString(mime);
allfilters += mime->patterns();
}
}
//! @todo hardcoded for MSA:
if (normalOpeningMode) {
mime = KMimeType::mimeType("application/vnd.ms-access");
if (mime && !d->excludedMimeTypes.contains(mime->name().toLower())) {
filter += KexiUtils::fileDialogFilterString(mime);
allfilters += mime->patterns();
}
mime = KMimeType::mimeType("application/vnd.oasis.opendocument.database");
if (mime && !d->excludedMimeTypes.contains(mime->name().toLower())) {
filter += KexiUtils::fileDialogFilterString(mime);
allfilters += mime->patterns();
}
}
foreach(const QString& mimeName, d->additionalMimeTypes) {
if (mimeName == "all/allfiles")
continue;
if (d->excludedMimeTypes.contains(mimeName.toLower()))
continue;
filter += KexiUtils::fileDialogFilterString(mimeName);
mime = KMimeType::mimeType(mimeName);
allfilters += mime->patterns();
}
if (!d->excludedMimeTypes.contains("all/allfiles")) {
filter += filterWidget()->defaultFilter();
}
//remove duplicates made because upper- and lower-case extenstions are used:
QStringList allfiltersUnique = allfilters.toSet().toList();
qSort(allfiltersUnique);
if (allfiltersUnique.count() > 1) {//prepend "all supoported files" entry
filter.prepend(allfilters.join(" ") + "|"
+ i18n("All Supported Files (%1)", allfiltersUnique.join(", ")) + "\n");
}
if (filter.right(1) == "\n")
filter.truncate(filter.length() - 1);
setFilter(filter);
if (d->mode & Opening) {
KFileWidget::setMode(KFile::ExistingOnly | KFile::LocalOnly | KFile::File);
setOperationMode(KFileWidget::Opening);
} else {
KFileWidget::setMode(KFile::LocalOnly | KFile::File);
setOperationMode(KFileWidget::Saving);
}
}
void setBmwE34(DECLARE_ENGINE_PARAMETER_F) {
board_configuration_s * boardConfiguration = &engineConfiguration->bc;
engineConfiguration->analogInputDividerCoefficient = 2;
boardConfiguration->analogChartMode = AC_TRIGGER;
// chartsize 450
engineConfiguration->digitalChartSize = 450;
// setAlgorithm(LM_PLAIN_MAF);
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER);
engineConfiguration->injector.flow = 750;
boardConfiguration->tunerStudioSerialSpeed = 38400;
engineConfiguration->rpmHardLimit = 6000;
// setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR);
// engineConfiguration->trigger.type = TT_ONE_PLUS_TOOTHED_WHEEL_60_2;
// engineConfiguration->injectionMode = IM_SEQUENTIAL;
// boardConfiguration->triggerInputPins[0] = GPIOC_6;
// boardConfiguration->triggerInputPins[1] = GPIOA_5;
setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_60_2;
engineConfiguration->injectionMode = IM_SEQUENTIAL;
boardConfiguration->triggerInputPins[0] = GPIOA_5;
boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED;
// engineConfiguration->useOnlyFrontForTrigger = true;
engineConfiguration->specs.cylindersCount = 6;
engineConfiguration->specs.displacement = 2.91;
engineConfiguration->specs.firingOrder = FO_1_THEN_5_THEN_3_THEN_6_THEN_2_THEN_4;
engineConfiguration->ignitionMode = IM_WASTED_SPARK;
engineConfiguration->ignMathCalculateAtIndex = 16;
setConstantDwell(3 PASS_ENGINE_PARAMETER); // a bit shorter dwell
engineConfiguration->useConstantDwellDuringCranking = true;
engineConfiguration->ignitionDwellForCrankingMs = 5;
// todo: check the digital sniffer while simulating
// set_global_trigger_offset_angle 84
engineConfiguration->globalTriggerAngleOffset = 84;
setWholeFuelMap(6 PASS_ENGINE_PARAMETER);
setWholeTimingTable(10 PASS_ENGINE_PARAMETER);
board_configuration_s *bc = &engineConfiguration->bc;
bc->malfunctionIndicatorPin = GPIO_UNASSIGNED;
// bc->isFastAdcEnabled = true;
bc->injectionPinMode = OM_INVERTED;
bc->injectionPins[0] = GPIOB_8; // #1
bc->injectionPins[1] = GPIOE_2; // #2
bc->injectionPins[2] = GPIOE_3; // #3
bc->injectionPins[3] = GPIOE_4; // #4
bc->injectionPins[4] = GPIOE_5; // #5
bc->injectionPins[5] = GPIOE_6; // #6
bc->ignitionPinMode = OM_INVERTED;
bc->ignitionPins[0] = GPIOB_5; // #1
bc->ignitionPins[2] = GPIOB_6; // #3
bc->ignitionPins[4] = GPIOB_7; // #5
bc->triggerErrorPin = GPIO_UNASSIGNED;
boardConfiguration->clutchUpPin = GPIOD_3;
boardConfiguration->clutchUpPinMode = PI_PULLUP;
boardConfiguration->fuelPumpPin = GPIOD_4;
boardConfiguration->idle.solenoidPin = GPIOC_14;
boardConfiguration->idle.solenoidPinMode = OM_INVERTED;
boardConfiguration->idle.solenoidFrequency = 300;
// set_idle_pwm 50
boardConfiguration->idlePosition = 50;
boardConfiguration->sdCardCsPin = GPIO_UNASSIGNED;
boardConfiguration->is_enabled_spi_2 = false;
boardConfiguration->is_enabled_spi_3 = false;
boardConfiguration->max31855spiDevice = SPI_NONE;
// turbocharger boost control solenoid: TODO output: GPIOE_6
// water injection #1 TODO GPIOD_7
// water injection #2 TODO GPIOE_2
/**
* emulating the 60-0 trigger takes some resources, let's keep it slow by default
* rpm 200
*/
bc->triggerSimulatorFrequency = 200;
engineConfiguration->map.sensor.type = MT_MPX4250;
// engineConfiguration->hasCltSensor = false;
// engineConfiguration->hasIatSensor = false;
engineConfiguration->hasCltSensor = true;
engineConfiguration->hasIatSensor = true;
setThermistorConfiguration(&engineConfiguration->clt, -10, 9300, 20, 2500, 80, 335);
engineConfiguration->iat.bias_resistor = 2200;
setThermistorConfiguration(&engineConfiguration->iat, -10, 9300, 20, 2500, 80, 335);
engineConfiguration->clt.bias_resistor = 2200;
// /**
// * This saves a couple of ticks in trigger emulation methods
// * TODO: add some smart logic to detect unneeded trigger simulation pins?
// * TODO: but probably not worth it
// */
// bc->triggerSimulatorPins[1] = GPIO_UNASSIGNED;
boardConfiguration->triggerSimulatorPins[0] = GPIOD_1;
boardConfiguration->triggerSimulatorPins[1] = GPIOD_2;
bc->triggerSimulatorPins[2] = GPIO_UNASSIGNED;
}
void setSachs(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->specs.displacement = 0.1; // 100cc
engineConfiguration->specs.cylindersCount = 1;
setOperationMode(engineConfiguration, TWO_STROKE);
engineConfiguration->specs.firingOrder = FO_1;
engineConfiguration->engineChartSize = 400;
// set injection_offset 0
engineConfiguration->extraInjectionOffset = 0;
setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER_SUFFIX);
/**
* 50/2 trigger
*/
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL;
engineConfiguration->trigger.customTotalToothCount = 50;
engineConfiguration->trigger.customSkippedToothCount = 2;
boardConfiguration->useSerialPort = false;
// Frankenstein analog input #1: PA1 adc1 MAP
// Frankenstein analog input #2: PA3 adc3 TPS
// Frankenstein analog input #3: PC3 adc13 IAT
// Frankenstein analog input #4: PC1 adc11 CLT
// Frankenstein analog input #5: PA0 adc0 O2
// Frankenstein analog input #6: PC2 adc12
// Frankenstein analog input #7: PA4 adc4
// Frankenstein analog input #8: PA2 adc2
// Frankenstein analog input #9: PA6 adc6
// Frankenstein analog input #10: PA7 adc7
// Frankenstein analog input #11: PC4 adc14
// Frankenstein analog input #12: PC5 adc15
engineConfiguration->tpsAdcChannel = EFI_ADC_3;
engineConfiguration->vbattAdcChannel = EFI_ADC_NONE;
/**
* TPS 0% 0.9v
* TPS 100% 2.34v
*/
engineConfiguration->tpsMin = convertVoltageTo10bitADC(1.250);
engineConfiguration->tpsMax = convertVoltageTo10bitADC(4.538);
// Frankenstein: low side - out #1: PC14
// Frankenstein: low side - out #2: PC15
// Frankenstein: low side - out #3: PE6
// Frankenstein: low side - out #4: PC13
// Frankenstein: low side - out #5: PE4
// Frankenstein: low side - out #6: PE5
// Frankenstein: low side - out #7: PE2
// Frankenstein: low side - out #8: PE3
// Frankenstein: low side - out #9: PE0
// Frankenstein: low side - out #10: PE1
// Frankenstein: low side - out #11: PB8
// Frankenstein: low side - out #12: PB9
boardConfiguration->triggerInputPins[0] = GPIOA_5;
boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED;
boardConfiguration->injectionPins[0] = GPIOC_15;
boardConfiguration->fuelPumpPin = GPIOE_6;
// todo: extract a method? figure out something smarter
setFuelRpmBin(800, 15000 PASS_CONFIG_PARAMETER_SUFFIX);
setTimingRpmBin(800, 15000 PASS_CONFIG_PARAMETER_SUFFIX);
setLinearCurve(config->veRpmBins, FUEL_RPM_COUNT, 15000, 7000, 1);
setLinearCurve(config->afrRpmBins, FUEL_RPM_COUNT, 15000, 7000, 1);
engineConfiguration->hasFrequencyReportingMapSensor = true;
boardConfiguration->frequencyReportingMapInputPin = GPIOC_6;
boardConfiguration->mapFrequency100Kpa = 159;
boardConfiguration->mapFrequency0Kpa = 80;
}
void setFordAspireEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->tpsMin = 100;
engineConfiguration->tpsMax = 750;
engineConfiguration->rpmHardLimit = 7000;
/**
* 18K Ohm @ -20C
* 2.1K Ohm @ 24C
* 1K Ohm @ 49C
*/
setThermistorConfiguration(&engineConfiguration->clt, -20, 18000, 23.8889, 2100, 48.8889, 1000);
engineConfiguration->clt.config.bias_resistor = 3300; // that's my custom resistor value!
engineConfiguration->cranking.baseFuel = 3;
// engineConfiguration->ignitionPinMode = OM_INVERTED;
engineConfiguration->specs.cylindersCount = 4;
engineConfiguration->specs.displacement = 1.3;
// Denso 195500-2110
engineConfiguration->injector.flow = 119.8;
engineConfiguration->specs.firingOrder = FO_1_3_4_2;
engineConfiguration->globalTriggerAngleOffset = 175;
engineConfiguration->ignitionOffset = 87;
engineConfiguration->extraInjectionOffset = 54 + 360;
setDefaultAspireMaps(PASS_ENGINE_PARAMETER_SIGNATURE);
// set_cranking_rpm 550
engineConfiguration->cranking.rpm = 550;
// set cranking_charge_angle 70
engineConfiguration->crankingChargeAngle = 70;
// set cranking_timing_angle 37
engineConfiguration->crankingTimingAngle = -37;
setSingleCoilDwell(engineConfiguration);
engineConfiguration->ignitionMode = IM_ONE_COIL;
setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR);
engineConfiguration->useOnlyRisingEdgeForTrigger = true;
engineConfiguration->trigger.type = TT_FORD_ASPIRE;
boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED;
boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED;
engineConfiguration->HD44780width = 20;
engineConfiguration->HD44780height = 4;
// Frankenstein analog input #1: adc1
// Frankenstein analog input #2: adc3
// Frankenstein analog input #3: adc13
// Frankenstein analog input #4: adc11
// Frankenstein analog input #5: adc
// Frankenstein analog input #6: adc
// Frankenstein analog input #7: adc
// Frankenstein analog input #8: adc
// Frankenstein analog input #9: adc
// Frankenstein analog input #10: adc
// Frankenstein analog input #11: adc
// Frankenstein analog input #12: adc
engineConfiguration->tpsAdcChannel = EFI_ADC_3;
engineConfiguration->vbattAdcChannel = EFI_ADC_0;
engineConfiguration->map.sensor.hwChannel = EFI_ADC_4;
engineConfiguration->mafAdcChannel = EFI_ADC_1;
engineConfiguration->clt.adcChannel = EFI_ADC_11;
// engineConfiguration->iat.adcChannel =
engineConfiguration->map.sensor.type = MT_DENSO183;
engineConfiguration->engineSnifferRpmThreshold = 13000;
engineConfiguration->sensorSnifferRpmThreshold = 13000;
}
void setCamaro4(DECLARE_CONFIG_PARAMETER_SIGNATURE) {
setCustomEngineConfiguration(PASS_CONFIG_PARAMETER_SIGNATURE);
setAlgorithm(LM_SPEED_DENSITY PASS_CONFIG_PARAMETER_SUFFIX);
engineConfiguration->specs.displacement = 5.7;
engineConfiguration->specs.cylindersCount = 8;
engineConfiguration->specs.firingOrder = FO_1_8_7_2_6_5_4_3;
boardConfiguration->triggerInputPins[0] = GPIOA_5;
boardConfiguration->triggerInputPins[1] = GPIOC_6;
engineConfiguration->injectionMode = IM_BATCH;
engineConfiguration->twoWireBatchInjection = true;
// set ignition_mode 2
engineConfiguration->ignitionMode = IM_WASTED_SPARK;
setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
engineConfiguration->trigger.type = TT_GM_LS_24;
engineConfiguration->map.sensor.hwChannel = EFI_ADC_0; // PA0
engineConfiguration->mafAdcChannel = EFI_ADC_NONE;
engineConfiguration->tps1_1AdcChannel = EFI_ADC_2;
// todo: move this into trigger definition
// set global_trigger_offset_angle 230
engineConfiguration->globalTriggerAngleOffset = 230;
engineConfiguration->iat.adcChannel = EFI_ADC_11;
engineConfiguration->clt.adcChannel = EFI_ADC_12;
engineConfiguration->clt.config.bias_resistor = 2700;
engineConfiguration->vbattAdcChannel = EFI_ADC_14;
engineConfiguration->afr.hwChannel = EFI_ADC_13;
boardConfiguration->idle.solenoidPin = GPIO_UNASSIGNED;
boardConfiguration->fuelPumpPin = GPIO_UNASSIGNED;
boardConfiguration->injectionPins[0] = GPIOE_6;
boardConfiguration->injectionPins[1] = GPIOE_5;
boardConfiguration->injectionPins[2] = GPIOD_7;
boardConfiguration->injectionPins[3] = GPIOC_13;
boardConfiguration->injectionPins[4] = GPIOE_3;
boardConfiguration->injectionPins[5] = GPIOE_4;
boardConfiguration->injectionPins[6] = GPIOD_3;
boardConfiguration->injectionPins[7] = GPIOE_2;
boardConfiguration->ignitionPins[0] = GPIOC_9;
boardConfiguration->ignitionPins[1] = GPIOC_7;
boardConfiguration->ignitionPins[2] = GPIOE_14;
boardConfiguration->ignitionPins[3] = GPIOE_12;
boardConfiguration->ignitionPins[4] = GPIOE_10;
boardConfiguration->ignitionPins[5] = GPIOE_8;
boardConfiguration->ignitionPins[6] = GPIOD_9;
boardConfiguration->ignitionPins[7] = GPIOD_8;
boardConfiguration->fuelPumpPin = GPIOB_8;
boardConfiguration->fanPin = GPIO_UNASSIGNED;
boardConfiguration->mainRelayPin = GPIOD_5;
}
void setBmwE34(DECLARE_CONFIG_PARAMETER_SIGNATURE) {
// chartsize 450
engineConfiguration->engineChartSize = 450;
// setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR);
// engineConfiguration->trigger.type = TT_ONE_PLUS_TOOTHED_WHEEL_60_2;
// engineConfiguration->injectionMode = IM_SEQUENTIAL;
// boardConfiguration->triggerInputPins[0] = GPIOC_6;
// boardConfiguration->triggerInputPins[1] = GPIOA_5;
//Base engine setting
engineConfiguration->specs.cylindersCount = 6;
engineConfiguration->specs.displacement = 2.91;
engineConfiguration->specs.firingOrder = FO_1_5_3_6_2_4;
engineConfiguration->injectionMode = IM_BATCH;
engineConfiguration->twoWireBatchInjection = true;
engineConfiguration->ignitionMode = IM_WASTED_SPARK;
engineConfiguration->useOnlyRisingEdgeForTrigger = true;
boardConfiguration->tachOutputPin = GPIOC_8;
// Trigger configuration
// engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_60_2;
setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
// set global_trigger_offset_angle 84
engineConfiguration->globalTriggerAngleOffset = 84;
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL;
engineConfiguration->trigger.customTotalToothCount = 30;
engineConfiguration->trigger.customSkippedToothCount = 1;
// Injection settings
setFlatInjectorLag(1.15 PASS_CONFIG_PARAMETER_SUFFIX);
engineConfiguration->injector.flow = 750;
// General settings
boardConfiguration->tunerStudioSerialSpeed = 57600;
engineConfiguration->rpmHardLimit = 7000;
setAlgorithm(LM_SPEED_DENSITY PASS_CONFIG_PARAMETER_SUFFIX);
// for best performance at high RPM, we need to turn off 'Engine Sniffer' and 'Sensor Sniffer'
boardConfiguration->sensorChartMode = SC_OFF;
engineConfiguration->isEngineChartEnabled = false;
engineConfiguration->isCylinderCleanupEnabled = false;
engineConfiguration->isInjectionEnabled = true;
engineConfiguration->isIgnitionEnabled = true;
setConstantDwell(3 PASS_CONFIG_PARAMETER_SUFFIX); // a bit shorter dwell
engineConfiguration->ignMathCalculateAtIndex = 14;
engineConfiguration->mapAveragingSchedulingAtIndex = 6;
// Cranking
engineConfiguration->cranking.rpm = 600;
engineConfiguration->crankingInjectionMode = IM_BATCH;
// enable constant_dwell
engineConfiguration->useConstantDwellDuringCranking = true;
engineConfiguration->ignitionDwellForCrankingMs = 6;
// Inputs configuration
engineConfiguration->analogInputDividerCoefficient = 1.52;
engineConfiguration->vbattDividerCoeff = 5.33;
engineConfiguration->vbattAdcChannel = EFI_ADC_15; // PC5
engineConfiguration->tps1_1AdcChannel = EFI_ADC_3;
boardConfiguration->triggerInputPins[0] = GPIOA_5;
boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED;
setWholeTimingTable(25);
boardConfiguration->malfunctionIndicatorPin = GPIO_UNASSIGNED;
// bc->isFastAdcEnabled = true;
boardConfiguration->injectionPinMode = OM_INVERTED;
boardConfiguration->injectionPins[0] = GPIOB_8; // #1
boardConfiguration->injectionPins[1] = GPIOE_2; // #2
boardConfiguration->injectionPins[2] = GPIOE_3; // #3
boardConfiguration->injectionPins[3] = GPIOE_4; // #4
boardConfiguration->injectionPins[4] = GPIOE_5; // #5
boardConfiguration->injectionPins[5] = GPIOE_6; // #6
boardConfiguration->ignitionPinMode = OM_INVERTED;
boardConfiguration->ignitionPins[0] = GPIOB_5; // #1
boardConfiguration->ignitionPins[2] = GPIOB_6; // #3
boardConfiguration->ignitionPins[4] = GPIOB_7; // #5
boardConfiguration->canRxPin = GPIO_UNASSIGNED;
boardConfiguration->canTxPin = GPIO_UNASSIGNED;
boardConfiguration->triggerErrorPin = GPIO_UNASSIGNED;
// clutch up
boardConfiguration->clutchUpPin = GPIOD_3;
boardConfiguration->clutchUpPinMode = PI_PULLUP;
// fuel pump
boardConfiguration->fuelPumpPin = GPIOD_4;
// idle
boardConfiguration->idle.solenoidPin = GPIOC_14;
boardConfiguration->idle.solenoidPinMode = OM_INVERTED;
boardConfiguration->idle.solenoidFrequency = 300;
boardConfiguration->manIdlePosition = 50; // set_idle_pwm 50
// disable sd_card
boardConfiguration->sdCardCsPin = GPIO_UNASSIGNED;
boardConfiguration->is_enabled_spi_2 = false;
boardConfiguration->is_enabled_spi_3 = false;
boardConfiguration->max31855spiDevice = SPI_NONE;
// turbocharger boost control solenoid: TODO output: GPIOE_6
// water injection #1 TODO GPIOD_7
// water injection #2 TODO GPIOE_2
/**
* emulating the 60-0 trigger takes some resources, let's keep it slow by default
* rpm 200
*/
boardConfiguration->triggerSimulatorFrequency = 200;
// Configurating sensors:
// map
engineConfiguration->map.sensor.type = MT_MPX4250;
// thermistors
setThermistorConfiguration(&engineConfiguration->clt, -10, 9300, 20, 2500, 80, 335);
engineConfiguration->iat.config.bias_resistor = 2200;
setThermistorConfiguration(&engineConfiguration->iat, -10, 9300, 20, 2500, 80, 335);
engineConfiguration->clt.config.bias_resistor = 2200;
// /**
// * This saves a couple of ticks in trigger emulation methods
// * TODO: add some smart logic to detect unneeded trigger simulation pins?
// * TODO: but probably not worth it
// */
// bc->triggerSimulatorPins[1] = GPIO_UNASSIGNED;
boardConfiguration->triggerSimulatorPins[0] = GPIOD_1;
boardConfiguration->triggerSimulatorPins[1] = GPIOD_2;
boardConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED;
}
void setCitroenBerlingoTU3JPConfiguration(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->engineType = CITROEN_TU3JP;
/**
* Base engine setting
*/
setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_60_2;
engineConfiguration->globalTriggerAngleOffset = 114;
engineConfiguration->specs.cylindersCount = 4;
engineConfiguration->specs.displacement = 1.360;
engineConfiguration->specs.firingOrder = FO_1_THEN_3_THEN_4_THEN2;
engineConfiguration->ignitionMode = IM_WASTED_SPARK;
engineConfiguration->injectionMode = IM_BATCH;
engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS;
engineConfiguration->rpmHardLimit = 5000;
engineConfiguration->cranking.rpm = 600;
// memcpy(config->ve2RpmBins, rpmSteps, sizeof(rpmSteps));
/**
* Cranking fuel setting
* TODO: they recomend using something like -40C for low point and +80C for high point
*/
engineConfiguration->cranking.baseFuel = 15;
/**
* Algorithm Alpha-N setting
*/
setAlgorithm(LM_ALPHA_N PASS_ENGINE_PARAMETER);
setFuelLoadBin(0, 100 PASS_ENGINE_PARAMETER);
setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER);
setTimingRpmBin(800, 7000 PASS_ENGINE_PARAMETER);
/**
* Outputs
*/
// Frankenstein lo-side output #1: PC14 Igniter 1-4
// Frankenstein lo-side output #2: PC15 Igniter 2-3
// Frankenstein lo-side output #3: PE6 Injector 1-4
// Frankenstein lo-side output #4: PC13 Injector 2-3
// Frankenstein lo-side output #5: PE4
// Frankenstein lo-side output #6: PE5
// Frankenstein lo-side output #7: PE2
// Frankenstein lo-side output #8: PE3
// Frankenstein lo-side output #9: PE0 Fan
// Frankenstein lo-side output #10: PE1 MIL
// Frankenstein lo-side output #11: PB8 Main relay
// Frankenstein lo-side output #12: PB9 Fuel pump
boardConfiguration->ignitionPins[0] = GPIOC_14;
boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED;
boardConfiguration->ignitionPins[2] = GPIOC_15;
boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED;
engineConfiguration->injector.flow = 137; //SIEMENS DEKA VAZ20734
boardConfiguration->injectionPins[0] = GPIOE_6;
boardConfiguration->injectionPins[1] = GPIOC_13;
boardConfiguration->injectionPins[2] = GPIO_UNASSIGNED;
boardConfiguration->injectionPins[3] = GPIO_UNASSIGNED;
boardConfiguration->fanPin = GPIOE_0;
boardConfiguration->fanPinMode = OM_DEFAULT;
boardConfiguration->malfunctionIndicatorPin = GPIOE_1;
boardConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT;
boardConfiguration->mainRelayPin = GPIOB_8;
boardConfiguration->fuelPumpPin = GPIOB_9;
boardConfiguration->fuelPumpPinMode = OM_DEFAULT;
setLCD(boardConfiguration);
// boardConfiguration->o2heaterPin = GPIOC_13;
// boardConfiguration->logicAnalyzerPins[1] = GPIO_UNASSIGNED;
/**
* Inputs
*/
// See https://docs.google.com/spreadsheet/ccc?key=0Arl1FeMZcfisdEdGdUlHdWh6cVBoSzFIbkxqa1QtZ3c
// Frankenstein analog input #1: PA1 adc1 MAP
// Frankenstein analog input #2: PA3 adc3 TPS
// Frankenstein analog input #3: PC3 adc13 IAT
// Frankenstein analog input #4: PC1 adc11 CLT
// Frankenstein analog input #5: PA0 adc0 vBatt
// Frankenstein analog input #6: PC2 adc12 WBO
// Frankenstein analog input #7: PA4 adc4
// Frankenstein analog input #8: PA2 adc2
// Frankenstein analog input #9: PA6 adc6
// Frankenstein analog input #10: PA7 adc7
// Frankenstein analog input #11: PC4 adc14
// Frankenstein analog input #12: PC5|PA8 adc15 Speed Sensor
/**
* MAP <BOSCH 0 261 230 057>
*/
engineConfiguration->map.sensor.hwChannel = EFI_ADC_1;
engineConfiguration->map.sensor.type = MT_CUSTOM;
engineConfiguration->map.sensor.valueAt0 = 10;
engineConfiguration->map.sensor.valueAt5 = 110;
/**
* TPS <MAGNETI MARELLI>
*/
engineConfiguration->tpsAdcChannel = EFI_ADC_3;
engineConfiguration->tpsMin = 108; // convert 12to10 bit (ADC/4)
engineConfiguration->tpsMax = 812; // convert 12to10 bit (ADC/4)
/**
* IAT <OEM ECU>
*/
engineConfiguration->iat.adcChannel = EFI_ADC_13;
setThermistorConfiguration(&engineConfiguration->iat, -20.0, 15600.0, 23.0, 2250.0, 92.0, 240.0);
engineConfiguration->iat.config.bias_resistor = 2660;
/**
* CLT <LADA Samara>
*/
engineConfiguration->clt.adcChannel = EFI_ADC_11;
setThermistorConfiguration(&engineConfiguration->clt, -20.0, 28680.0, 25.0, 2796.0, 100.0, 177.0);
engineConfiguration->iat.config.bias_resistor = 2660;
/**
* vBatt
*/
engineConfiguration->vbattAdcChannel = EFI_ADC_0;
engineConfiguration->vbattDividerCoeff = ((float) (2.6 + 10.1)) / 2.6 * 2;
/**
* WBO Innovate LC-1
*/
engineConfiguration->afr.hwChannel = EFI_ADC_12;
/**
* Speed Sensor
*/
boardConfiguration->vehicleSpeedSensorInputPin = GPIOA_8;
engineConfiguration->hasVehicleSpeedSensor = true;
/**
* Other
*/
// engineConfiguration->mafAdcChannel = GPIO_UNASSIGNED;
copyFuelTable(tps_fuel_table, config->fuelTable);
copyTimingTable(tps_advance_table, config->ignitionTable);
}
void setRoverv8(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
// set trigger_type 9
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_36_1;
boardConfiguration->is_enabled_spi_2 = false;
boardConfiguration->isHip9011Enabled = false;
setFrankenstein_01_LCD(boardConfiguration);
engineConfiguration->specs.displacement = 3.528;
engineConfiguration->specs.cylindersCount = 8;
engineConfiguration->specs.firingOrder = FO_1_8_4_3_6_5_7_2;
// set_rpm_hard_limit 4000
engineConfiguration->rpmHardLimit = 4000; // yes, 4k. let's play it safe for now
// set_cranking_rpm 350
engineConfiguration->cranking.rpm = 350;
// set_whole_fuel_map 3
setWholeFuelMap(3 PASS_CONFIG_PARAMETER_SUFFIX);
// set cranking_injection_mode 0
engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS;
// set injection_mode 1
engineConfiguration->injectionMode = IM_SEQUENTIAL;
// set ignition_mode 2
engineConfiguration->ignitionMode = IM_WASTED_SPARK;
boardConfiguration->ignitionPinMode = OM_INVERTED;
// set_ignition_channels
boardConfiguration->ignitionPins[0] = GPIOE_8; // Frankenstein: low side - out #x (?)
boardConfiguration->ignitionPins[7] = GPIOE_10; // Frankenstein: low side - out #x (?)
boardConfiguration->ignitionPins[3] = GPIOE_12; // Frankenstein: low side - out #x (?)
boardConfiguration->ignitionPins[2] = GPIOE_14; // Frankenstein: low side - out #x (?)
// Frankenstein: low side - out #1: PC14
// Frankenstein: low side - out #2: PC15
// Frankenstein: low side - out #3: PE6
// Frankenstein: low side - out #4: PC13
// Frankenstein: low side - out #5: PE4
// Frankenstein: low side - out #6: PE5
// Frankenstein: low side - out #7: PE2
// Frankenstein: low side - out #8: PE3
// Frankenstein: low side - out #9: PE0
// Frankenstein: low side - out #10: PE1
// Frankenstein: low side - out #11: PB8
// Frankenstein: low side - out #12: PB9
boardConfiguration->injectionPins[0] = GPIOC_14; // Frankenstein: low side - out #1
boardConfiguration->injectionPins[1] = GPIOC_15; // Frankenstein: low side - out #2
boardConfiguration->injectionPins[2] = GPIOE_6; // Frankenstein: low side - out #3
boardConfiguration->injectionPins[3] = GPIOC_13; // Frankenstein: low side - out #4
boardConfiguration->injectionPins[4] = GPIOE_4; // Frankenstein: low side - out #5
boardConfiguration->injectionPins[5] = GPIOE_5; // Frankenstein: low side - out #6
boardConfiguration->injectionPins[6] = GPIOE_2; // Frankenstein: low side - out #7
boardConfiguration->injectionPins[7] = GPIOE_3; // Frankenstein: low side - out #8
// not valid ICU pin boardConfiguration->vehicleSpeedSensorInputPin = GPIOC_2;
//GPIOE_0 AND GPIOE_1 are bad pins since they conflict with accelerometer
//no malfunction indicator pin needed, since we use CAN_BUS_MAZDA_RX8
//boardConfiguration->fuelPumpPin = GPIOE_0; // Frankenstein: low side - out #9
//boardConfiguration->malfunctionIndicatorPin = GPIOE_1; // Frankenstein: low side - out #10
boardConfiguration->fuelPumpPin = GPIOB_8; // Frankenstein: low side - out #11
boardConfiguration->fuelPumpPinMode = OM_DEFAULT;
boardConfiguration->mainRelayPin = GPIOB_9; // Frankenstein: low side - out #12
boardConfiguration->triggerInputPins[0] = GPIOC_6; // 2G YEL/BLU
boardConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP
setCommonNTCSensor(&engineConfiguration->clt);
engineConfiguration->clt.config.bias_resistor = 2700;
setCommonNTCSensor(&engineConfiguration->iat);
engineConfiguration->iat.config.bias_resistor = 2700;
engineConfiguration->tpsAdcChannel = EFI_ADC_3; //Frankenstein: inp2
engineConfiguration->vbattAdcChannel = EFI_ADC_0; //Frankenstein: inp5
engineConfiguration->clt.adcChannel = EFI_ADC_11;
engineConfiguration->iat.adcChannel = EFI_ADC_13;
setCommonNTCSensor(&engineConfiguration->clt);
engineConfiguration->clt.config.bias_resistor = 2700;
setCommonNTCSensor(&engineConfiguration->iat);
engineConfiguration->iat.config.bias_resistor = 2700;
/**
* TPS 0% 0.9v
* TPS 100% 2.34v
*/
engineConfiguration->tpsMin = convertVoltageTo10bitADC(1.250);
engineConfiguration->tpsMax = convertVoltageTo10bitADC(4.538);
// Stepper logic:
boardConfiguration->idle.stepperDirectionPin = GPIOB_10;
boardConfiguration->idle.stepperStepPin = GPIOB_15;
engineConfiguration->stepperEnablePin = GPIOB_14;
engineConfiguration->idleStepperReactionTime = 10;
engineConfiguration->idleStepperTotalSteps = 150;
boardConfiguration->useStepperIdle = false;
// set injection_pin_mode 0
boardConfiguration->injectionPinMode = OM_DEFAULT;
boardConfiguration->canTxPin = GPIOB_6;
boardConfiguration->canRxPin = GPIOB_12;
engineConfiguration->canWriteEnabled = true;
engineConfiguration->canReadEnabled = false;
engineConfiguration->canNbcType = CAN_BUS_MAZDA_RX8;
setAlgorithm(LM_SPEED_DENSITY PASS_CONFIG_PARAMETER_SUFFIX);
// todo: make this official Frankenstein joystick?
boardConfiguration->joystickCenterPin = GPIOD_8;
boardConfiguration->joystickAPin = GPIOD_10;
boardConfiguration->joystickBPin = GPIO_UNASSIGNED;
boardConfiguration->joystickCPin = GPIO_UNASSIGNED;
boardConfiguration->joystickDPin = GPIOD_11;
}
