Functions
void	processLuaCan (const size_t busIndex, const CANRxFrame &frame)

static void	lua_createtable_noGC (lua_State *L, int narray)

static void	handleCanFrame (LuaHandle &ls, CanFrameData *data)

static bool	doOneLuaCanRx (LuaHandle &ls)

int	doLuaCanRx (LuaHandle &ls)

void	initLuaCanRx ()

size_t	getLuaCanRxDropped ()

Variables
static CanFrameData	canFrames [LUA_canFrameCount]

static chibios_rt::Mailbox< CanFrameData *, LUA_canFrameCount >	freeBuffers

static chibios_rt::Mailbox< CanFrameData *, LUA_canFrameCount >	filledBuffers

static size_t	dropRxCount = 0

Function Documentation

◆ doLuaCanRx()

int doLuaCanRx ( LuaHandle & ls )

Definition at line 170 of file lua_can_rx.cpp.

                              {
    ScopePerf perf(PE::LuaAllCanRxFunction);
  int counter = 0;
    // While it processed a frame, continue checking
    while (doOneLuaCanRx(ls)) {
      counter++;
    }
    return counter;
}

Referenced by runOneLua().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ doOneLuaCanRx()

static bool doOneLuaCanRx ( LuaHandle & ls )

static

Definition at line 142 of file lua_can_rx.cpp.

                                         {
    ScopePerf perf(PE::LuaOneCanRxFunction);
    CanFrameData* data;
 
    msg_t msg = filledBuffers.fetch(&data, TIME_IMMEDIATE);
 
    if (msg == MSG_TIMEOUT) {
        // No new CAN messages rx'd, nothing more to do.
        return false;
    }
 
    if (msg != MSG_OK) {
        // Message was otherwise not OK
        // TODO: what do here?
        return false;
    }
 
    // We've accepted the frame, process it in Lua.
    handleCanFrame(ls, data);
 
    // We're done, return this frame to the free list
    msg = freeBuffers.post(data, TIME_IMMEDIATE);
    efiAssert(ObdCode::OBD_PCM_Processor_Fault, msg == MSG_OK, "lua can post to free buffer fail", false);
 
    // We processed a frame so we should check again
    return true;
}

Referenced by doLuaCanRx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getLuaCanRxDropped()

size_t getLuaCanRxDropped ( )

Definition at line 187 of file lua_can_rx.cpp.

                            {
    return dropRxCount;
}

Referenced by configureRusefiLuaHooks(), and startLua().

Here is the caller graph for this function:

◆ handleCanFrame()

static void handleCanFrame	(	LuaHandle &	ls,
		CanFrameData *	data
	)

static

Definition at line 89 of file lua_can_rx.cpp.

                                                              {
    ScopePerf perf(PE::LuaOneCanRxCallback);
    if (data->Callback == NO_CALLBACK) {
        // No callback, use catch-all function
        lua_getglobal(ls, "onCanRx");
    } else {
        // Push the specified callback on to the stack
        lua_rawgeti(ls, LUA_REGISTRYINDEX, data->Callback);
    }
 
  auto frameCanId = CAN_ID(data->Frame);
 
    if (lua_isnil(ls, -1)) {
        // no rx function, ignore
        efiPrintf("LUA CAN rx missing function onCanRx ID=%ld", frameCanId);
        lua_settop(ls, 0);
        return;
    }
 
    auto dlc = data->Frame.DLC;
 
    // Push bus, ID and DLC
    lua_pushinteger(ls, HUMAN_OFFSET + data->BusIndex);
    lua_pushinteger(ls, frameCanId);
    lua_pushinteger(ls, dlc);
 
  if (engineConfiguration->luaCanRxWorkaround) {
    // todo: https://github.com/rusefi/rusefi/issues/6041
    lua_getglobal(ls, "global_can_data");
  } else {
    // Build table for data, custom implementation without explicit GC but still garbage
      lua_createtable_noGC(ls, dlc);
    }
    for (size_t i = 0; i < dlc; i++) {
        lua_pushinteger(ls, data->Frame.data8[i]);
 
        // index is i+1 because Lua "arrays" (tables) are 1-indexed
        lua_rawseti(ls, -2, i + 1);
    }
 
    // Perform the actual function call
    int status = lua_pcall(ls, 4, 0, 0);
 
    if (0 != status) {
        // error calling CAN rx hook function
        auto errMsg = lua_tostring(ls, -1);
        efiPrintf("LUA CAN RX error %s", errMsg);
        lua_pop(ls, 1);
    }
 
    lua_settop(ls, 0);
}

Referenced by doOneLuaCanRx().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initLuaCanRx()

void initLuaCanRx ( )

Definition at line 180 of file lua_can_rx.cpp.

                    {
    // Push all CAN frames in to the free buffer
    for (size_t i = 0; i < LUA_canFrameCount; i++) {
        freeBuffers.post(&canFrames[i], TIME_INFINITE);
    }
}

Referenced by startLua().

Here is the caller graph for this function:

◆ lua_createtable_noGC()

static void lua_createtable_noGC	(	lua_State *	L,
		int	narray
	)

static

Definition at line 74 of file lua_can_rx.cpp.

                                                           {
    Table *t;
    lua_lock(L);
    t = luaH_new(L);
    sethvalue2s(L, L->top.p, t);
    api_incr_top(L);
    luaH_resize(L, t, narray, 0);
 
    // This line is commented out - no need to do a GC every time in
    // this hot path when we'll do it shortly and have plenty of memory available.
    // luaC_checkGC(L);
 
    lua_unlock(L);
}

Referenced by handleCanFrame().

Here is the caller graph for this function:

◆ processLuaCan()

void processLuaCan	(	const size_t	busIndex,
		const CANRxFrame &	frame
	)

Definition at line 38 of file lua_can_rx.cpp.

                                                                   {
    auto filter = getFilterForId(busIndex, CAN_ID(frame));
 
    // Filter the frame if we aren't listening for it
    if (!filter) {
        return;
    }
 
    CanFrameData* frameBuffer;
    msg_t msg;
 
    {
        // Acquire a buffer under lock
        chibios_rt::CriticalSectionLocker csl;
        msg = freeBuffers.fetchI(&frameBuffer);
    }
 
    if (msg != MSG_OK) {
        // all buffers are already in use, this frame will be dropped!
        dropRxCount++;
        return;
    }
 
    // Copy the frame in to the buffer
    frameBuffer->BusIndex = busIndex;
    frameBuffer->Frame = frame;
    frameBuffer->Callback = filter->Callback;
 
    {
        // Push the frame in to the queue under lock
        chibios_rt::CriticalSectionLocker csl;
        filledBuffers.postI(frameBuffer);
    }
}