status_loop.cpp File Reference

Detailed Description

Human-readable protocol status messages.

http://rusefi.com/forum/viewtopic.php?t=263 rusEfi console overview http://rusefi.com/forum/viewtopic.php?t=210 Commands overview

Date

Mar 15, 2013

Author

Andrey Belomutskiy, (c) 2012-2020

This file is part of rusEfi - see http://rusefi.com

rusEfi is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

rusEfi is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file status_loop.cpp.

Functions
static void	printVersionForConsole (const char *engineTypeName, const char *firmwareBuildId)
static void	printOutPin (const char *pinName, brain_pin_e hwPin)
static void	printEngineSnifferPinMappings ()
void	printOverallStatus ()
void	updateDevConsoleState ()
	Sends all pending data to rusEfi console.
void	initWarningRunningPins ()
static void	initStatusLeds ()
static bool	isTriggerErrorNow ()
static int	packEngineMode ()
static void	updateTempSensors ()
void	updateUnfilteredRawPedal ()
static void	updateThrottles ()
static void	updateLambda ()
static void	updateFuelSensors ()
static void	updateEgtSensors ()
static void	updateVvtSensors ()
static void	updateVehicleSpeed ()
static void	updateRawSensors ()
static void	updatePressures ()
static void	updateMiscSensors ()
static void	updateSensors ()
static void	updateFuelCorrections ()
static void	updateFuelResults ()
static void	updateFuelInfo ()
static void	updateIgnition (float rpm)
static void	updateFlags ()
void	updateTunerStudioState ()
void	startStatusThreads ()

Variables
WaveChart	waveChart
int	maxTriggerReentrant
uint32_t	maxLockedDuration
static Timer	printVersionTimer
static char	logicAnalyzerBuffer [LOGIC_ANALYZER_BUFFER_SIZE]
static Logging	logicAnalyzerLogger ("logic analyzer", logicAnalyzerBuffer, sizeof(logicAnalyzerBuffer))
static OutputPin *	leds []
bool	consoleByteArrived
static CommunicationBlinkingTask	communicationsBlinkingTask
static SensorType	luaGaugeTypes []

Function Documentation

initStatusLeds()

static void initStatusLeds ( )

static

Definition at line 235 of file status_loop.cpp.

                             {
    enginePins.communicationLedPin.initPin("led: comm status", getCommsLedPin(), LED_PIN_MODE, true);
    // checkEnginePin is already initialized by the time we get here
}

Referenced by startStatusThreads().

Here is the call graph for this function:

Here is the caller graph for this function:

initWarningRunningPins()

void initWarningRunningPins

(

)

Definition at line 226 of file status_loop.cpp.

                              {
#if EFI_PROD_CODE
    // open question if we need warningLedPin and runningLedPin at all!
    enginePins.warningLedPin.initPin("led: warning status", getWarningLedPin(), LED_PIN_MODE, true);
    enginePins.runningLedPin.initPin("led: running status", getRunningLedPin(), LED_PIN_MODE, true);
#endif /* EFI_PROD_CODE */
}

Referenced by initRealHardwareEngineController().

Here is the call graph for this function:

Here is the caller graph for this function:

isTriggerErrorNow()

static bool isTriggerErrorNow ( )

static

Definition at line 240 of file status_loop.cpp.

                                {
#if EFI_ENGINE_CONTROL && EFI_SHAFT_POSITION_INPUT
    bool justHadError = engine->triggerCentral.triggerState.someSortOfTriggerError();
    return justHadError || engine->triggerCentral.isTriggerDecoderError();
#else
    return false;
#endif /* EFI_ENGINE_CONTROL && EFI_SHAFT_POSITION_INPUT */
}

Referenced by updateFlags().

Here is the call graph for this function:

Here is the caller graph for this function:

packEngineMode()

static int packEngineMode ( )

static

This is useful if we are changing engine mode dynamically For example http://rusefi.com/forum/viewtopic.php?f=5&t=1085

Definition at line 339 of file status_loop.cpp.

                            {
    return (Enum2Underlying(engineConfiguration->fuelAlgorithm) << 4) +
            (engineConfiguration->injectionMode << 2) +
            engineConfiguration->ignitionMode;
}

Referenced by updateTunerStudioState().

Here is the caller graph for this function:

printEngineSnifferPinMappings()

static void printEngineSnifferPinMappings ( )

static

Definition at line 126 of file status_loop.cpp.

                                            {
#if EFI_PROD_CODE
    printOutPin(PROTOCOL_CRANK1, engineConfiguration->triggerInputPins[0]);
    printOutPin(PROTOCOL_CRANK2, engineConfiguration->triggerInputPins[1]);
    for (int i = 0;i<CAM_INPUTS_COUNT;i++) {
        extern const char *vvtNames[];
        printOutPin(vvtNames[i], engineConfiguration->camInputs[i]);
    }
 
    int cylCount = minI(engineConfiguration->cylindersCount, MAX_CYLINDER_COUNT);
    for (int i = 0; i < cylCount; i++) {
        printOutPin(enginePins.coils[i].getShortName(), engineConfiguration->ignitionPins[i]);
        printOutPin(enginePins.trailingCoils[i].getShortName(), engineConfiguration->trailingCoilPins[i]);
        printOutPin(enginePins.injectors[i].getShortName(), engineConfiguration->injectionPins[i]);
        printOutPin(enginePins.injectorsStage2[i].getShortName(), engineConfiguration->injectionPinsStage2[i]);
    }
#endif /* EFI_PROD_CODE */
}

Referenced by printOverallStatus().

Here is the call graph for this function:

Here is the caller graph for this function:

printOutPin()

static void printOutPin ( const char *  pinName, brain_pin_e  hwPin  )

static

Definition at line 108 of file status_loop.cpp.

                                                                {
    if (hwPin == Gpio::Unassigned || hwPin == Gpio::Invalid) {
        return;
    }
    const char *hwPinName;
    if (isBrainPinValid(hwPin)) {
        hwPinName = hwPortname(hwPin);
    } else {
        hwPinName = "smart";
    }
 
    efiPrintfProto(PROTOCOL_OUTPIN, "%s@%s", pinName, hwPinName);
}

Referenced by printEngineSnifferPinMappings().

Here is the call graph for this function:

Here is the caller graph for this function:

printOverallStatus()

void printOverallStatus

(

)

we report the version every second - this way the console does not need to request it and we will display it pretty soon

Definition at line 145 of file status_loop.cpp.

                          {
#if EFI_ENGINE_SNIFFER
    waveChart.publishIfFull();
#endif /* EFI_ENGINE_SNIFFER */
 
 
    /**
     * we report the version every second - this way the console does not need to
     * request it and we will display it pretty soon
     */
    if (printVersionTimer.hasElapsedSec(1)) {
        // we're sending, reset the timer
        printVersionTimer.reset();
 
        // Output the firmware version, board type, git hash, uptime in seconds, etc for rusEFI console
        printVersionForConsole(getEngine_type_e(engineConfiguration->engineType), FIRMWARE_ID);
 
        // Output the current engine sniffer pin mappings
        printEngineSnifferPinMappings();
    }
}

Referenced by handleGetText().

Here is the call graph for this function:

Here is the caller graph for this function:

printVersionForConsole()

static void printVersionForConsole ( const char *  engineTypeName, const char *  firmwareBuildId  )

static

Definition at line 96 of file status_loop.cpp.

                                                                                            {
    // VersionChecker in rusEFI console is parsing these version string, please follow the expected format
    efiPrintfProto(PROTOCOL_VERSION_TAG, "%d@%u %s %s %ld",
            getRusEfiVersion(), /*do we have a working way to print 64 bit values?!*/(unsigned int)SIGNATURE_HASH,
            firmwareBuildId,
            engineTypeName,
            (uint32_t)getTimeNowS());
}

Referenced by printOverallStatus().

Here is the call graph for this function:

Here is the caller graph for this function:

startStatusThreads()

void startStatusThreads

(

)

Definition at line 768 of file status_loop.cpp.

                          {
    // todo: refactoring needed, this file should probably be split into pieces
#if EFI_PROD_CODE
    initStatusLeds();
    communicationsBlinkingTask.start();
#endif /* EFI_PROD_CODE */
}

Referenced by commonEarlyInit().

Here is the call graph for this function:

Here is the caller graph for this function:

updateDevConsoleState()

void updateDevConsoleState

(

)

Sends all pending data to rusEfi console.

This method is periodically invoked by the main loop todo: is this mostly dead code?

Definition at line 183 of file status_loop.cpp.

                             {
#if EFI_PROD_CODE
    // todo: unify with simulator!
    if (hasFirmwareError()) {
        efiPrintf("%s error: %s", CRITICAL_PREFIX, getCriticalErrorMessage());
        return;
    }
#endif /* EFI_PROD_CODE */
 
#if EFI_RTC
  engine->outputChannels.rtcUnixEpochTime = getEpochTime();
#endif
 
#if HAL_USE_ADC
    printFullAdcReportIfNeeded();
#endif /* HAL_USE_ADC */
 
#if EFI_ENGINE_CONTROL && EFI_SHAFT_POSITION_INPUT
    int currentCkpEventCounter = engine->triggerCentral.triggerState.getTotalEventCounter();
    systime_t nowSeconds = getTimeNowS();
static int prevCkpEventCounter = -1;
static systime_t timeOfPreviousReport = (systime_t) -1;
    if (prevCkpEventCounter == currentCkpEventCounter && timeOfPreviousReport == nowSeconds) {
        return;
    }
    timeOfPreviousReport = nowSeconds;
 
    prevCkpEventCounter = currentCkpEventCounter;
#else
    chThdSleepMilliseconds(200);
#endif
 
#if EFI_LOGIC_ANALYZER
    printWave(&logicAnalyzerLogger);
    scheduleLogging(&logicAnalyzerLogger);
#endif /* EFI_LOGIC_ANALYZER */
}

Referenced by runMainLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

updateEgtSensors()

static void updateEgtSensors ( )

static

Definition at line 432 of file status_loop.cpp.

                               {
    engine->outputChannels.egt[0] = Sensor::getOrZero(SensorType::EGT1);
    engine->outputChannels.egt[1] = Sensor::getOrZero(SensorType::EGT2);
    engine->outputChannels.egt[2] = Sensor::getOrZero(SensorType::EGT3);
    engine->outputChannels.egt[3] = Sensor::getOrZero(SensorType::EGT4);
    engine->outputChannels.egt[4] = Sensor::getOrZero(SensorType::EGT5);
    engine->outputChannels.egt[5] = Sensor::getOrZero(SensorType::EGT6);
    engine->outputChannels.egt[6] = Sensor::getOrZero(SensorType::EGT7);
    engine->outputChannels.egt[7] = Sensor::getOrZero(SensorType::EGT8);
}

Referenced by updateSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

updateFlags()

static void updateFlags ( )

static

Definition at line 606 of file status_loop.cpp.

                          {
    engine->outputChannels.isO2HeaterOn = enginePins.o2heater.getLogicValue();
    // todo: eliminate state copy logic by giving DfcoController it's owm xxx.txt and leveraging LiveData
    engine->outputChannels.dfcoActive = engine->module<DfcoController>()->cutFuel();
 
#if EFI_LAUNCH_CONTROL
    engine->outputChannels.launchTriggered = engine->launchController.isLaunchCondition;
#endif
 
#if EFI_PROD_CODE
    engine->outputChannels.isTriggerError = isTriggerErrorNow();
#endif // EFI_PROD_CODE
 
#if EFI_CONFIGURATION_STORAGE
    engine->outputChannels.needBurn = getNeedToWriteConfiguration();
#endif /* EFI_CONFIGURATION_STORAGE */
#if EFI_FILE_LOGGING
    updateSdCardLiveFlags();
#endif
}

Referenced by updateTunerStudioState().

Here is the call graph for this function:

Here is the caller graph for this function:

updateFuelCorrections()

static void updateFuelCorrections ( )

static

Definition at line 572 of file status_loop.cpp.

                                    {
    engine->outputChannels.Gego = 100.0f * engine->engineState.stftCorrection[0];
}

Referenced by updateFuelInfo().

Here is the caller graph for this function:

updateFuelInfo()

static void updateFuelInfo ( )

static

Definition at line 588 of file status_loop.cpp.

                             {
    updateFuelCorrections();
    updateFuelResults();
#if EFI_ENGINE_CONTROL
    const auto& wallFuel = engine->injectionEvents.elements[0].getWallFuel();
    engine->outputChannels.wallFuelAmount = wallFuel.getWallFuel() * 1000;          // Convert grams to mg
    engine->outputChannels.wallFuelCorrectionValue = wallFuel.wallFuelCorrection * 1000;    // Convert grams to mg
 
    engine->outputChannels.veValue = engine->engineState.currentVe;
#endif // EFI_ENGINE_CONTROL
}

Referenced by updateTunerStudioState().

Here is the call graph for this function:

Here is the caller graph for this function:

updateFuelResults()

static void updateFuelResults ( )

static

Definition at line 576 of file status_loop.cpp.

                                {
#if EFI_VEHICLE_SPEED && defined (MODULE_ODOMETER)
    engine->outputChannels.fuelFlowRate = engine->module<TripOdometer>()->getConsumptionGramPerSecond();
    engine->outputChannels.totalFuelConsumption = engine->module<TripOdometer>()->getConsumedGrams();
    engine->outputChannels.ignitionOnTime = engine->module<TripOdometer>()->getIgnitionOnTime();
    engine->outputChannels.engineRunTime = engine->module<TripOdometer>()->getEngineRunTime();
 
    // output channel in km
    engine->outputChannels.distanceTraveled = 0.001f * engine->module<TripOdometer>()->getDistanceMeters();
#endif // EFI_VEHICLE_SPEED MODULE_ODOMETER
}

Referenced by updateFuelInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

updateFuelSensors()

static void updateFuelSensors ( )

static

Definition at line 421 of file status_loop.cpp.

                                {
    // Low pressure is directly in kpa
    engine->outputChannels.lowFuelPressure = Sensor::getOrZero(SensorType::FuelPressureLow);
    // High pressure is in bar, aka 100 kpa
    engine->outputChannels.highFuelPressure = KPA2BAR(Sensor::getOrZero(SensorType::FuelPressureHigh));
 
    engine->outputChannels.flexPercent = Sensor::getOrZero(SensorType::FuelEthanolPercent);
 
    engine->outputChannels.fuelTankLevel = Sensor::getOrZero(SensorType::FuelLevel);
}

Referenced by updateSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

updateIgnition()

static void updateIgnition ( float  rpm )

static

Definition at line 600 of file status_loop.cpp.

                                      {
#if EFI_ENGINE_CONTROL
    engine->outputChannels.coilDutyCycle = getCoilDutyCycle(rpm);
#endif // EFI_ENGINE_CONTROL
}

Referenced by updateTunerStudioState().

Here is the call graph for this function:

Here is the caller graph for this function:

updateLambda()

static void updateLambda ( )

static

Definition at line 405 of file status_loop.cpp.

                           {
    float lambdaValue = Sensor::getOrZero(SensorType::Lambda1);
    engine->outputChannels.lambdaValue = lambdaValue;
    engine->outputChannels.AFRValue = lambdaValue * engine->fuelComputer.stoichiometricRatio;
    // TODO: this can be calculated on PC side!
    engine->outputChannels.afrGasolineScale = lambdaValue * STOICH_RATIO;
    engine->outputChannels.SmoothedAFRValue = Sensor::getOrZero(SensorType::SmoothedLambda1);
 
    float lambda2Value = Sensor::getOrZero(SensorType::Lambda2);
    engine->outputChannels.lambdaValue2 = lambda2Value;
    engine->outputChannels.AFRValue2 = lambda2Value * engine->fuelComputer.stoichiometricRatio;
    // TODO: this can be calculated on PC side!
    engine->outputChannels.afr2GasolineScale = lambda2Value * STOICH_RATIO;
    engine->outputChannels.SmoothedAFRValue2 = Sensor::getOrZero(SensorType::SmoothedLambda2);
}

Referenced by updateSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

updateMiscSensors()

static void updateMiscSensors ( )

static

Definition at line 542 of file status_loop.cpp.

                                {
    engine->outputChannels.VBatt = Sensor::getOrZero(SensorType::BatteryVoltage);
 
    engine->outputChannels.idlePositionSensor = Sensor::getOrZero(SensorType::IdlePosition);
 
    engine->outputChannels.wastegatePositionSensor = Sensor::getOrZero(SensorType::WastegatePosition);
 
    engine->outputChannels.ISSValue = Sensor::getOrZero(SensorType::InputShaftSpeed);
    engine->outputChannels.auxSpeed1 = Sensor::getOrZero(SensorType::AuxSpeed1);
    engine->outputChannels.auxSpeed2 = Sensor::getOrZero(SensorType::AuxSpeed2);
 
#if HAL_USE_ADC
    engine->outputChannels.internalMcuTemperature = getMCUInternalTemperature();
    engine->outputChannels.internalVref = getMCUVref();
#endif /* HAL_USE_ADC */
}

Referenced by updateSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

updatePressures()

static void updatePressures ( )

static

Definition at line 522 of file status_loop.cpp.

                              {
    engine->outputChannels.baroPressure = Sensor::getOrZero(SensorType::BarometricPressure);
  // instantMAPValue is injected in a very different way
  float mapValue = Sensor::getOrZero(SensorType::Map);
    engine->outputChannels.MAPValue = mapValue;
 
    engine->outputChannels.mapFast = Sensor::getOrZero(SensorType::MapFast);
    engine->outputChannels.oilPressure = Sensor::getOrZero(SensorType::OilPressure);
  engine->outputChannels.acPressure = Sensor::getOrZero(SensorType::AcPressure);
 
    engine->outputChannels.compressorDischargePressure = Sensor::getOrZero(SensorType::CompressorDischargePressure);
    engine->outputChannels.throttleInletPressure = Sensor::getOrZero(SensorType::ThrottleInletPressure);
    engine->outputChannels.throttlePressureRatio = getThrottlePressureRatio(mapValue);
 
    engine->outputChannels.auxLinear1 = Sensor::getOrZero(SensorType::AuxLinear1);
    engine->outputChannels.auxLinear2 = Sensor::getOrZero(SensorType::AuxLinear2);
    engine->outputChannels.auxLinear3 = Sensor::getOrZero(SensorType::AuxLinear3);
    engine->outputChannels.auxLinear4 = Sensor::getOrZero(SensorType::AuxLinear4);
}

Referenced by updateSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

updateRawSensors()

static void updateRawSensors ( )

static

Definition at line 475 of file status_loop.cpp.

                               {
    engine->outputChannels.rawTps1Primary = Sensor::getRaw(SensorType::Tps1Primary);
    engine->outputChannels.rawTps1Secondary = Sensor::getRaw(SensorType::Tps1Secondary);
    engine->outputChannels.rawTps2Primary = Sensor::getRaw(SensorType::Tps2Primary);
    engine->outputChannels.rawTps2Secondary = Sensor::getRaw(SensorType::Tps2Secondary);
    engine->outputChannels.rawPpsPrimary = Sensor::getRaw(SensorType::AcceleratorPedalPrimary);
    engine->outputChannels.rawPpsSecondary = Sensor::getRaw(SensorType::AcceleratorPedalSecondary);
    engine->outputChannels.rawBattery = Sensor::getRaw(SensorType::BatteryVoltage);
    engine->outputChannels.rawClt = Sensor::getRaw(SensorType::Clt);
    engine->outputChannels.rawIat = Sensor::getRaw(SensorType::Iat);
    engine->outputChannels.rawAuxTemp1 = Sensor::getRaw(SensorType::AuxTemp1);
    engine->outputChannels.rawAuxTemp2 = Sensor::getRaw(SensorType::AuxTemp2);
    engine->outputChannels.rawAmbientTemp = Sensor::getRaw(SensorType::AmbientTemperature);
    engine->outputChannels.rawOilPressure = Sensor::getRaw(SensorType::OilPressure);
    engine->outputChannels.rawFuelLevel = Sensor::getRaw(SensorType::FuelLevel);
  engine->outputChannels.rawAcPressure = Sensor::getRaw(SensorType::AcPressure);
    engine->outputChannels.rawLowFuelPressure = Sensor::getRaw(SensorType::FuelPressureLow);
    engine->outputChannels.rawHighFuelPressure = Sensor::getRaw(SensorType::FuelPressureHigh);
    engine->outputChannels.rawMaf = Sensor::getRaw(SensorType::Maf);
    engine->outputChannels.rawMaf2 = Sensor::getRaw(SensorType::Maf2);
    engine->outputChannels.rawMap = Sensor::getRaw(SensorType::MapSlow);
    engine->outputChannels.rawWastegatePosition = Sensor::getRaw(SensorType::WastegatePosition);
    engine->outputChannels.rawIdlePositionSensor = Sensor::getRaw(SensorType::IdlePosition);
    engine->outputChannels.rawAuxAnalog1 = Sensor::getRaw(SensorType::AuxAnalog1);
    engine->outputChannels.rawAuxAnalog2 = Sensor::getRaw(SensorType::AuxAnalog2);
    engine->outputChannels.rawAuxAnalog3 = Sensor::getRaw(SensorType::AuxAnalog3);
    engine->outputChannels.rawAuxAnalog4 = Sensor::getRaw(SensorType::AuxAnalog4);
 
#if EFI_PROD_CODE
extern int flexCallbackCounter;
    engine->outputChannels.rawFlexFreq = flexCallbackCounter;
#endif // EFI_PROD_CODE
 
  for (size_t i = 0;i<LUA_GAUGE_COUNT;i++) {
      engine->outputChannels.luaGauges[i] = Sensor::getOrZero(luaGaugeTypes[i]);
  }
 
    for (int i = 0; i < LUA_ANALOG_INPUT_COUNT; i++) {
        adc_channel_e channel = engineConfiguration->auxAnalogInputs[i];
        if (isAdcChannelValid(channel)) {
            engine->outputChannels.rawAnalogInput[i] = adcGetScaledVoltage("raw aux", channel).value_or(0);
        }
    }
 
    // TODO: transition AFR to new sensor model
    engine->outputChannels.rawAfr = (engineConfiguration->afr.hwChannel == EFI_ADC_NONE) ? 0 : adcGetScaledVoltage("ego", engineConfiguration->afr.hwChannel).value_or(0);
}

Referenced by updateSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

updateSensors()

static void updateSensors ( )

static

Definition at line 559 of file status_loop.cpp.

                            {
    updateTempSensors();
    updateThrottles();
    updateRawSensors();
    updateLambda();
    updateFuelSensors();
    updateEgtSensors();
    updateVvtSensors();
    updateVehicleSpeed();
    updatePressures();
    updateMiscSensors();
}

Referenced by updateTunerStudioState().

Here is the call graph for this function:

Here is the caller graph for this function:

updateTempSensors()

static void updateTempSensors ( )

static

Definition at line 345 of file status_loop.cpp.

                                {
    SensorResult clt = Sensor::get(SensorType::Clt);
    engine->outputChannels.coolant = clt.value_or(0);
    engine->outputChannels.isCltError = !clt.Valid;
 
    SensorResult iat = Sensor::get(SensorType::Iat);
    engine->outputChannels.intake = iat.value_or(0);
    engine->outputChannels.isIatError = !iat.Valid;
 
    SensorResult auxTemp1 = Sensor::get(SensorType::AuxTemp1);
    engine->outputChannels.auxTemp1 = auxTemp1.value_or(0);
 
    SensorResult auxTemp2 = Sensor::get(SensorType::AuxTemp2);
    engine->outputChannels.auxTemp2 = auxTemp2.value_or(0);
 
    SensorResult oilTemp = Sensor::get(SensorType::OilTemperature);
    engine->outputChannels.oilTemp = oilTemp.value_or(0);
 
    // see also updateFuelSensors()
    SensorResult fuelTemp = Sensor::get(SensorType::FuelTemperature);
    engine->outputChannels.fuelTemp = fuelTemp.value_or(0);
 
    SensorResult ambientTemp = Sensor::get(SensorType::AmbientTemperature);
    engine->outputChannels.ambientTemp = ambientTemp.value_or(0);
 
    SensorResult compressorDischargeTemp = Sensor::get(SensorType::CompressorDischargeTemperature);
    engine->outputChannels.compressorDischargeTemp = compressorDischargeTemp.value_or(0);
}

Referenced by updateSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

updateThrottles()

static void updateThrottles ( )

static

Definition at line 376 of file status_loop.cpp.

                              {
    SensorResult tps1 = Sensor::get(SensorType::Tps1);
    engine->outputChannels.TPSValue = tps1.value_or(0);
    engine->outputChannels.isTpsError = Sensor::hasSensor(SensorType::Tps1) ? !tps1.Valid : false;
    engine->outputChannels.tpsADC = convertVoltageTo10bitADC(Sensor::getRaw(SensorType::Tps1Primary));
 
    SensorResult tps2 = Sensor::get(SensorType::Tps2);
    engine->outputChannels.TPS2Value = tps2.value_or(0);
    // If we don't have a TPS2 at all, don't turn on the failure light
    engine->outputChannels.isTps2Error = Sensor::hasSensor(SensorType::Tps2Primary) ? !tps2.Valid : false;
 
    SensorResult pedal = Sensor::get(SensorType::AcceleratorPedal);
    engine->outputChannels.throttlePedalPosition = pedal.value_or(0);
    // Only report fail if you have one (many people don't)
    engine->outputChannels.isPedalError = Sensor::hasSensor(SensorType::AcceleratorPedal) ? !pedal.Valid : false;
 
    // TPS 1 pri/sec split
    engine->outputChannels.tps1Split = Sensor::getOrZero(SensorType::Tps1Primary) - Sensor::getOrZero(SensorType::Tps1Secondary);
    // TPS 2 pri/sec split
    engine->outputChannels.tps2Split = Sensor::getOrZero(SensorType::Tps2Primary) - Sensor::getOrZero(SensorType::Tps2Secondary);
    // TPS1 - TPS2 split
    engine->outputChannels.tps12Split = Sensor::getOrZero(SensorType::Tps1) - Sensor::getOrZero(SensorType::Tps2);
    // Pedal pri/sec split
    engine->outputChannels.accPedalSplit = Sensor::getOrZero(SensorType::AcceleratorPedalPrimary) - Sensor::getOrZero(SensorType::AcceleratorPedalSecondary);
 
    engine->outputChannels.accPedalUnfiltered = Sensor::getOrZero(SensorType::AcceleratorPedalUnfiltered);
    updateUnfilteredRawPedal();
}

Referenced by updateSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

updateTunerStudioState()

void updateTunerStudioState

(

)

Definition at line 631 of file status_loop.cpp.

                              {
    TunerStudioOutputChannels *tsOutputChannels = &engine->outputChannels;
#if EFI_USB_SERIAL
  // pretty much SD card logs know if specifically USB serial is active
    engine->outputChannels.isUsbConnected = is_usb_serial_ready();
#endif // EFI_USB_SERIAL
 
    float rpm = Sensor::get(SensorType::Rpm).value_or(0);
 
 
  static Timer blinkIndicatorsTimer;
  constexpr float blinkHalfPeriod = 0.3;
  bool isBlinkPhase = blinkIndicatorsTimer.hasElapsedSec(blinkHalfPeriod);
#if EFI_ELECTRONIC_THROTTLE_BODY
  blinkEtbErrorCodes(isBlinkPhase);
#endif // EFI_ELECTRONIC_THROTTLE_BODY
  if (isBlinkPhase) {
    engine->outputChannels.sparkCutReasonBlinker = 0;
    engine->outputChannels.fuelCutReasonBlinker = 0;
 
    if (blinkIndicatorsTimer.hasElapsedSec(2 * blinkHalfPeriod)) {
      blinkIndicatorsTimer.reset();
    }
  } else {
    engine->outputChannels.sparkCutReasonBlinker = engine->outputChannels.sparkCutReason;
    engine->outputChannels.fuelCutReasonBlinker = engine->outputChannels.fuelCutReason;
  }
 
 
#if EFI_PROD_CODE
    executorStatistics();
#endif /* EFI_PROD_CODE */
 
    DcHardware *dc = getPrimaryDCHardwareForLogging();
    engine->dc_motors.dcOutput0 = dc->dcMotor.get();
    engine->dc_motors.isEnabled0_int = dc->msg() == nullptr;
 
    tsOutputChannels->RPMValue = rpm;
#if EFI_SHAFT_POSITION_INPUT
    tsOutputChannels->instantRpm = engine->triggerCentral.instantRpm.getInstantRpm();
    tsOutputChannels->totalTriggerErrorCounter = engine->triggerCentral.triggerState.totalTriggerErrorCounter;
    tsOutputChannels->rpmAcceleration = engine->rpmCalculator.getRpmAcceleration();
 
    tsOutputChannels->orderingErrorCounter = engine->triggerCentral.triggerState.orderingErrorCounter;
#endif // EFI_SHAFT_POSITION_INPUT
 
    updateSensors();
    updateFuelInfo();
    updateIgnition(rpm);
    updateFlags();
    // update calibration channel, reset to None state after timeout
    tsCalibrationIsIdle();
 
    // Output both the estimated air flow, and measured air flow (if available)
    tsOutputChannels->mafMeasured = Sensor::getOrZero(SensorType::Maf);
    tsOutputChannels->mafMeasured2 = Sensor::getOrZero(SensorType::Maf2);
    tsOutputChannels->mafEstimate = engine->engineState.airflowEstimate;
 
#if EFI_ENGINE_CONTROL
    tsOutputChannels->injectorDutyCycle = minF(/*let's avoid scaled "uint8_t, 2" overflow*/127, getInjectorDutyCycle(rpm));
    tsOutputChannels->injectorDutyCycleStage2 = getInjectorDutyCycleStage2(rpm);
#endif
 
    tsOutputChannels->seconds = getTimeNowS();
 
    tsOutputChannels->engineMode = packEngineMode();
    tsOutputChannels->firmwareVersion = getRusEfiVersion();
 
    tsOutputChannels->accelerationLat = engine->sensors.accelerometer.lat;
    tsOutputChannels->accelerationLon = engine->sensors.accelerometer.lon;
    tsOutputChannels->accelerationVert = engine->sensors.accelerometer.vert;
    tsOutputChannels->gyroYaw = engine->sensors.accelerometer.yawRate;
 
#if EFI_DYNO_VIEW
    tsOutputChannels->hp = getDynoviewHP();
  tsOutputChannels->torque = getDynoviewTorque();
#else
    tsOutputChannels->hp = -1;
  tsOutputChannels->torque = -1;
#endif
 
    tsOutputChannels->turboSpeed = Sensor::getOrZero(SensorType::TurbochargerSpeed);
    extern FrequencySensor inputShaftSpeedSensor;
    tsOutputChannels->issEdgeCounter = inputShaftSpeedSensor.eventCounter;
    extern FrequencySensor vehicleSpeedSensor;
    tsOutputChannels->vssEdgeCounter = vehicleSpeedSensor.eventCounter;
 
    tsOutputChannels->hasCriticalError = hasFirmwareError() || hasConfigError() || engine->engineState.warnings.hasWarningMessage();
    tsOutputChannels->hasFaultReportFile = hasErrorReportFile();
    tsOutputChannels->triggerPageRefreshFlag = needToTriggerTsRefresh() || ltftNeedVeRefresh();
 
    tsOutputChannels->isWarnNow = engine->engineState.warnings.isWarningNow();
 
    tsOutputChannels->tpsAccelFuel = engine->engineState.tpsAccelEnrich;
 
    tsOutputChannels->checkEngine = hasErrorCodes();
 
    engine->engineState.warnings.refreshTs();
 
    tsOutputChannels->starterState = enginePins.starterControl.getLogicValue();
    tsOutputChannels->starterRelayDisable = enginePins.starterRelayDisable.getLogicValue();
 
 
    tsOutputChannels->revolutionCounterSinceStart = engine->rpmCalculator.getRevolutionCounterSinceStart();
 
#if EFI_CLOCK_LOCKS
    tsOutputChannels->maxLockedDuration = NT2US(maxLockedDuration);
#endif /* EFI_CLOCK_LOCKS */
 
#if EFI_SHAFT_POSITION_INPUT
    tsOutputChannels->maxTriggerReentrant = maxTriggerReentrant;
    tsOutputChannels->triggerPrimaryFall = engine->triggerCentral.getHwEventCounter((int)SHAFT_PRIMARY_FALLING);
    tsOutputChannels->triggerPrimaryRise = engine->triggerCentral.getHwEventCounter((int)SHAFT_PRIMARY_RISING);
 
    tsOutputChannels->triggerSecondaryFall = engine->triggerCentral.getHwEventCounter((int)SHAFT_SECONDARY_FALLING);
    tsOutputChannels->triggerSecondaryRise = engine->triggerCentral.getHwEventCounter((int)SHAFT_SECONDARY_RISING);
 
#endif // EFI_SHAFT_POSITION_INPUT
 
#if HAL_USE_PAL && EFI_PROD_CODE
    tsOutputChannels->extiOverflowCount = getExtiOverflowCounter();
#endif
 
    switch (engineConfiguration->debugMode) {
    case DBG_LOGIC_ANALYZER:
#if EFI_LOGIC_ANALYZER
    // used by HW CI
        reportLogicAnalyzerToTS();
#endif /* EFI_LOGIC_ANALYZER */
        break;
    default:
        ;
    }
}

Referenced by TunerStudio::cmdOutputChannels(), configureRusefiLuaHooks(), and MLG::writeSdLogLine().

Here is the call graph for this function:

Here is the caller graph for this function:

updateUnfilteredRawPedal()

void updateUnfilteredRawPedal

(

)

Definition at line 194 of file init_tps.cpp.

                                {
  pedal.updateUnfilteredRawValues();
}

Referenced by updateThrottles().

Here is the call graph for this function:

Here is the caller graph for this function:

updateVehicleSpeed()

static void updateVehicleSpeed ( )

static

Definition at line 453 of file status_loop.cpp.

                                 {
#if EFI_VEHICLE_SPEED
    engine->outputChannels.vehicleSpeedKph = Sensor::getOrZero(SensorType::VehicleSpeed);
    engine->outputChannels.wheelSlipRatio = Sensor::getOrZero(SensorType::WheelSlipRatio);
#ifdef MODULE_GEAR_DETECTOR
    engine->outputChannels.speedToRpmRatio = engine->module<GearDetector>()->getGearboxRatio();
    engine->outputChannels.detectedGear = Sensor::getOrZero(SensorType::DetectedGear);
#endif
#endif /* EFI_VEHICLE_SPEED */
}

Referenced by updateSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

updateVvtSensors()

static void updateVvtSensors ( )

static

Definition at line 443 of file status_loop.cpp.

                               {
#if EFI_SHAFT_POSITION_INPUT
    // 248
    engine->outputChannels.vvtPositionB1I = engine->triggerCentral.getVVTPosition(/*bankIndex*/0, /*camIndex*/0);
    engine->outputChannels.vvtPositionB1E = engine->triggerCentral.getVVTPosition(/*bankIndex*/0, /*camIndex*/1);
    engine->outputChannels.vvtPositionB2I = engine->triggerCentral.getVVTPosition(/*bankIndex*/1, /*camIndex*/0);
    engine->outputChannels.vvtPositionB2E = engine->triggerCentral.getVVTPosition(/*bankIndex*/1, /*camIndex*/1);
#endif
}

Referenced by updateSensors().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

communicationsBlinkingTask

CommunicationBlinkingTask communicationsBlinkingTask

static

Definition at line 328 of file status_loop.cpp.

Referenced by startStatusThreads().

consoleByteArrived

bool consoleByteArrived

extern

Definition at line 47 of file console_io.cpp.

Referenced by onDataArrived().

leds

OutputPin* leds[]

static

Initial value:

= { &enginePins.warningLedPin, &enginePins.runningLedPin,
        &enginePins.errorLedPin, &enginePins.communicationLedPin, &enginePins.checkEnginePin }

Definition at line 222 of file status_loop.cpp.

                           { &enginePins.warningLedPin, &enginePins.runningLedPin,
        &enginePins.errorLedPin, &enginePins.communicationLedPin, &enginePins.checkEnginePin };

logicAnalyzerBuffer

char logicAnalyzerBuffer[LOGIC_ANALYZER_BUFFER_SIZE]

static

Definition at line 173 of file status_loop.cpp.

logicAnalyzerLogger

Logging logicAnalyzerLogger("logic analyzer", logicAnalyzerBuffer, sizeof(logicAnalyzerBuffer)) ( "logic analyzer"  , logicAnalyzerBuffer  , sizeof(logicAnalyzerBuffer)    )

static

Referenced by updateDevConsoleState().

luaGaugeTypes

SensorType luaGaugeTypes[]

static

Initial value:

= {
  SensorType::LuaGauge1,
  SensorType::LuaGauge2,
  SensorType::LuaGauge3,
  SensorType::LuaGauge4,
  SensorType::LuaGauge5,
  SensorType::LuaGauge6,
  SensorType::LuaGauge7,
  SensorType::LuaGauge8
  }

Definition at line 464 of file status_loop.cpp.

                                    {
  SensorType::LuaGauge1,
  SensorType::LuaGauge2,
  SensorType::LuaGauge3,
  SensorType::LuaGauge4,
  SensorType::LuaGauge5,
  SensorType::LuaGauge6,
  SensorType::LuaGauge7,
  SensorType::LuaGauge8
  };

Referenced by updateRawSensors().

maxLockedDuration

uint32_t maxLockedDuration

extern

Maximum time before requesting lock and releasing lock at the end of critical section

Definition at line 549 of file error_handling.cpp.

Referenced by updateTunerStudioState().

maxTriggerReentrant

int maxTriggerReentrant

extern

Definition at line 460 of file trigger_central.cpp.

Referenced by updateTunerStudioState().

printVersionTimer

Timer printVersionTimer

static

Time when the firmware version was last reported TODO: implement a request/response instead of just constantly sending this out

Definition at line 93 of file status_loop.cpp.

Referenced by printOverallStatus().

waveChart

WaveChart waveChart

extern

Definition at line 68 of file engine_sniffer.cpp.

Referenced by printOverallStatus(), and Engine::resetEngineSnifferIfInTestMode().

Go to the source code of this file.