lua_hooks.cpp File Reference

Namespaces
namespace	LUAAA_NS

Functions
static int	lua_vin (lua_State *l)
static int	lua_readpin (lua_State *l)
static int	getSensor (lua_State *l, SensorType type)
static int	lua_getAuxAnalog (lua_State *l)
static int	lua_getSensorByIndex (lua_State *l)
static SensorType	findSensorByName (lua_State *l, const char *name)
static int	lua_getSensorByName (lua_State *l)
static int	lua_getSensorRaw (lua_State *l)
static int	lua_hasSensor (lua_State *l)
uint32_t	getLuaArray (lua_State *l, int paramIndex, uint8_t *data, uint32_t size)
static int	validateCanChannelAndConvertFromHumanIntoZeroIndex (lua_State *l)
static int	lua_txCan (lua_State *l)
AirmassModelBase &	getLuaAirmassModel ()
static P	luaL_checkPwmIndex (lua_State *l, int pos)
void	startPwm (int index, float freq, float duty)
static int	lua_startPwm (lua_State *l)
void	luaDeInitPins ()
void	setPwmDuty (int index, float duty)
static int	lua_setPwmDuty (lua_State *l)
static int	lua_setPwmFreq (lua_State *l)
static int	lua_getDigital (lua_State *l)
bool	getAuxDigital (int index)
static int	lua_getAuxDigital (lua_State *l)
static int	lua_setDebug (lua_State *l)
static auto	lua_getAirmassResolveMode (lua_State *l)
static int	lua_getAirmass (lua_State *l)
static int	lua_setAirmass (lua_State *l)
static bool	isFunction (lua_State *l, int idx)
int	getLuaFunc (lua_State *l)
int	lua_canRxAdd (lua_State *l)
int	lua_canRxAddMask (lua_State *l)
PUBLIC_API_WEAK void	boardConfigureLuaHooks (lua_State *lState)
void	configureRusefiLuaHooks (lua_State *lState)

Variables
static LuaAirmass	luaAirmass
static SimplePwm	pwms [LUA_PWM_COUNT]
static tinymt32_t	tinymt

Function Documentation

boardConfigureLuaHooks()

PUBLIC_API_WEAK void boardConfigureLuaHooks

(

lua_State *

lState

)

Definition at line 636 of file lua_hooks.cpp.

                                                               {
    UNUSED(lState);
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

configureRusefiLuaHooks()

void configureRusefiLuaHooks

(

lua_State *

lState

)

same exact could be accomplished via LuaSensor just with more API

Definition at line 642 of file lua_hooks.cpp.

                                                {
  boardConfigureLuaHooks(lState);
 
  tinymt32_init(&tinymt, 1534525); // todo: share instance with launch_control? probably not?
    lua_register(lState, "random", [](lua_State* l) {
      auto random = tinymt32_generate_float(&tinymt);
        lua_pushnumber(l, random);
        return 1;
    });
 
    LuaClass<Timer> luaTimer(lState, "Timer");
    luaTimer
        .ctor()
        .fun("reset",             static_cast<void (Timer::*)()     >(&Timer::reset            ))
        .fun("getElapsedSeconds", static_cast<float(Timer::*)()const>(&Timer::getElapsedSeconds));
 
    LuaClass<LuaSensor> luaSensor(lState, "Sensor");
    luaSensor
        .ctor<lua_State*, const char*>()
        .fun("set", &LuaSensor::set)
        .fun("setRedundant", &LuaSensor::setRedundant)
        .fun("setTimeout", &LuaSensor::setTimeout)
        .fun("invalidate", &LuaSensor::invalidate);
 
#ifndef WITH_LUA_PID
#define WITH_LUA_PID TRUE
#endif
 
#if WITH_LUA_PID
  LuaClass<LuaBiQuad> biQuard(lState, "Biquad");
  biQuard
    .ctor()
        .fun("filter", &LuaBiQuad::filter)
        .fun("configureLowpass", &LuaBiQuad::configureLowpass);
 
    LuaClass<LuaPid> luaPid(lState, "Pid");
    luaPid
        .ctor<float, float, float, float, float>()
        .fun("get", &LuaPid::get)
        .fun("setOffset", &LuaPid::setOffset)
        .fun("reset", &LuaPid::reset);
 
    LuaClass<LuaIndustrialPid> luaIndustrialPid(lState, "IndustrialPid");
    luaIndustrialPid
        .ctor<float, float, float, float, float>()
        .fun("get", &LuaIndustrialPid::get)
        .fun("setOffset", &LuaIndustrialPid::setOffset)
        .fun("setDerivativeFilterLoss", &LuaIndustrialPid::setDerivativeFilterLoss)
        .fun("setAntiwindupFreq", &LuaIndustrialPid::setAntiwindupFreq)
        .fun("reset", &LuaIndustrialPid::reset);
#endif
 
    configureRusefiLuaUtilHooks(lState);
 
    lua_register(lState, "readPin", lua_readpin);
#if EFI_PROD_CODE && EFI_SHAFT_POSITION_INPUT
    lua_register(lState, "startCrankingEngine", [](lua_State* l) {
        doStartCranking();
        return 0;
    });
#endif // EFI_PROD_CODE && EFI_SHAFT_POSITION_INPUT
    lua_register(lState, "vin", lua_vin);
 
    lua_register(lState, "getAuxAnalog", lua_getAuxAnalog);
    lua_register(lState, "getSensorByIndex", lua_getSensorByIndex);
    lua_register(lState, "getSensor", lua_getSensorByName);
    lua_register(lState, "getSensorRaw", lua_getSensorRaw);
    lua_register(lState, "hasSensor", lua_hasSensor);
 
#ifndef WITH_LUA_CONSUMPTION
#define WITH_LUA_CONSUMPTION TRUE
#endif
 
#if EFI_VEHICLE_SPEED && WITH_LUA_CONSUMPTION && defined (MODULE_ODOMETER)
    lua_register(lState, "getConsumedGrams", [](lua_State* l) {
        lua_pushnumber(l, engine->module<TripOdometer>()->getConsumedGrams());
        return 1;
    });
    lua_register(lState, "getConsumedGramsRemainder", [](lua_State* l) {
        lua_pushnumber(l, engine->module<TripOdometer>()->getConsumedGramsRemainder());
        return 1;
    });
    lua_register(lState, "getConsumptionGramPerSecond", [](lua_State* l) {
        lua_pushnumber(l, engine->module<TripOdometer>()->getConsumptionGramPerSecond());
        return 1;
    });
    lua_register(lState, "resetOdometer", [](lua_State*) {
        engine->module<TripOdometer>()->reset();
        return 0;
    });
#endif // EFI_VEHICLE_SPEED WITH_LUA_CONSUMPTION MODULE_ODOMETER
    lua_register(lState, "table3d", [](lua_State* l) {
        auto humanTableIdx = luaL_checkinteger(l, 1);
        auto x = luaL_checknumber(l, 2);
        auto y = luaL_checknumber(l, 3);
 
        // index table, compute table lookup
        auto result = getscriptTable(humanTableIdx - HUMAN_OFFSET)->getValue(x, y);
 
        lua_pushnumber(l, result);
        return 1;
    });
    // time since console or TunerStudio
    lua_register(lState, "secondsSinceTsActivity", [](lua_State* l) {
        lua_pushinteger(l, getSecondsSinceChannelsRequest());
        return 1;
    });
 
    lua_register(lState, "curve", [](lua_State* l) {
        // index starting from 1
        auto humanCurveIdx = luaL_checkinteger(l, 1);
        auto x = luaL_checknumber(l, 2);
 
        auto result = getCurveValue(humanCurveIdx - HUMAN_OFFSET, x);
 
        lua_pushnumber(l, result);
        return 1;
    });
 
#if EFI_PROD_CODE || EFI_SIMULATOR
extern int luaCommandCounters[LUA_BUTTON_COUNT];
 
    lua_register(lState, "getTsButtonCount",
            [](lua_State* l) {
            auto humanIndex = luaL_checkinteger(l, 1);
            if (humanIndex < 1 || humanIndex > LUA_BUTTON_COUNT) {
              luaL_error(l, "Invalid button index: %d", humanIndex);
              return 0;
            }
            lua_pushinteger(l, luaCommandCounters[humanIndex - 1]);
            return 1;
    });
#endif // EFI_PROD_CODE || EFI_SIMULATOR
 
#if EFI_PROD_CODE && EFI_SENT_SUPPORT
    lua_register(lState, "getSentValue",
            [](lua_State* l) {
            auto humanIndex = luaL_checkinteger(l, 1);
            auto value = getSentValue(static_cast<SentInput>(humanIndex));
            lua_pushnumber(l, value);
            return 1;
    });
 
    lua_register(lState, "getSentValues",
            [](lua_State* l) {
            uint16_t sig0;
            uint16_t sig1;
            auto humanIndex = luaL_checkinteger(l, 1);
            /*auto ret = */getSentValues(static_cast<SentInput>(humanIndex), &sig0, &sig1);
            lua_pushinteger(l, sig0);
            lua_pushinteger(l, sig1);
            return 2;
    });
#endif // EFI_SENT_SUPPORT
 
#if EFI_LAUNCH_CONTROL
    lua_register(lState, "setSparkSkipRatio", [](lua_State* l) {
        auto targetSkipRatio = luaL_checknumber(l, 1);
        engine->engineState.luaSoftSparkSkip = targetSkipRatio;
        engine->engineState.updateSparkSkip();
        return 0;
    });
    lua_register(lState, "setSparkHardSkipRatio", [](lua_State* l) {
        auto targetSkipRatio = luaL_checknumber(l, 1);
        engine->engineState.luaHardSparkSkip = targetSkipRatio;
        engine->engineState.updateSparkSkip();
        return 0;
    });
    lua_register(lState, "setLaunchTrigger", [](lua_State* l) {
        auto value = luaL_checkinteger(l, 1);
    engine->launchController.luaLaunchState = value;
        return 0;
    });
#endif // EFI_LAUNCH_CONTROL
#if EFI_ANTILAG_SYSTEM
    lua_register(lState, "setRollingIdleTrigger", [](lua_State* l) {
        auto value = luaL_checkinteger(l, 1);
    engine->antilagController.luaAntilagState = value;
        return 0;
    });
#endif // EFI_ANTILAG_SYSTEM
 
#if EFI_EMULATE_POSITION_SENSORS && !EFI_UNIT_TEST
    lua_register(lState, "selfStimulateRPM", [](lua_State* l) {
        auto rpm = luaL_checkinteger(l, 1);
        if (rpm < 1) {
            disableTriggerStimulator();
            return 0;
        }
        if (!engine->triggerCentral.directSelfStimulation) {
            enableTriggerStimulator();
        }
        setTriggerEmulatorRPM(rpm);
        return 0;
    });
#endif // EFI_UNIT_TEST
 
    /**
     * same exact could be accomplished via LuaSensor just with more API
     */
    lua_register(lState, "setLuaGauge", [](lua_State* l) {
        auto index = luaL_checkinteger(l, 1) - 1;
        auto value = luaL_checknumber(l, 2);
        if (index < 0 || index >= LUA_GAUGE_COUNT)
            return 0;
        extern StoredValueSensor luaGauges[LUA_GAUGE_COUNT];
        luaGauges[index].setValidValue(value, getTimeNowNt());
        return 0;
    });
 
    lua_register(lState, "enableCanTx", [](lua_State* l) {
        engine->allowCanTx = lua_toboolean(l, 1);
        return 0;
    });
 
    lua_register(lState, "enableCanRxWorkaround", [](lua_State*) {
        // that's about global_can_data
        engineConfiguration->luaCanRxWorkaround = true;
        return 0;
    });
// high-performance CANbus should be done on F7+, let's preserve couple of priceless bytes on F4
#if !defined(STM32F4)
#if EFI_CAN_SUPPORT
    lua_register(lState, "getCanRxDropped", [](lua_State* l) {
      auto count = getLuaCanRxDropped();
    lua_pushinteger(l, count);
        return 1;
    });
#endif // EFI_CAN_SUPPORT
    lua_register(lState, "disableExtendedCanBroadcast", [](lua_State*) {
        // that's about global_can_data
        engineConfiguration->enableExtendedCanBroadcast = false;
        return 0;
    });
    lua_register(lState, "getCanBaudRate", [](lua_State* l) {
      auto index = luaL_checkinteger(l, 1);
      if (index == 1) {
        lua_pushinteger(l, engineConfiguration->canBaudRate);
      } else {
        lua_pushinteger(l, engineConfiguration->can2BaudRate);
      }
        return 1;
    });
#endif // STM32F4
 
#if !defined(STM32F4) || defined(WITH_LUA_GET_GPPWM_STATE)
    lua_register(lState, "getGpPwm", [](lua_State* l) {
      auto index = luaL_checkinteger(l, 1);
      // this works due to updateGppwm being invoked from periodicSlowCallback
      auto result = engine->outputChannels.gppwmOutput[index];
      lua_pushnumber(l, result);
        return 1;
    });
#endif
 
#if EFI_ELECTRONIC_THROTTLE_BODY && EFI_PROD_CODE
  lua_register(lState, "getEtbTarget", [](lua_State* l) {
    auto controller = engine->etbControllers[0];
        assertNotNull(controller, 0);
    auto result = controller->getCurrentTarget();
        lua_pushnumber(l, result);
        return 1;
  });
    lua_register(lState, "restartEtb", [](lua_State*) {
        // this is about Lua sensor acting in place of real analog PPS sensor
        // todo: smarter implementation
        doInitElectronicThrottle(true); // lame, we run with 'isStartupInit=true' in order to reset, NOT COOL
        return 0;
    });
#endif // EFI_ELECTRONIC_THROTTLE_BODY
 
    // checksum stuff
    lua_register(lState, "crc8_j1850", [](lua_State* l) {
        uint8_t data[8];
        uint32_t length = getLuaArray(l, 1, data, sizeof(data));
        auto trimLength = luaL_checkinteger(l, 2);
        int crc = crc8(data, minI(length, trimLength));
 
        lua_pushinteger(l, crc);
        return 1;
    });
 
#if EFI_BOOST_CONTROL
    lua_register(lState, "setBoostTargetAdd", [](lua_State* l) {
        engine->module<BoostController>().unmock().luaTargetAdd = luaL_checknumber(l, 1);
        return 0;
    });
    lua_register(lState, "setBoostTargetMult", [](lua_State* l) {
        engine->module<BoostController>().unmock().luaTargetMult = luaL_checknumber(l, 1);
        return 0;
    });
    lua_register(lState, "setBoostDutyAdd", [](lua_State* l) {
        engine->module<BoostController>().unmock().luaOpenLoopAdd = luaL_checknumber(l, 1);
        return 0;
    });
#endif // EFI_BOOST_CONTROL
#if EFI_IDLE_CONTROL
    lua_register(lState, "setIdleAdd", [](lua_State* l) {
        engine->module<IdleController>().unmock().luaAdd = luaL_checknumber(l, 1);
        return 0;
    });
    lua_register(lState, "setIdleRpm", [](lua_State* l) {
      auto rpm = luaL_checknumber(l, 1);
    setLinearCurve(config->cltIdleRpm, rpm, rpm, 1);
        return 0;
    });
#endif
    lua_register(lState, "setTimingAdd", [](lua_State* l) {
        engine->ignitionState.luaTimingAdd = luaL_checknumber(l, 1);
        return 0;
    });
#ifndef DISABLE_LUA_SET_TIMING_MULT
    lua_register(lState, "setTimingMult", [](lua_State* l) {
        engine->ignitionState.luaTimingMult = luaL_checknumber(l, 1);
        return 0;
    });
#endif // !defined(DISABLE_LUA_SET_TIMING_MULT)
#ifndef DISABLE_LUA_SET_FUEL_ADD
    lua_register(lState, "setFuelAdd", [](lua_State* l) {
        engine->engineState.lua.fuelAdd = luaL_checknumber(l, 1);
        return 0;
    });
#endif // !defined(DISABLE_LUA_SET_FUEL_ADD)
    lua_register(lState, "setFuelMult", [](lua_State* l) {
        engine->engineState.lua.fuelMult = luaL_checknumber(l, 1);
        return 0;
    });
#if EFI_ELECTRONIC_THROTTLE_BODY && EFI_PROD_CODE
    lua_register(lState, "setEtbAdd", [](lua_State* l) {
        auto luaAdjustment = luaL_checknumber(l, 1);
 
        setEtbLuaAdjustment(luaAdjustment);
 
        return 0;
    });
    lua_register(lState, "setEwgAdd", [](lua_State* l) {
        auto luaAdjustment = luaL_checknumber(l, 1);
 
        setEwgLuaAdjustment(luaAdjustment);
 
        return 0;
    });
    lua_register(lState, "setEtbDisabled", [](lua_State* l) {
        engine->engineState.lua.luaDisableEtb = lua_toboolean(l, 1);
        return 0;
    });
#endif // EFI_ELECTRONIC_THROTTLE_BODY
#if EFI_PROD_CODE
    lua_register(lState, "setIgnDisabled", [](lua_State* l) {
        engine->engineState.lua.luaIgnCut = lua_toboolean(l, 1);
        return 0;
    });
    lua_register(lState, "setFuelDisabled", [](lua_State* l) {
        engine->engineState.lua.luaFuelCut = lua_toboolean(l, 1);
        return 0;
    });
    lua_register(lState, "setDfcoDisabled", [](lua_State* l) {
        engine->engineState.lua.disableDecelerationFuelCutOff = lua_toboolean(l, 1);
        return 0;
    });
#endif // EFI_PROD_CODE
 
    lua_register(lState, "setClutchUpState", [](lua_State* l) {
        engine->engineState.lua.clutchUpState = lua_toboolean(l, 1);
        return 0;
    });
    lua_register(lState, "setClutchDownState", [](lua_State* l) {
        engine->engineState.lua.clutchDownState = lua_toboolean(l, 1);
        return 0;
    });
    lua_register(lState, "setBrakePedalState", [](lua_State* l) {
        engine->engineState.lua.brakePedalState = lua_toboolean(l, 1);
        return 0;
    });
 
    lua_register(lState, "setAcRequestState", [](lua_State* l) {
        engine->engineState.lua.acRequestState = lua_toboolean(l, 1);
        return 0;
    });
 
#if !defined(STM32F4)
    lua_register(lState, "getTorque", [](lua_State* l) {
        auto rpm = Sensor::getOrZero(SensorType::Rpm);
        auto tps = Sensor::getOrZero(SensorType::Tps1);
 
        auto result = interpolate3d(
                        config->torqueTable,
                        config->torqueLoadBins, tps,
                        config->torqueRpmBins, rpm
                    );
        lua_pushnumber(l, result);
        return 1;
    });
#endif
 
    lua_register(lState, "setTorqueReductionState", [](lua_State* l) {
        engine->engineState.lua.torqueReductionState = lua_toboolean(l, 1);
        return 0;
    });
 
    lua_register(lState, "getCalibration", [](lua_State* l) {
        auto propertyName = luaL_checklstring(l, 1, nullptr);
        auto result = getConfigValueByName(propertyName);
        lua_pushnumber(l, result);
        return 1;
    });
 
#if EFI_TUNER_STUDIO && (EFI_PROD_CODE || EFI_SIMULATOR)
    lua_register(lState, "getOutput", [](lua_State* l) {
        auto propertyName = luaL_checklstring(l, 1, nullptr);
         // fresh values need to be requested explicitly, there is no periodic invocation of that method
        updateTunerStudioState();
        auto result = getOutputValueByName(propertyName);
        lua_pushnumber(l, result);
        return 1;
    });
#endif // EFI_PROD_CODE || EFI_SIMULATOR
 
#if EFI_SHAFT_POSITION_INPUT
    lua_register(lState, "getEngineState", [](lua_State* l) {
        spinning_state_e state = engine->rpmCalculator.getState();
        int luaStateCode;
        if (state == STOPPED) {
            luaStateCode = 0;
        } else if (state == RUNNING) {
            luaStateCode = 2;
        } else {
            // spinning-up or cranking
            luaStateCode = 1;
        }
        lua_pushinteger(l, luaStateCode);
        return 1;
    });
#endif //EFI_SHAFT_POSITION_INPUT
 
    lua_register(lState, "setCalibration", [](lua_State* l) {
        auto propertyName = luaL_checklstring(l, 1, nullptr);
        auto value = luaL_checknumber(l, 2);
        auto incrementVersion = lua_toboolean(l, 3);
        bool isGoodName = setConfigValueByName(propertyName, value);
        if (isGoodName) {
            efiPrintf("LUA: applying [%s][%f]", propertyName, value);
        } else {
            efiPrintf("LUA: invalid calibration key [%s]", propertyName);
        }
        if (incrementVersion) {
            incrementGlobalConfigurationVersion("lua");
        }
        return 0;
    });
    lua_register(lState, CMD_BURNCONFIG, [](lua_State*) {
      requestBurn();
        return 0;
    });
 
    lua_register(lState, "getGlobalConfigurationVersion", [](lua_State* l) {
        lua_pushinteger(l, engine->getGlobalConfigurationVersion());
        return 1;
    });
 
    lua_register(lState, "setAcDisabled", [](lua_State* l) {
        auto value = lua_toboolean(l, 1);
        engine->module<AcController>().unmock().isDisabledByLua = value;
        return 0;
    });
    lua_register(lState, "getTimeSinceAcToggleMs", [](lua_State* l) {
        float result = engine->module<AcController>().unmock().timeSinceStateChange.getElapsedSeconds() * 1000;
        lua_pushnumber(l, result);
        return 1;
    });
 
#if !EFI_UNIT_TEST
    lua_register(lState, "startPwm", lua_startPwm);
    lua_register(lState, "setPwmDuty", lua_setPwmDuty);
    lua_register(lState, "setPwmFreq", lua_setPwmFreq);
    lua_register(lState, "getFan", [](lua_State* l) {
                                        lua_pushboolean(l, enginePins.fanRelay.getLogicValue());
                                        return 1;
                                    });
    lua_register(lState, "getFan2", [](lua_State* l) {
                                        lua_pushboolean(l, enginePins.fanRelay2.getLogicValue());
                                        return 1;
                                    });
    lua_register(lState, "getAcRelay", [](lua_State* l) {
                                        lua_pushboolean(l, enginePins.acRelay.getLogicValue());
                                        return 1;
                                    });
    lua_register(lState, "getDigital", lua_getDigital);
    lua_register(lState, "getAuxDigital", lua_getAuxDigital);
    lua_register(lState, "setDebug", lua_setDebug);
#if EFI_ENGINE_CONTROL
    lua_register(lState, "getAirmass", lua_getAirmass);
    lua_register(lState, "setAirmass", lua_setAirmass);
#endif // EFI_ENGINE_CONTROL
 
 
#ifndef WITH_LUA_STOP_ENGINE
#define WITH_LUA_STOP_ENGINE TRUE
#endif
 
#if WITH_LUA_STOP_ENGINE
    lua_register(lState, "isFirmwareError", [](lua_State* l) {
        lua_pushboolean(l, hasFirmwareError());
        return 1;
    });
#if EFI_SHAFT_POSITION_INPUT
    lua_register(lState, "stopEngine", [](lua_State*) {
        doScheduleStopEngine(StopRequestedReason::Lua);
        return 0;
    });
    lua_register(lState, "isEngineStopRequested", [](lua_State* l) {
        bool result = getLimpManager()->shutdownController.isEngineStop(getTimeNowNt());
        lua_pushboolean(l, result);
        return 1;
    });
    lua_register(lState, "getTimeSinceTriggerEventMs", [](lua_State* l) {
        int result = engine->triggerCentral.m_lastEventTimer.getElapsedUs() / 1000;
        lua_pushinteger(l, result);
        return 1;
    });
#endif // EFI_SHAFT_POSITION_INPUT
#endif // WITH_LUA_STOP_ENGINE
 
#if EFI_CAN_SUPPORT
    lua_register(lState, "canRxAdd", lua_canRxAdd);
    lua_register(lState, "canRxAddMask", lua_canRxAddMask);
#endif // EFI_CAN_SUPPORT
#endif // not EFI_UNIT_TEST
 
#if EFI_CAN_SUPPORT || EFI_UNIT_TEST
    lua_register(lState, "txCan", lua_txCan);
#endif
 
#if EFI_PROD_CODE
  /* todo: hasCriticalReportFile method #7291
    lua_register(lState, "hasCriticalReportFile", [](lua_State*) {
        // todo: actual method to scan SD card for error report files
        lua_pushinteger(l, hasCriticalReportFile());
      return 1;
  }
*/
#endif // EFI_PROD_CODE
 
#if EFI_PROD_CODE && HW_HELLEN
    lua_register(lState, "hellenEnablePower", [](lua_State*) {
        hellenEnableEn("Lua");
        return 0;
    });
    lua_register(lState, "hellenDisablePower", [](lua_State*) {
        hellenDisableEn("Lua");
        return 0;
    });
#endif // HW_HELLEN
 
#if EFI_DAC
    lua_register(lState, "setDacVoltage", [](lua_State* l) {
        auto channel = luaL_checkinteger(l, 1);
        auto voltage = luaL_checknumber(l, 2);
        setDacVoltage(channel, voltage);
        return 0;
    });
#endif // EFI_DAC
 
    LuaClass<SignalDebounce> luaDebounce(lState, "SignalDebounce");
    luaDebounce
        .ctor<float>()
        .fun("set", &SignalDebounce::set)
        .fun("get", &SignalDebounce::get);
 
#if EFI_UNIT_TEST
    lua_register(lState, "advanceTimeUs", [](lua_State *l){
        auto us = luaL_checknumber(l, 1);
        advanceTimeUs(us);
        return 0;
    });
#endif // EFI_UNIT_TEST
}

Referenced by setupLuaState().

Here is the caller graph for this function:

findSensorByName()

static SensorType findSensorByName ( lua_State *  l, const char *  name  )

static

Definition at line 106 of file lua_hooks.cpp.

                                                                   {
    SensorType type = findSensorTypeByName(name);
 
    if (l && type == SensorType::Invalid) {
        luaL_error(l, "Invalid sensor type: %s", name);
    }
 
    return type;
}

Referenced by lua_getSensorByName().

Here is the call graph for this function:

Here is the caller graph for this function:

getAuxDigital()

bool getAuxDigital

(

int

index

)

Definition at line 365 of file lua_hooks.cpp.

                              {
#if EFI_PROD_CODE
    return efiReadPin(engineConfiguration->luaDigitalInputPins[index]);
#else
    UNUSED(index);
    return false;
#endif
}

Referenced by lua_getAuxDigital(), pokeAuxDigital(), and runOneLua().

Here is the call graph for this function:

Here is the caller graph for this function:

getLuaAirmassModel()

AirmassModelBase & getLuaAirmassModel

(

)

Definition at line 251 of file lua_hooks.cpp.

                                       {
    return luaAirmass;
}

Referenced by getAirmassModel().

Here is the caller graph for this function:

getLuaArray()

uint32_t getLuaArray	(	lua_State *	l,
		int	paramIndex,
		uint8_t *	data,
		uint32_t	size
	)

Returns

number of elements

Definition at line 140 of file lua_hooks.cpp.

                                                                                 {
    uint32_t result = 0;
 
    luaL_checktype(l, paramIndex, LUA_TTABLE);
    while (true) {
        lua_pushnumber(l, result + 1);
        auto elementType = lua_gettable(l, paramIndex);
        auto val = lua_tonumber(l, -1);
        lua_pop(l, 1);
 
        if (elementType == LUA_TNIL) {
            // we're done, this is the end of the array.
            break;
        }
 
        if (elementType != LUA_TNUMBER) {
            // We're not at the end, but this isn't a number!
            luaL_error(l, "Unexpected data at position %d: %s", result, lua_tostring(l, -1));
        }
 
        // This element is valid, increment DLC
        result++;
 
        if (result > size) {
            luaL_error(l, "Input array longer than buffer");
        }
        else {
            data[result - 1] = val;
        }
    }
    return result;
}

Referenced by configureRusefiLuaHooks().

Here is the caller graph for this function:

getLuaFunc()

int getLuaFunc

(

lua_State *

l

)

Definition at line 532 of file lua_hooks.cpp.

                             {
    if (!isFunction(l, 1)) {
        return luaL_error(l, "expected function");
    } else {
        return luaL_ref(l, LUA_REGISTRYINDEX);
    }
}

Referenced by lua_canRxAdd(), and lua_canRxAddMask().

Here is the call graph for this function:

Here is the caller graph for this function:

getSensor()

static int getSensor ( lua_State *  l, SensorType  type  )

static

Definition at line 77 of file lua_hooks.cpp.

                                                    {
    auto result = Sensor::get(type);
 
    if (result) {
        // return value if valid
        lua_pushnumber(l, result.Value);
    } else {
        // return nil if invalid
        lua_pushnil(l);
    }
 
    return 1;
}

Referenced by lua_getAuxAnalog(), lua_getSensorByIndex(), and lua_getSensorByName().

Here is the call graph for this function:

Here is the caller graph for this function:

isFunction()

static bool isFunction ( lua_State *  l, int  idx  )

static

Definition at line 528 of file lua_hooks.cpp.

                                              {
    return lua_type(l, idx) == LUA_TFUNCTION;
}

Referenced by getLuaFunc(), lua_canRxAdd(), and lua_canRxAddMask().

Here is the caller graph for this function:

lua_canRxAdd()

int lua_canRxAdd

(

lua_State *

l

)

Definition at line 541 of file lua_hooks.cpp.

                               {
    uint32_t eid;
 
    // defaults if not passed
    int bus = ANY_BUS;
    int callback = NO_CALLBACK;
    int argumentCount = lua_gettop(l);
 
    switch (argumentCount) {
        case 1:
            // handle canRxAdd(id)
            eid = luaL_checkinteger(l, 1);
            break;
 
        case 2:
            if (isFunction(l, 2)) {
                // handle canRxAdd(id, callback)
                eid = luaL_checkinteger(l, 1);
                lua_remove(l, 1);
                callback = getLuaFunc(l);
            } else {
                // handle canRxAdd(bus, id)
                bus = validateCanChannelAndConvertFromHumanIntoZeroIndex(l);
                eid = luaL_checkinteger(l, 2);
            }
 
            break;
        case 3:
            // handle canRxAdd(bus, id, callback)
            bus = validateCanChannelAndConvertFromHumanIntoZeroIndex(l);
            eid = luaL_checkinteger(l, 2);
            lua_remove(l, 1);
            lua_remove(l, 1);
            callback = getLuaFunc(l);
            break;
        default:
            return luaL_error(l, "Wrong number of arguments to canRxAdd. Got %d, expected 1, 2, or 3.", argumentCount);
    }
 
    addLuaCanRxFilter(eid, FILTER_SPECIFIC, bus, callback);
 
    return 0;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_canRxAddMask()

int lua_canRxAddMask

(

lua_State *

l

)

Definition at line 585 of file lua_hooks.cpp.

                                   {
    uint32_t eid;
    uint32_t mask;
 
    // defaults if not passed
    int bus = ANY_BUS;
    int callback = NO_CALLBACK;
 
    switch (lua_gettop(l)) {
        case 2:
            // handle canRxAddMask(id, mask)
            eid = luaL_checkinteger(l, 1);
            mask = luaL_checkinteger(l, 2);
            break;
 
        case 3:
            if (isFunction(l, 3)) {
                // handle canRxAddMask(id, mask, callback)
                eid = luaL_checkinteger(l, 1);
                mask = luaL_checkinteger(l, 2);
                lua_remove(l, 1);
                lua_remove(l, 1);
                callback = getLuaFunc(l);
            } else {
                // handle canRxAddMask(bus, id, mask)
                bus = validateCanChannelAndConvertFromHumanIntoZeroIndex(l);
                eid = luaL_checkinteger(l, 2);
                mask = luaL_checkinteger(l, 3);
            }
 
            break;
        case 4:
            // handle canRxAddMask(bus, id, mask, callback)
            bus = validateCanChannelAndConvertFromHumanIntoZeroIndex(l);
            eid = luaL_checkinteger(l, 2);
            mask = luaL_checkinteger(l, 3);
            lua_remove(l, 1);
            lua_remove(l, 1);
            lua_remove(l, 1);
            callback = getLuaFunc(l);
            break;
        default:
            return luaL_error(l, "Wrong number of arguments to canRxAddMask. Got %d, expected 2, 3, or 4.");
    }
 
    addLuaCanRxFilter(eid, mask, bus, callback);
 
    return 0;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_getAirmass()

static int lua_getAirmass ( lua_State *  l )

static

Definition at line 426 of file lua_hooks.cpp.

                                        {
    auto airmassMode = lua_getAirmassResolveMode(l);
    auto airmass = getAirmassModel(airmassMode);
 
    if (!airmass) {
        return luaL_error(l, "null airmass");
    }
 
    auto rpm = Sensor::getOrZero(SensorType::Rpm);
    auto result = airmass->getAirmass(rpm, false).CylinderAirmass;
 
    lua_pushnumber(l, result);
    return 1;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_getAirmassResolveMode()

static auto lua_getAirmassResolveMode ( lua_State *  l )

static

Definition at line 417 of file lua_hooks.cpp.

                                                    {
    if (lua_gettop(l) == 0) {
        // zero args, return configured mode
        return engineConfiguration->fuelAlgorithm;
    } else {
        return static_cast<engine_load_mode_e>(luaL_checkinteger(l, 1));
    }
}

Referenced by lua_getAirmass().

Here is the caller graph for this function:

lua_getAuxAnalog()

static int lua_getAuxAnalog ( lua_State *  l )

static

Definition at line 91 of file lua_hooks.cpp.

                                          {
    // todo: shall we use HUMAN_OFFSET since UI goes from 1 and Lua loves going from 1?
    auto zeroBasedSensorIndex = luaL_checkinteger(l, 1);
 
    auto type = static_cast<SensorType>(zeroBasedSensorIndex + static_cast<int>(SensorType::AuxAnalog1));
 
    return getSensor(l, type);
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_getAuxDigital()

static int lua_getAuxDigital ( lua_State *  l )

static

Definition at line 374 of file lua_hooks.cpp.

                                           {
    auto idx = luaL_checkinteger(l, 1);
    if (idx < 0 || idx >= LUA_DIGITAL_INPUT_COUNT) {
        // Return nil to indicate invalid parameter
        lua_pushnil(l);
        return 1;
    }
 
    if (!isBrainPinValid(engineConfiguration->luaDigitalInputPins[idx])) {
        // Return nil to indicate invalid pin
        lua_pushnil(l);
        return 1;
    }
 
#if !EFI_SIMULATOR
    bool state = getAuxDigital(idx);
    lua_pushboolean(l, state);
#endif // !EFI_SIMULATOR
 
    return 1;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_getDigital()

static int lua_getDigital ( lua_State *  l )

static

Definition at line 345 of file lua_hooks.cpp.

                                        {
    auto idx = luaL_checkinteger(l, 1);
 
    bool state = false;
 
    switch (idx) {
        case 0: state = engine->engineState.clutchDownState; break;
        case 1: state = engine->engineState.clutchUpState; break;
        case 2: state = engine->engineState.brakePedalState; break;
        case 3: state = engine->module<AcController>().unmock().acButtonState; break;
        default:
            // Return nil to indicate invalid parameter
            lua_pushnil(l);
            return 1;
    }
 
    lua_pushboolean(l, state);
    return 1;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_getSensorByIndex()

static int lua_getSensorByIndex ( lua_State *  l )

static

Definition at line 100 of file lua_hooks.cpp.

                                              {
    auto zeroBasedSensorIndex = luaL_checkinteger(l, 1);
 
    return getSensor(l, static_cast<SensorType>(zeroBasedSensorIndex));
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_getSensorByName()

static int lua_getSensorByName ( lua_State *  l )

static

Definition at line 116 of file lua_hooks.cpp.

                                             {
    auto sensorName = luaL_checklstring(l, 1, nullptr);
    SensorType type = findSensorByName(l, sensorName);
 
    return getSensor(l, type);
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_getSensorRaw()

static int lua_getSensorRaw ( lua_State *  l )

static

Definition at line 123 of file lua_hooks.cpp.

                                          {
    auto zeroBasedSensorIndex = luaL_checkinteger(l, 1);
 
    lua_pushnumber(l, Sensor::getRaw(static_cast<SensorType>(zeroBasedSensorIndex)));
    return 1;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_hasSensor()

static int lua_hasSensor ( lua_State *  l )

static

Definition at line 130 of file lua_hooks.cpp.

                                       {
    auto zeroBasedSensorIndex = luaL_checkinteger(l, 1);
 
    lua_pushboolean(l, Sensor::hasSensor(static_cast<SensorType>(zeroBasedSensorIndex)));
    return 1;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_readpin()

static int lua_readpin ( lua_State *  l )

static

Definition at line 60 of file lua_hooks.cpp.

                                     {
#if EFI_PROD_CODE
    const char * msg = luaL_checkstring(l, 1);
    brain_pin_e pin = parseBrainPin(msg);
    if (!isBrainPinValid(pin)) {
        efiPrintf("LUA: invalid pin [%s]", msg);
        lua_pushnil(l);
    } else {
        int physicalValue = palReadPad(getHwPort("read", pin), getHwPin("read", pin));
        lua_pushinteger(l, physicalValue);
    }
#else
    UNUSED(l);
#endif
    return 1;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_setAirmass()

static int lua_setAirmass ( lua_State *  l )

static

Definition at line 441 of file lua_hooks.cpp.

                                        {
    float airmass = luaL_checknumber(l, 1);
    float engineLoadPercent = luaL_checknumber(l, 2);
 
    airmass = clampF(0, airmass, 10);
    engineLoadPercent = clampF(0, engineLoadPercent, 1000);
 
    luaAirmass.setAirmass({airmass, engineLoadPercent});
 
    return 0;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_setDebug()

static int lua_setDebug ( lua_State *  l )

static

Definition at line 396 of file lua_hooks.cpp.

                                      {
    // wrong debug mode, ignore
    if (engineConfiguration->debugMode != DBG_LUA) {
        return 0;
    }
 
    auto idx = luaL_checkinteger(l, 1);
    auto val = luaL_checknumber(l, 2);
 
    // invalid index, ignore
    if (idx < 1 || idx > 7) {
        return 0;
    }
 
    auto firstDebugField = &engine->outputChannels.debugFloatField1;
    firstDebugField[idx - 1] = val;
 
    return 0;
}

Referenced by configureRusefiLuaHooks().

Here is the caller graph for this function:

lua_setPwmDuty()

static int lua_setPwmDuty ( lua_State *  l )

static

Definition at line 325 of file lua_hooks.cpp.

                                        {
    auto p = luaL_checkPwmIndex(l, 1);
    auto duty = luaL_checknumber(l, 2);
    setPwmDuty(p.idx, duty);
 
    return 0;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_setPwmFreq()

static int lua_setPwmFreq ( lua_State *  l )

static

Definition at line 333 of file lua_hooks.cpp.

                                        {
    auto p = luaL_checkPwmIndex(l, 1);
    auto freq = luaL_checknumber(l, 2);
 
    // clamp to 1..1000 hz
    freq = clampF(1, freq, 1000);
 
    p.pwm.setFrequency(freq);
 
    return 0;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_startPwm()

static int lua_startPwm ( lua_State *  l )

static

Definition at line 296 of file lua_hooks.cpp.

                                      {
    auto p = luaL_checkPwmIndex(l, 1);
    auto freq = luaL_checknumber(l, 2);
    auto duty = luaL_checknumber(l, 3);
 
    if (duty < 0 || duty > PWM_MAX_DUTY) {
        luaL_error(l, "Duty parameter should be from 0 to 1 got %f", duty);
        return 0;
    }
 
  startPwm(p.idx, freq, duty);
 
    return 0;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_txCan()

static int lua_txCan ( lua_State *  l )

static

Definition at line 182 of file lua_hooks.cpp.

                                   {
    ScopePerf perf(PE::LuaOneCanTxFunction);
  int bus;
  int id;
  int ext;
  int dataIndex;
  if (lua_gettop(l) == 2) {
    bus = 0;
    id = luaL_checkinteger(l, 1);
    ext = 0;
    dataIndex = 2;
  } else {
    bus = validateCanChannelAndConvertFromHumanIntoZeroIndex(l);
    id = luaL_checkinteger(l, 2);
      ext = luaL_checkinteger(l, 3);
    dataIndex = 4;
  }
 
    // Check that ID is valid based on std vs. ext
    if (ext == 0) {
        luaL_argcheck(l, id <= 0x7FF, 2, "ID specified is greater than max std ID");
    } else {
        luaL_argcheck(l, id <= 0x1FFF'FFFF, 2, "ID specified is greater than max ext ID");
    }
 
    // conform ext parameter to true/false
    CanTxMessage msg(CanCategory::LUA, id, 8, bus, ext == 0 ? false : true);
 
    // Unfortunately there is no way to inspect the length of a table,
    // so we have to just iterate until we run out of numbers
    uint8_t dlc = 0;
 
    // todo: reduce code duplication with getLuaArray
    luaL_checktype(l, dataIndex, LUA_TTABLE);
    while (true) {
        lua_pushnumber(l, dlc + 1);
        auto elementType = lua_gettable(l, dataIndex);
        auto val = lua_tonumber(l, -1);
        lua_pop(l, 1);
 
        if (elementType == LUA_TNIL) {
            // we're done, this is the end of the array.
            break;
        }
 
        if (elementType != LUA_TNUMBER) {
            // We're not at the end, but this isn't a number!
            luaL_error(l, "Unexpected CAN data at position %d: %s", dlc, lua_tostring(l, -1));
        }
 
        // This element is valid, increment DLC
        dlc++;
 
        if (dlc > 8) {
            luaL_error(l, "CAN frame length cannot be longer than 8");
        }
 
        msg[dlc - 1] = val;
    }
 
    msg.setDlc(dlc);
 
    // no return value
    return 0;
}

Referenced by configureRusefiLuaHooks().

Here is the call graph for this function:

Here is the caller graph for this function:

lua_vin()

static int lua_vin ( lua_State *  l )

static

Definition at line 49 of file lua_hooks.cpp.

                                 {
    auto zeroBasedCharIndex = luaL_checkinteger(l, 1);
    if (zeroBasedCharIndex < 0 || zeroBasedCharIndex > VIN_NUMBER_SIZE) {
        lua_pushnil(l);
    } else {
        char value = engineConfiguration->vinNumber[zeroBasedCharIndex];
        lua_pushinteger(l, value);
    }
    return 1;
}

Referenced by configureRusefiLuaHooks().

Here is the caller graph for this function:

luaDeInitPins()

void luaDeInitPins

(

)

Definition at line 311 of file lua_hooks.cpp.

                     {
    // Simply de-init all pins - when the script runs again, they will be re-init'd
    for (size_t i = 0; i < efi::size(enginePins.luaOutputPins); i++) {
        enginePins.luaOutputPins[i].deInit();
    }
}

Referenced by resetLua().

Here is the call graph for this function:

Here is the caller graph for this function:

luaL_checkPwmIndex()

static P luaL_checkPwmIndex ( lua_State *  l, int  pos  )

static

Definition at line 263 of file lua_hooks.cpp.

                                                   {
    auto channel = luaL_checkinteger(l, pos);
 
    // todo: what a mess :( CAN buses start at 1 and PWM channels start at 0 :(
    // Ensure channel is valid
    if (channel < 0 || channel >= LUA_PWM_COUNT) {
        luaL_error(l, "setPwmDuty invalid channel %d", channel);
    }
 
    return { pwms[channel], channel };
}

Referenced by lua_setPwmDuty(), lua_setPwmFreq(), and lua_startPwm().

Here is the caller graph for this function:

setPwmDuty()

void setPwmDuty	(	int	index,
		float	duty
	)

Definition at line 318 of file lua_hooks.cpp.

                                       {
    // clamp to 0..1
    duty = clampF(0, duty, 1);
 
    pwms[index].setSimplePwmDutyCycle(duty);
}

Referenced by lua_setPwmDuty().

Here is the call graph for this function:

Here is the caller graph for this function:

startPwm()

void startPwm	(	int	index,
		float	freq,
		float	duty
	)

Definition at line 279 of file lua_hooks.cpp.

                                                 {
    // clamp to 1..1000 hz, this line would turn 0hz on/off PWM into 1hz behind the scenes
    freq = clampF(1, freq, 1000);
 
  brain_pin_e pwmPin = engineConfiguration->luaOutputPins[index];
 
    startSimplePwmExt(
        &pwms[index], "lua", &engine->scheduler,
        pwmPin, &enginePins.luaOutputPins[index],
        freq, duty
    );
 
    efiPrintf("LUA PWM on %s at %f initial duty",
      hwPortname(pwmPin),
      PERCENT_MULT * duty);
}

Referenced by lua_startPwm().

Here is the call graph for this function:

Here is the caller graph for this function:

validateCanChannelAndConvertFromHumanIntoZeroIndex()

static int validateCanChannelAndConvertFromHumanIntoZeroIndex ( lua_State *  l )

static

Definition at line 175 of file lua_hooks.cpp.

                                                                            {
    lua_Integer channel = luaL_checkinteger(l, 1);
    // TODO: support multiple channels
    luaL_argcheck(l, channel == 1 || channel == 2, 1, "only buses 1 and 2 currently supported");
    return channel - HUMAN_OFFSET;
}

Referenced by lua_canRxAdd(), lua_canRxAddMask(), and lua_txCan().

Here is the caller graph for this function:

Variable Documentation

luaAirmass

LuaAirmass luaAirmass

static

Definition at line 249 of file lua_hooks.cpp.

Referenced by getLuaAirmassModel(), and lua_setAirmass().

pwms

SimplePwm pwms[LUA_PWM_COUNT]

static

Definition at line 256 of file lua_hooks.cpp.

Referenced by luaL_checkPwmIndex(), setPwmDuty(), and startPwm().

tinymt

tinymt32_t tinymt

static

Definition at line 640 of file lua_hooks.cpp.

Referenced by configureRusefiLuaHooks().

Go to the source code of this file.