9102_LUA/script/uart485_test.lua

--[[
@module  485_uart
@summary 485串口功能模块
@version 1.0
@date    2025.09.23
@author  魏健强
@usage
本demo演示的核心功能为：
1.开启串口，配置波特率等参数；
2.设置接收回调函数
3.定时向串口发送数据
]]
local uartid = 12        -- 根据实际设备选取不同的uartid
local uart485Pin = 141    -- 用于控制485接收和发送的使能引脚（根据实际设备选取不同引脚）

local rdbuf = ""      -- 全局接收缓存，用于拼接分包数据

-- 协议格式
local FRAME_HEAD = "\xFE\xFE"  -- 帧头（2字节）
local FRAME_HEAD_LEN = 12      --- 帧头长度12字节
local CHECK_FIELD_LEN = 2      -- CRC校验位占2字节


local function head_paser(data)
    local netHeader = {pro_ver=0,msg_id=0,msg_type1=0,msg_type2=0,msg_len=0}
    local nextpos = 1

    if #data <FRAME_HEAD_LEN then return false,nil end


    nextpos, netHeader.head = pack.unpack(data, "<H", nextpos)      -- 校验帧头
    if netHeader.head ~= 0xFEFE then
        log.info("net","error","帧头错误,应为:FEFE,实际为:", string.format("0x%04X",netHeader.head))
        return false,nil
    end

    nextpos, netHeader.pro_ver   = pack.unpack(data, "b", nextpos)    -- 获取协议版本
    nextpos, netHeader.msg_id    = pack.unpack(data, "<I", nextpos)    -- 获取消息序列号
    nextpos, netHeader.msg_type1 = pack.unpack(data, "b", nextpos)    -- 获取一级消息类型
    nextpos, netHeader.msg_type2 = pack.unpack(data, "<H", nextpos)    -- 获取二级消息类型
    nextpos, netHeader.msg_len   = pack.unpack(data, "<H", nextpos)    -- 校验帧长


    -- log.info("head_paser", "解析帧头成功", 
    --     "协议版本", netHeader.pro_ver,
    --     "消息ID", netHeader.msg_id,
    --     "数据长度N", netHeader.msg_len)

    return true, netHeader
end

local function parse(data)
    if not data or #data == 0 then
        return false, data, nil
    end

    log.info("parse", "开始解析数据", data:toHex())
    -- 步骤1：查找帧头FE FE的位置
    local head_pos = string.find(data, FRAME_HEAD, 1, true)
    if not head_pos then
        log.warn("parse", "未找到帧头FE FE，缓存长度：", #data)
        return false, data, nil  -- 无帧头，返回原缓存
    end

    -- 步骤2：清理帧头前的无效数据（比如乱码、残留字节）
    local remain_buf = string.sub(data, head_pos)
    log.info("parse", "找到帧头，清理无效数据后缓存长度：", #remain_buf)

    -- 步骤3：判断是否够帧头长度（12字节），不够则返回等待后续数据
    if #remain_buf < FRAME_HEAD_LEN then
        log.warn("parse", "缓存仅"..#remain_buf.."字节，不足帧头12字节，等待分包")
        return false, remain_buf, nil
    end

    -- 步骤4：解析帧头，获取数据长度N
    local head_ok, netHeader = head_paser(remain_buf)
    if not head_ok then
        log.error("parse", "帧头解析失败，丢弃当前帧头，继续查找下一个")
        -- 跳过当前错误帧头，从下一个字节继续解析（避免死循环）
        return true, string.sub(remain_buf, 2), nil
    end

    -- 步骤5：计算完整帧总长度 = 帧头(12) + 数据长度(N)
    local frame_total_len = FRAME_HEAD_LEN + netHeader.msg_len
    log.info("parse", "计算完整帧长度：", frame_total_len, "（帧头12 + 数据"..netHeader.msg_len.." + CRC2）")

    -- 步骤6：判断缓存是否够完整帧长度，不够则返回等待分包
    if #remain_buf < frame_total_len then
        log.warn("parse", "缓存仅"..#remain_buf.."字节，不足完整帧"..frame_total_len.."字节，等待分包")
        return false, remain_buf, nil
    end

    -- 步骤7：提取完整帧，剩余数据留待下次解析
    local full_frame = string.sub(remain_buf, 1, frame_total_len)  -- 完整帧
    local unproc_buf = string.sub(remain_buf, frame_total_len + 1) -- 剩余未解析数据

    log.info("parse", "提取完整帧，长度：", #full_frame, "十六进制：", full_frame:toHex())
    return true, unproc_buf, full_frame
end

local function proc(data)
    if not data or #data == 0 then return end
    
    -- 步骤1：追加新数据到全局缓存
    rdbuf = rdbuf .. data
    log.info("proc", "全局缓存总长度：", #rdbuf)

    local result, unproc_buf, full_frame
    unproc_buf = rdbuf

    -- 步骤2：循环解析所有完整帧（处理黏包）
    while true do
        -- 调用parse解析，返回：是否继续、剩余缓存、完整帧
        result, unproc_buf, full_frame = parse(unproc_buf)
        
        -- 解析出完整帧则发布事件
        if full_frame then
            sys.publish("UART_485_RECIVE", full_frame)
        end

        -- 终止条件：无剩余数据/解析失败/无完整帧
        if not result or not unproc_buf or unproc_buf == "" then
            break
        end
    end

    -- 步骤3：更新全局缓存为未解析的剩余数据
    rdbuf = unproc_buf or ""
    log.info("proc", "解析完成，剩余缓存长度：", #rdbuf)
end


local function uart_cb(id, len)
    local data = ""
    repeat
        data = uart.read(id, 1024)  -- 一次读取最多1024字节
        if not data or #data == 0 then break end
        
        -- 打印十六进制（二进制数据必须看十六进制，字符打印会乱码）
        log.info("uart_cb", "接收数据长度：", #data)
        --log.info("uart_cb", "接收数据，长度：", #data, "十六进制：", data:toHex())
        
        -- 处理数据（拼接+解析）
        proc(data)
    until data == ""
end


sys.subscribe("UART_485_RECIVE", function(full_frame)
    if not full_frame or #full_frame == 0 then return end

    -- 解析帧头（再次确认，可选）
    local head_ok, netHeader = head_paser(full_frame)
    if not head_ok then
        log.error("业务解析", "帧头解析失败")
        return
    end

    local data_part = string.sub(full_frame, FRAME_HEAD_LEN + 1, #full_frame - CHECK_FIELD_LEN)
    
    local crc_data_part = string.sub(full_frame, 1, #full_frame - CHECK_FIELD_LEN)

    local crc_str = string.sub(full_frame, #full_frame - CHECK_FIELD_LEN + 1, #full_frame)

    local _, recv_crc = pack.unpack(crc_str, "<H", 1)  -- 第一个返回值是nextpos，无用；第二个是CRC数值

    local calc_crc = crypto.crc16("IBM", crc_data_part)

    log.info("业务解析", 
        "接收CRC数值：", recv_crc, "十六进制：", string.format("0x%04X", recv_crc),
        "计算CRC数值：", calc_crc, "十六进制：", string.format("0x%04X", calc_crc))

    if recv_crc ~= calc_crc then
        log.error("业务解析", "CRC校验失败！")
        return  -- 校验失败，放弃处理该帧
    end
    log.info("业务解析", "CRC校验通过")

    -- 7. 校验通过后处理业务逻辑（示例：根据消息类型分支处理）
    log.info("业务解析完成", 
        "一级消息类型：", netHeader.msg_type1,
        "二级消息类型：", netHeader.msg_type2,
        "消息ID：", netHeader.msg_id)
    
    -- 示例：根据不同消息类型处理数据
    if netHeader.msg_type1 == 0x02 and netHeader.msg_type2 == 0x2002 then
        log.info("业务解析", "处理控制类指令，数据：", data_part:toHex())
        sys.publish("UART_485_RECIVE_CONTROL", data_part)
    -- elseif netHeader.msg_type1 == 0x02 then
    --     log.info("业务解析", "处理数据上报指令，数据：", data_part:toHex())

    end
end)

-- local function uart_send()
--     -- 循环两秒向串口发一次数据
--     while true do
--         sys.wait(2000)
--         uart.write(uartid, "test data.")
--     end
-- end

--初始化
gpio.setup(3,0)
uart.setup(uartid, 115200, 8, 1, uart.NONE, uart.LSB, 1024, uart485Pin, 0, 20000)

-- 收取数据会触发回调, 这里的"receive" 是固定值
uart.on(uartid, "receive", uart_cb)

-- 发送数据完成会触发回调, 这里的"sent" 是固定值
uart.on(uartid, "sent", uart_send_cb)

--sys.taskInit(uart_send)