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; }