bool SparseOptimizerIncremental::initSolver(int dimension, int batchEveryN) { //cerr << __PRETTY_FUNCTION__ << endl; slamDimension = dimension; if (dimension == 3) { setAlgorithm(createSolver("fix3_2_cholmod")); OptimizationAlgorithmGaussNewton* gaussNewton = dynamic_cast<OptimizationAlgorithmGaussNewton*>(solver()); assert(gaussNewton); BlockSolver<BlockSolverTraits<3, 2> >* bs = dynamic_cast<BlockSolver<BlockSolverTraits<3, 2> >*>(gaussNewton->solver()); assert(bs && "Unable to get internal block solver"); LinearSolverCholmodOnline<Matrix3d>* s = dynamic_cast<LinearSolverCholmodOnline<Matrix3d>*>(bs->linearSolver()); bs->setAdditionalVectorSpace(300); bs->setSchur(false); _solverInterface = s; _underlyingSolver = bs; } else { setAlgorithm(createSolver("fix6_3_cholmod")); OptimizationAlgorithmGaussNewton* gaussNewton = dynamic_cast<OptimizationAlgorithmGaussNewton*>(solver()); assert(gaussNewton); BlockSolver<BlockSolverTraits<6, 3> >* bs = dynamic_cast<BlockSolver<BlockSolverTraits<6, 3> >*>(gaussNewton->solver()); assert(bs && "Unable to get internal block solver"); LinearSolverCholmodOnline<Matrix<double, 6, 6> >* s = dynamic_cast<LinearSolverCholmodOnline<Matrix<double, 6, 6> >*>(bs->linearSolver()); bs->setAdditionalVectorSpace(600); bs->setSchur(false); _solverInterface = s; _underlyingSolver = bs; } _solverInterface->cmember = &_cmember; _solverInterface->batchEveryN = batchEveryN; if (! solver()) { cerr << "Error allocating solver. Allocating CHOLMOD solver failed!" << endl; return false; } return true; }
void BSafe::BSafeKeyPairGenContext::setupAlgorithm( const Context &context, uint32 &keySize) { switch(context.algorithm()) { case CSSM_ALGID_RSA: { A_RSA_KEY_GEN_PARAMS genParams; keySize = genParams.modulusBits = context.getInt(CSSM_ATTRIBUTE_KEY_LENGTH, CSSMERR_CSP_INVALID_ATTR_KEY_LENGTH); if (CssmData *params = context.get<CssmData>(CSSM_ATTRIBUTE_ALG_PARAMS)) { genParams.publicExponent = BSafeItem(*params); } else { static unsigned char exponent[] = { 1, 0, 1 }; genParams.publicExponent = BSafeItem(exponent, sizeof(exponent)); } /* * For test purposes, we avoid the 'strong' key generate * algorithm if a CSSM_ALGMODE_CUSTOM mode atrtribute * is present in the context. This is not published and * not supported in the real world. */ uint32 mode = context.getInt(CSSM_ATTRIBUTE_MODE); if(mode == CSSM_ALGMODE_CUSTOM) { setAlgorithm(AI_RSAKeyGen, &genParams); } else { setAlgorithm(AI_RSAStrongKeyGen, &genParams); } } break; case CSSM_ALGID_DSA: { A_DSA_PARAMS genParams; genParams.prime = BSafeItem(context.get<CssmData>( CSSM_ATTRIBUTE_PRIME, CSSMERR_CSP_MISSING_ATTR_ALG_PARAMS)); genParams.subPrime = BSafeItem(context.get<CssmData>( CSSM_ATTRIBUTE_SUBPRIME, CSSMERR_CSP_MISSING_ATTR_ALG_PARAMS)); genParams.base = BSafeItem(context.get<CssmData>( CSSM_ATTRIBUTE_BASE, CSSMERR_CSP_MISSING_ATTR_ALG_PARAMS)); setAlgorithm(AI_DSAKeyGen, &genParams); keySize = B_IntegerBits(genParams.prime.data, genParams.prime.len); } break; default: CssmError::throwMe(CSSMERR_CSP_INTERNAL_ERROR); } }
QColor choseCAndF::choseColor(const colorAlgorithm& color,const int& index) { setAlgorithm(color); switch( this->algorithm()+index){ case black: currentColor=Qt::black; break; case red: currentColor=Qt::red; break; case yellow: currentColor=Qt::yellow; break; case blue: currentColor=Qt::blue; break; case green: currentColor=Qt::green; break; case cyan: currentColor=Qt::cyan; break; } emit colorChanged(currentColor); return currentColor; }
ZoneAirHeatBalanceAlgorithm::ZoneAirHeatBalanceAlgorithm(Model& model) : ModelObject(ZoneAirHeatBalanceAlgorithm::iddObjectType(),model) { OS_ASSERT(getImpl<detail::ZoneAirHeatBalanceAlgorithm_Impl>()); setAlgorithm("ThirdOrderBackwardDifference"); }
bool RGBMatrix::copyFrom(const Function* function) { const RGBMatrix* mtx = qobject_cast<const RGBMatrix*> (function); if (mtx == NULL) return false; setFixtureGroup(mtx->fixtureGroup()); if (mtx->algorithm() != NULL) setAlgorithm(mtx->algorithm()->clone()); else setAlgorithm(NULL); setStartColor(mtx->startColor()); setEndColor(mtx->endColor()); return Function::copyFrom(function); }
AverageLevelFiltered::AverageLevelFiltered( const int numberOfChannels, const double sampleRate, const int fftBufferSize, const int averageAlgorithm) : frut::dsp::FIRFilterBox(numberOfChannels, fftBufferSize), sampleRate_(sampleRate), previousSamplesPreFilterInput_( numberOfChannels_, KMETER_MAXIMUM_FILTER_STAGES - 1), previousSamplesPreFilterOutput_( numberOfChannels_, KMETER_MAXIMUM_FILTER_STAGES - 1), previousSamplesWeightingFilterInput_( numberOfChannels_, KMETER_MAXIMUM_FILTER_STAGES - 1), previousSamplesWeightingFilterOutput_( numberOfChannels_, KMETER_MAXIMUM_FILTER_STAGES - 1), previousSamplesOutputTemp_(1, fftBufferSize_) { dither_.initialise(numberOfChannels_, 24); peakToAverageCorrection_ = 0.0f; averageAlgorithm_ = -1; float meterMinimumDecibel = MeterBallistics::getMeterMinimumDecibel(); for (int channel = 0; channel < numberOfChannels_; ++channel) { loudnessValues_.add(meterMinimumDecibel); } // also calculates filter kernel setAlgorithm(averageAlgorithm); }
/// constructor InsideSurfaceConvectionAlgorithm::InsideSurfaceConvectionAlgorithm(const Model& model) : ModelObject(InsideSurfaceConvectionAlgorithm::iddObjectType(),model) { OS_ASSERT(getImpl<detail::InsideSurfaceConvectionAlgorithm_Impl>()); setAlgorithm("TARP"); }
bool RGBMatrix::loadXML(const QDomElement& root) { if (root.tagName() != KXMLQLCFunction) { qWarning() << Q_FUNC_INFO << "Function node not found"; return false; } if (root.attribute(KXMLQLCFunctionType) != typeToString(Function::RGBMatrix)) { qWarning() << Q_FUNC_INFO << "Function is not an RGB matrix"; return false; } /* Load matrix contents */ QDomNode node = root.firstChild(); while (node.isNull() == false) { QDomElement tag = node.toElement(); if (tag.tagName() == KXMLQLCFunctionSpeed) { loadXMLSpeed(tag); } else if (tag.tagName() == KXMLQLCRGBAlgorithm) { setAlgorithm(RGBAlgorithm::loader(doc(), tag)); } else if (tag.tagName() == KXMLQLCRGBMatrixFixtureGroup) { setFixtureGroup(tag.text().toUInt()); } else if (tag.tagName() == KXMLQLCFunctionDirection) { loadXMLDirection(tag); } else if (tag.tagName() == KXMLQLCFunctionRunOrder) { loadXMLRunOrder(tag); } else if (tag.tagName() == KXMLQLCRGBMatrixStartColor) { setStartColor(QColor::fromRgb(QRgb(tag.text().toUInt()))); } else if (tag.tagName() == KXMLQLCRGBMatrixEndColor) { setEndColor(QColor::fromRgb(QRgb(tag.text().toUInt()))); } else { qWarning() << Q_FUNC_INFO << "Unknown RGB matrix tag:" << tag.tagName(); } node = node.nextSibling(); } return true; }
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 ContinuousProcessingThread::run() { while (pProcessingMode->getRunning()) { setInput(); pInput->read(); setAlgorithm(); pAlgorithm->execute(); setOutput(); pOutput->outputResult(); Sleep(1000); } }
void setDodgeStratus(DECLARE_ENGINE_PARAMETER_F) { engineConfiguration->trigger.type = TT_DODGE_STRATUS; engineConfiguration->specs.cylindersCount = 6; engineConfiguration->specs.firingOrder = FO_1_THEN_2_THEN_3_THEN_4_THEN_5_THEN_6; engineConfiguration->map.sensor.type = MT_DODGE_NEON_2003; setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS; boardConfiguration->ignitionPins[0] = GPIOC_9; boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; boardConfiguration->ignitionPins[2] = GPIOE_8; boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; boardConfiguration->ignitionPins[4] = GPIO_UNASSIGNED; boardConfiguration->ignitionPins[5] = GPIO_UNASSIGNED; }
RGBMatrix::RGBMatrix(Doc* doc) : Function(doc, Function::RGBMatrix) , m_fixtureGroup(FixtureGroup::invalidId()) , m_algorithm(NULL) , m_startColor(Qt::red) , m_endColor(QColor()) , m_fader(NULL) , m_step(0) , m_roundTime(new QTime) , m_stepColor(QColor()) , m_crDelta(0) , m_cgDelta(0) , m_cbDelta(0) { setName(tr("New RGB Matrix")); setDuration(500); RGBScript scr = RGBScript::script(doc, "Full Columns"); setAlgorithm(scr.clone()); }
RGBMatrix::RGBMatrix(Doc* doc) : Function(doc, Function::RGBMatrixType) , m_dimmerControl(true) , m_fixtureGroupID(FixtureGroup::invalidId()) , m_group(NULL) , m_algorithm(NULL) , m_algorithmMutex(QMutex::Recursive) , m_startColor(Qt::red) , m_endColor(QColor()) , m_stepHandler(new RGBMatrixStep()) , m_fader(NULL) , m_roundTime(new QElapsedTimer()) , m_stepsCount(0) , m_stepBeatDuration(0) { setName(tr("New RGB Matrix")); setDuration(500); RGBScript scr = doc->rgbScriptsCache()->script("Stripes"); setAlgorithm(scr.clone()); }
RGBMatrix::RGBMatrix(Doc* doc) : Function(doc, Function::RGBMatrix) , m_fixtureGroupID(FixtureGroup::invalidId()) , m_algorithm(NULL) , m_algorithmMutex(QMutex::Recursive) , m_startColor(Qt::red) , m_endColor(QColor()) , m_fader(NULL) , m_step(0) , m_roundTime(new QTime) , m_stepColor(QColor()) , m_crDelta(0.0) , m_cgDelta(0.0) , m_cbDelta(0.0) , m_stepCount(0) { setName(tr("New RGB Matrix")); setDuration(500); RGBScript scr = doc->rgbScriptsCache()->script("Stripes"); setAlgorithm(scr.clone()); }
void Machinery::setup(const kerberos::StringMap & settings) { // ----------------------------------------------------------- // Creates condition, algorithms, expositors, heuristics and io handlers. LINFO << "Starting conditions: " + settings.at("condition"); std::vector<Condition *> conditions = Factory<Condition>::getInstance()->createMultiple(settings.at("condition")); for(int i = 0; i < conditions.size(); i++) { conditions[i]->setup(settings); } setCondition(conditions); LINFO << "Starting algorithm: " + settings.at("algorithm"); Algorithm * algorithm = Factory<Algorithm>::getInstance()->create(settings.at("algorithm")); algorithm->setup(settings); setAlgorithm(algorithm); LINFO << "Starting expositor: " + settings.at("expositor"); Expositor * expositor = Factory<Expositor>::getInstance()->create(settings.at("expositor")); expositor->setup(settings); setExpositor(expositor); LINFO << "Starting heuristic: " + settings.at("heuristic"); Heuristic * heuristic = Factory<Heuristic>::getInstance()->create(settings.at("heuristic")); heuristic->setup(settings); setHeuristic(heuristic); LINFO << "Starting io devices: " + settings.at("io"); std::vector<Io *> ios = Factory<Io>::getInstance()->createMultiple(settings.at("io")); for(int i = 0; i < ios.size(); i++) { ios[i]->setup(settings); } setIo(ios); }
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); }
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); }
bool RGBMatrix::loadXML(QXmlStreamReader &root) { if (root.name() != KXMLQLCFunction) { qWarning() << Q_FUNC_INFO << "Function node not found"; return false; } if (root.attributes().value(KXMLQLCFunctionType).toString() != typeToString(Function::RGBMatrixType)) { qWarning() << Q_FUNC_INFO << "Function is not an RGB matrix"; return false; } /* Load matrix contents */ while (root.readNextStartElement()) { if (root.name() == KXMLQLCFunctionSpeed) { loadXMLSpeed(root); } else if (root.name() == KXMLQLCRGBAlgorithm) { setAlgorithm(RGBAlgorithm::loader(doc(), root)); } else if (root.name() == KXMLQLCRGBMatrixFixtureGroup) { setFixtureGroup(root.readElementText().toUInt()); } else if (root.name() == KXMLQLCFunctionDirection) { loadXMLDirection(root); } else if (root.name() == KXMLQLCFunctionRunOrder) { loadXMLRunOrder(root); } else if (root.name() == KXMLQLCRGBMatrixStartColor) { setStartColor(QColor::fromRgb(QRgb(root.readElementText().toUInt()))); } else if (root.name() == KXMLQLCRGBMatrixEndColor) { setEndColor(QColor::fromRgb(QRgb(root.readElementText().toUInt()))); } else if (root.name() == KXMLQLCRGBMatrixProperty) { QString name = root.attributes().value(KXMLQLCRGBMatrixPropertyName).toString(); QString value = root.attributes().value(KXMLQLCRGBMatrixPropertyValue).toString(); setProperty(name, value); root.skipCurrentElement(); } else if (root.name() == KXMLQLCRGBMatrixDimmerControl) { setDimmerControl(root.readElementText().toInt()); } else { qWarning() << Q_FUNC_INFO << "Unknown RGB matrix tag:" << root.name(); root.skipCurrentElement(); } } return true; }
bool EFX::loadXML(const QDomElement& root) { if (root.tagName() != KXMLQLCFunction) { qWarning() << "Function node not found!"; return false; } if (root.attribute(KXMLQLCFunctionType) != typeToString(Function::EFX)) { qWarning("Function is not an EFX!"); return false; } /* Load EFX contents */ QDomNode node = root.firstChild(); while (node.isNull() == false) { QDomElement tag = node.toElement(); if (tag.tagName() == KXMLQLCBus) { /* Bus */ QString str = tag.attribute(KXMLQLCBusRole); if (str == KXMLQLCBusFade) m_legacyFadeBus = tag.text().toUInt(); else if (str == KXMLQLCBusHold) m_legacyHoldBus = tag.text().toUInt(); } else if (tag.tagName() == KXMLQLCFunctionSpeed) { loadXMLSpeed(tag); } else if (tag.tagName() == KXMLQLCEFXFixture) { EFXFixture* ef = new EFXFixture(this); ef->loadXML(tag); if (ef->fixture() != Fixture::invalidId()) { if (addFixture(ef) == false) delete ef; } } else if (tag.tagName() == KXMLQLCEFXPropagationMode) { /* Propagation mode */ setPropagationMode(stringToPropagationMode(tag.text())); } else if (tag.tagName() == KXMLQLCEFXAlgorithm) { /* Algorithm */ setAlgorithm(stringToAlgorithm(tag.text())); } else if (tag.tagName() == KXMLQLCFunctionDirection) { loadXMLDirection(tag); } else if (tag.tagName() == KXMLQLCFunctionRunOrder) { loadXMLRunOrder(tag); } else if (tag.tagName() == KXMLQLCEFXWidth) { /* Width */ setWidth(tag.text().toInt()); } else if (tag.tagName() == KXMLQLCEFXHeight) { /* Height */ setHeight(tag.text().toInt()); } else if (tag.tagName() == KXMLQLCEFXRotation) { /* Rotation */ setRotation(tag.text().toInt()); } else if (tag.tagName() == KXMLQLCEFXStartOffset) { /* StartOffset */ setStartOffset(tag.text().toInt()); } else if (tag.tagName() == KXMLQLCEFXAxis) { /* Axes */ loadXMLAxis(tag); } else { qWarning() << "Unknown EFX tag:" << tag.tagName(); } node = node.nextSibling(); } return true; }
/** * pin 1I/W9 - extra +5v * set_engine_type 14 */ void setFordEscortGt(DECLARE_ENGINE_PARAMETER_F) { engineConfiguration->trigger.type = TT_MAZDA_DOHC_1_4; common079721_2351(engineConfiguration, boardConfiguration); setFrankenso_01_LCD(boardConfiguration); setFrankenso0_1_joystick(engineConfiguration); setDensoTODO(config); engineConfiguration->globalFuelCorrection = 0.75; engineConfiguration->specs.displacement = 1.839; // engineConfiguration->algorithm = LM_PLAIN_MAF; setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); // engineConfiguration->algorithm = LM_REAL_MAF; setFuelLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER); setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER); config->veRpmBins[0] = 800; config->veRpmBins[1] = 1200; config->veRpmBins[2] = 1600; config->veRpmBins[3] = 2000; config->veRpmBins[4] = 2400; config->veRpmBins[5] = 2800; config->veRpmBins[6] = 3200; config->veRpmBins[7] = 3600; config->veRpmBins[8] = 4100; config->veRpmBins[9] = 4500; config->veRpmBins[10] = 4900; config->veRpmBins[11] = 5300; config->veRpmBins[12] = 5700; config->veRpmBins[13] = 6100; config->veRpmBins[14] = 6500; config->veRpmBins[15] = 7000; copyFuelTable(racingFestivaVeTable, config->veTable); // boardConfiguration->triggerInputPins[0] = GPIOC_6; // 2G YEL/BLU // boardConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP // in case of SOHC distributor we only have one signal // boardConfiguration->triggerInputPins[0] = GPIOA_5; // 2E White CKP // boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; // in case of DOHC distributor we have two signals boardConfiguration->triggerInputPins[0] = GPIOC_6; boardConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP // Denso 195500-2180 engineConfiguration->injector.flow = 265; engineConfiguration->hasBaroSensor = false; engineConfiguration->hasMapSensor = true; boardConfiguration->isFastAdcEnabled = true; engineConfiguration->map.sensor.type = MT_DENSO183; engineConfiguration->map.sensor.hwChannel = EFI_ADC_4; setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER); engineConfiguration->afr.hwChannel = EFI_ADC_2; // Frankenso analog #5 // set_idle_position 10 boardConfiguration->manIdlePosition = 10; setWholeIatCorrTimingTable(0 PASS_ENGINE_PARAMETER); // set_global_trigger_offset_angle -37 engineConfiguration->globalTriggerAngleOffset = -37; // set_ignition_offset 0 engineConfiguration->ignitionOffset = 0; // set_injection_offset 0 engineConfiguration->injectionOffset = 0; // todo: change to 15? // set_cranking_timing_angle 3 engineConfiguration->crankingTimingAngle = 3; engineConfiguration->crankingChargeAngle = 70; // set_cranking_fuel 9 engineConfiguration->cranking.baseFuel = 9; setTableBin2(config->ignitionLoadBins, IGN_LOAD_COUNT, 20, 105, 5); setWholeTimingTable(10 PASS_ENGINE_PARAMETER); // set_whole_fuel_map 5 setWholeFuelMap(5 PASS_ENGINE_PARAMETER); setMap(config->afrTable, 13.5); setSingleCoilDwell(engineConfiguration); engineConfiguration->ignitionMode = IM_ONE_COIL; boardConfiguration->triggerSimulatorPinModes[0] = OM_OPENDRAIN; boardConfiguration->triggerSimulatorPinModes[1] = OM_OPENDRAIN; 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; // individual coils // W6 PC9 // W8 PC7 // W12 PE8 // W13 PE12 /** * Outputs */ // Frankenso low out #1: PE6 // Frankenso low out #2: PE5 MIL // Frankenso low out #3: // Frankenso low out #4: // Frankenso low out #5: PE3 VICS solenoid // Frankenso low out #6: PE4 // Frankenso low out #7: PE0<>PD5 // Frankenso low out #8: PE2 INJ // Frankenso low out #9: PB9 IDLE // Frankenso low out #10: PE1<>PD3 INJ 1&3 // Frankenso low out #11: PB8 // Frankenso low out #12: PB7 boardConfiguration->injectionPins[0] = GPIOD_3; boardConfiguration->injectionPins[1] = GPIOE_2; //setDefaultCrankingFuel(engineConfiguration); engineConfiguration->cranking.baseFuel = 5; // 40% idle is good default boardConfiguration->idle.solenoidFrequency = 300; boardConfiguration->idle.solenoidPin = GPIOB_9; boardConfiguration->malfunctionIndicatorPin = GPIOE_5; boardConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; boardConfiguration->tunerStudioSerialSpeed = 19200; commonFrankensoAnalogInputs(engineConfiguration); setCommonNTCSensor(&engineConfiguration->clt); engineConfiguration->clt.config.bias_resistor = 2700; setCommonNTCSensor(&engineConfiguration->iat); engineConfiguration->iat.config.bias_resistor = 2700; // we have a 1999 Auto Miata TB mounted on this car engineConfiguration->hasTpsSensor = true; engineConfiguration->tpsMin = 115; // convert 12to10 bit (ADC/4) engineConfiguration->tpsMax = 630; // convert 12to10 bit (ADC/4) engineConfiguration->tpsAdcChannel = EFI_ADC_3; // engineConfiguration->map.sensor.hwChannel = EFI_ADC_4; engineConfiguration->mafAdcChannel = EFI_ADC_0; engineConfiguration->clt.adcChannel = EFI_ADC_12; engineConfiguration->iat.adcChannel = EFI_ADC_11; // todo: 8.2 or 10k? engineConfiguration->vbattDividerCoeff = ((float) (10 + 33)) / 10 * 2; // VICS solenoid /** * to test * set_fsio_setting 0 5000 */ engineConfiguration->bc.fsio_setting[0] = 5000; // set_fsio_expression 1 "rpm 0 fsio_setting >" setFsioExt(0, GPIOE_3, "rpm 0 fsio_setting >", 150 PASS_ENGINE_PARAMETER); // warning light /** * to test * set_fsio_setting 1 1800 * set_fsio_setting 2 95 * set_fsio_setting 3 14 * * set_fsio_expression 1 "rpm 0 fsio_setting > coolant 1 fsio_setting > | vbatt 2 fsio_setting < |" * eval "rpm 0 fsio_setting > coolant 1 fsio_setting > | vbatt 2 fsio_setting < |" */ engineConfiguration->bc.fsio_setting[1] = 6200; // RPM threshold engineConfiguration->bc.fsio_setting[2] = 90; // CLT threshold engineConfiguration->bc.fsio_setting[3] = 13.5; // voltage threshold setFsio(1, GPIOC_13, "rpm 1 fsio_setting > coolant 2 fsio_setting > | vbatt 3 fsio_setting < |" PASS_ENGINE_PARAMETER); config->ignitionRpmBins[0] = 800; config->ignitionRpmBins[1] = 1200; config->ignitionRpmBins[2] = 1600; config->ignitionRpmBins[3] = 2000; config->ignitionRpmBins[4] = 2400; config->ignitionRpmBins[5] = 2800; config->ignitionRpmBins[6] = 3200; config->ignitionRpmBins[7] = 3600; config->ignitionRpmBins[8] = 4100; config->ignitionRpmBins[9] = 4500; config->ignitionRpmBins[10] = 4900; config->ignitionRpmBins[11] = 5300; config->ignitionRpmBins[12] = 5700; config->ignitionRpmBins[13] = 6100; config->ignitionRpmBins[14] = 6500; config->ignitionRpmBins[15] = 7000; copyTimingTable(racingFestivaIgnitionTable, config->ignitionTable); // boardConfiguration->useWarmupPidAfr = true; engineConfiguration->warmupAfrPid.pFactor = -0.2; engineConfiguration->warmupAfrPid.iFactor = -0.0005; // engineConfiguration->warmupAfrPid.dFactor = -0.02; engineConfiguration->debugMode = WARMUP_ENRICH; // end of Ford Escort GT config }
bool EFX::loadXML(QXmlStreamReader &root) { if (root.name() != KXMLQLCFunction) { qWarning() << "Function node not found!"; return false; } if (root.attributes().value(KXMLQLCFunctionType).toString() != typeToString(Function::EFX)) { qWarning("Function is not an EFX!"); return false; } /* Load EFX contents */ while (root.readNextStartElement()) { if (root.name() == KXMLQLCBus) { /* Bus */ QString str = root.attributes().value(KXMLQLCBusRole).toString(); if (str == KXMLQLCBusFade) m_legacyFadeBus = root.readElementText().toUInt(); else if (str == KXMLQLCBusHold) m_legacyHoldBus = root.readElementText().toUInt(); } else if (root.name() == KXMLQLCFunctionSpeed) { loadXMLSpeed(root); } else if (root.name() == KXMLQLCEFXFixture) { EFXFixture* ef = new EFXFixture(this); ef->loadXML(root); if (ef->head().isValid()) { if (addFixture(ef) == false) delete ef; } } else if (root.name() == KXMLQLCEFXPropagationMode) { /* Propagation mode */ setPropagationMode(stringToPropagationMode(root.readElementText())); } else if (root.name() == KXMLQLCEFXAlgorithm) { /* Algorithm */ setAlgorithm(stringToAlgorithm(root.readElementText())); } else if (root.name() == KXMLQLCFunctionDirection) { loadXMLDirection(root); } else if (root.name() == KXMLQLCFunctionRunOrder) { loadXMLRunOrder(root); } else if (root.name() == KXMLQLCEFXWidth) { /* Width */ setWidth(root.readElementText().toInt()); } else if (root.name() == KXMLQLCEFXHeight) { /* Height */ setHeight(root.readElementText().toInt()); } else if (root.name() == KXMLQLCEFXRotation) { /* Rotation */ setRotation(root.readElementText().toInt()); } else if (root.name() == KXMLQLCEFXStartOffset) { /* StartOffset */ setStartOffset(root.readElementText().toInt()); } else if (root.name() == KXMLQLCEFXIsRelative) { /* IsRelative */ setIsRelative(root.readElementText().toInt() != 0); } else if (root.name() == KXMLQLCEFXAxis) { /* Axes */ loadXMLAxis(root); } else { qWarning() << "Unknown EFX tag:" << root.name(); root.skipCurrentElement(); } } return true; }
/** * this method is used in console - it also prints current configuration */ static void setAlgorithmInt(int value) { setAlgorithm((engine_load_mode_e) value); doPrintConfiguration(engine); }
static void setHondaAccordConfigurationCommon(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->map.sensor.type = MT_DENSO183; boardConfiguration->isFastAdcEnabled = true; // set ignition_mode 0 engineConfiguration->ignitionMode = IM_ONE_COIL; // set injection_mode engineConfiguration->injectionMode = IM_BATCH; engineConfiguration->idleMode = IM_MANUAL; engineConfiguration->HD44780height = 4; engineConfiguration->specs.cylindersCount = 4; engineConfiguration->specs.displacement = 2.156; // Keihin 06164-P0A-A00 engineConfiguration->injector.flow = 248; setAlgorithm(LM_SPEED_DENSITY PASS_CONFIG_PARAMETER_SUFFIX); setFuelLoadBin(0, 100 PASS_CONFIG_PARAMETER_SUFFIX); buildTimingMap(35 PASS_CONFIG_PARAMETER_SUFFIX); /** * 18K Ohm @ -20C * 2.1K Ohm @ 24C * 100 Ohm @ 120C */ setCommonNTCSensor(&engineConfiguration->clt); engineConfiguration->clt.config.bias_resistor = 1500; // same as OEM ECU setCommonNTCSensor(&engineConfiguration->iat); engineConfiguration->iat.config.bias_resistor = 1500; // same as OEM ECU // set cranking_charge_angle 35 engineConfiguration->crankingChargeAngle = 70; // set cranking_timing_angle 0 engineConfiguration->crankingTimingAngle = -45; // set global_trigger_offset_angle 34 engineConfiguration->globalTriggerAngleOffset = 34; // set_rpm_hard_limit 4000 engineConfiguration->rpmHardLimit = 4000; // yes, 4k. let's play it safe for now // set_cranking_rpm 2000 engineConfiguration->cranking.rpm = 500; // set ignition_offset 350 // engineConfiguration->ignitionOffset = 350; // set injection_offset 510 // engineConfiguration->extraInjectionOffset = 510; /** * ADC inputs: * * Inp1/ADC12 PC2: CLT * Inp2/ADC11 PC1: AIT/IAT * Inp3/ADC0 PA0: MAP * Inp4/ADC13 PC3: AFR green wire * Inp6/ADC1 PA1: TPS * Inp12/ADC14 PC4: VBatt */ /** * wideband O2 Sensor */ engineConfiguration->afr.hwChannel = EFI_ADC_13; /** * VBatt */ engineConfiguration->vbattAdcChannel = EFI_ADC_14; engineConfiguration->vbattDividerCoeff = ((float) (10 + 39)) / 10 * 2; // todo engineConfiguration->afr.hwChannel = 14; /** * MAP D17/W5 blue wire */ engineConfiguration->map.sensor.hwChannel = EFI_ADC_0; /** * IAT D15/W7 green wire */ engineConfiguration->iat.adcChannel = EFI_ADC_11; /** * CLT D13/W9 yellow wire */ engineConfiguration->clt.adcChannel = EFI_ADC_12; /** * TPS D11/W11 blue wire */ engineConfiguration->tpsAdcChannel = EFI_ADC_1; /** * Outputs */ // Frankenso low out #1: PE6 // Frankenso low out #2: PE5 // Frankenso low out #3: PD7 // Frankenso low out #4: PC13 // Frankenso low out #5: PE3 Fuel Relay // Frankenso low out #6: PE4 radiator fan - blue wire // Frankenso low out #7: PD3 idle air valve solenoid - green wire // Frankenso low out #8: PE2 MIL - white wire // Frankenso low out #9: PB9 Injector #2 // Frankenso low out #10: PD5 Injector #3 // Frankenso low out #11: PB8 injector #1 // Frankenso low out #12: PB7 injector #4 boardConfiguration->fuelPumpPin = GPIOE_3; boardConfiguration->fuelPumpPinMode = OM_DEFAULT; boardConfiguration->malfunctionIndicatorPin = GPIOE_2; boardConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; boardConfiguration->fanPin = GPIOE_4; // blue wire boardConfiguration->idle.solenoidPin = GPIOD_3; // green wire boardConfiguration->injectionPins[0] = GPIOB_8; boardConfiguration->injectionPins[1] = GPIOB_9; boardConfiguration->injectionPins[2] = GPIOD_5; boardConfiguration->injectionPins[3] = GPIOB_7; boardConfiguration->ignitionPins[0] = GPIOE_12; // white wire boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; boardConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; setFrankenso_01_LCD(boardConfiguration); setFrankenso0_1_joystick(engineConfiguration); boardConfiguration->idle.solenoidFrequency = 500; }
/*** PUBLIC ***/ br::Algorithm::Algorithm(QWidget *parent) : QComboBox(parent) { setToolTip("Algorithm"); connect(this, SIGNAL(currentIndexChanged(QString)), this, SLOT(setAlgorithm(QString))); }
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; }
bool EFX::loadXML(const QDomElement* root) { QString str; QDomNode node; QDomElement tag; Q_ASSERT(root != NULL); if (root->tagName() != KXMLQLCFunction) { qWarning() << "Function node not found!"; return false; } /* Load EFX contents */ node = root->firstChild(); while (node.isNull() == false) { tag = node.toElement(); if (tag.tagName() == KXMLQLCBus) { /* Bus */ str = tag.attribute(KXMLQLCBusRole); setBus(tag.text().toInt()); } else if (tag.tagName() == KXMLQLCEFXFixture) { EFXFixture* ef = new EFXFixture(this); ef->loadXML(&tag); if (ef->fixture() != KNoID) { if (addFixture(ef) == false) delete ef; } } else if (tag.tagName() == KXMLQLCEFXPropagationMode) { /* Propagation mode */ setPropagationMode(stringToPropagationMode(tag.text())); } else if (tag.tagName() == KXMLQLCEFXAlgorithm) { /* Algorithm */ setAlgorithm(tag.text()); } else if (tag.tagName() == KXMLQLCFunctionDirection) { /* Direction */ setDirection(Function::stringToDirection(tag.text())); } else if (tag.tagName() == KXMLQLCFunctionRunOrder) { /* Run Order */ setRunOrder(Function::stringToRunOrder(tag.text())); } else if (tag.tagName() == KXMLQLCEFXWidth) { /* Width */ setWidth(tag.text().toInt()); } else if (tag.tagName() == KXMLQLCEFXHeight) { /* Height */ setHeight(tag.text().toInt()); } else if (tag.tagName() == KXMLQLCEFXRotation) { /* Rotation */ setRotation(tag.text().toInt()); } else if (tag.tagName() == KXMLQLCEFXStartScene) { /* Start scene */ setStartScene(tag.text().toInt()); if (tag.attribute(KXMLQLCFunctionEnabled) == KXMLQLCTrue) setStartSceneEnabled(true); else setStartSceneEnabled(false); } else if (tag.tagName() == KXMLQLCEFXStopScene) { /* Stop scene */ setStopScene(tag.text().toInt()); if (tag.attribute(KXMLQLCFunctionEnabled) == KXMLQLCTrue) setStopSceneEnabled(true); else setStopSceneEnabled(false); } else if (tag.tagName() == KXMLQLCEFXAxis) { /* Axes */ loadXMLAxis(&tag); } else { qWarning() << "Unknown EFX tag:" << tag.tagName(); } node = node.nextSibling(); } return true; }
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 setHonda600(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->trigger.type = TT_HONDA_CBR_600_CUSTOM; engineConfiguration->fuelAlgorithm = LM_ALPHA_N; // upside down wiring boardConfiguration->triggerInputPins[0] = GPIOA_5; boardConfiguration->triggerInputPins[1] = GPIOC_6; // set global_trigger_offset_angle 180 // set global_trigger_offset_angle 540 engineConfiguration->globalTriggerAngleOffset = 540; engineConfiguration->specs.cylindersCount = 4; engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS; engineConfiguration->injectionMode = IM_SEQUENTIAL; engineConfiguration->specs.firingOrder = FO_1_3_4_2; engineConfiguration->extraInjectionOffset = 320; engineConfiguration->cranking.rpm = 800; // engineConfiguration->ignitionMode = IM_WASTED_SPARK; //IM_INDIVIDUAL_COILS; engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS; //setIndividualCoilsIgnition(); setFrankenso_01_LCD(boardConfiguration); commonFrankensoAnalogInputs(engineConfiguration); setFrankenso0_1_joystick(engineConfiguration); setMap(config->injectionPhase, 320); /** * Frankenso analog #1 PC2 ADC12 CLT * Frankenso analog #2 PC1 ADC11 IAT * Frankenso analog #3 PA0 ADC0 MAP * Frankenso analog #4 PC3 ADC13 WBO / O2 * Frankenso analog #5 PA2 ADC2 TPS * Frankenso analog #6 PA1 ADC1 * Frankenso analog #7 PA4 ADC4 * Frankenso analog #8 PA3 ADC3 * Frankenso analog #9 PA7 ADC7 * Frankenso analog #10 PA6 ADC6 * Frankenso analog #11 PC5 ADC15 * Frankenso analog #12 PC4 ADC14 VBatt */ engineConfiguration->tps1_1AdcChannel = EFI_ADC_2; engineConfiguration->map.sensor.hwChannel = EFI_ADC_0; engineConfiguration->clt.adcChannel = EFI_ADC_12; engineConfiguration->iat.adcChannel = EFI_ADC_11; engineConfiguration->afr.hwChannel = EFI_ADC_13; setCommonNTCSensor(&engineConfiguration->clt); engineConfiguration->clt.config.bias_resistor = 2700; setCommonNTCSensor(&engineConfiguration->iat); engineConfiguration->iat.config.bias_resistor = 2700; /** * http://rusefi.com/wiki/index.php?title=Manual:Hardware_Frankenso_board */ // Frankenso low out #1: PE6 // Frankenso low out #2: PE5 // Frankenso low out #3: PD7 Main Relay // Frankenso low out #4: PC13 Idle valve solenoid // Frankenso low out #5: PE3 // Frankenso low out #6: PE4 fuel pump relay // Frankenso low out #7: PE1 (do not use with discovery!) // Frankenso low out #8: PE2 injector #2 // Frankenso low out #9: PB9 injector #1 // Frankenso low out #10: PE0 (do not use with discovery!) // Frankenso low out #11: PB8 injector #3 // Frankenso low out #12: PB7 injector #4 boardConfiguration->fuelPumpPin = GPIOE_4; boardConfiguration->mainRelayPin = GPIOD_7; boardConfiguration->idle.solenoidPin = GPIOC_13; boardConfiguration->fanPin = GPIOE_5; boardConfiguration->injectionPins[0] = GPIOB_9; // #1 boardConfiguration->injectionPins[1] = GPIOD_5; // #2 boardConfiguration->injectionPins[2] = GPIOB_7; // #3 boardConfiguration->injectionPins[3] = GPIOB_8; // #4 setDefaultCustomMaps(PASS_CONFIG_PARAMETER_SIGNATURE); setAlgorithm(LM_ALPHA_N PASS_CONFIG_PARAMETER_SUFFIX); boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED; boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED; boardConfiguration->injectionPins[6] = GPIO_UNASSIGNED; boardConfiguration->injectionPins[7] = GPIO_UNASSIGNED; boardConfiguration->injectionPins[8] = GPIO_UNASSIGNED; boardConfiguration->injectionPins[9] = GPIO_UNASSIGNED; boardConfiguration->injectionPins[10] = GPIO_UNASSIGNED; boardConfiguration->injectionPins[11] = GPIO_UNASSIGNED; boardConfiguration->ignitionPins[0] = GPIOE_14; boardConfiguration->ignitionPins[1] = GPIOC_7; boardConfiguration->ignitionPins[2] = GPIOE_10; boardConfiguration->ignitionPins[3] = GPIOC_9; // #4 // todo: 8.2 or 10k? engineConfiguration->vbattDividerCoeff = ((float) (10 + 33)) / 10 * 2; #if EFI_CAN_SUPPORT enableFrankensoCan(); #endif /* EFI_CAN_SUPPORT */ }
RGBMatrix::~RGBMatrix() { setAlgorithm(NULL); delete m_roundTime; m_roundTime = NULL; }
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; }