--- 模块功能：串口1功能测试
-- @author openLuat
-- @module uart.testUart
-- @license MIT
-- @copyright openLuat
-- @release 2018.03.27

module(...,package.seeall)

require "utils"
require "pm"
require "sys"
require "log"
--[[
功能定义：
uart按照帧结构接收外围设备的输入，收到正确的指令后，回复ASCII字符串

帧结构如下：
帧头：1字节，0x01表示扫描指令，0x02表示控制GPIO命令，0x03表示控制端口命令
帧体：字节不固定，跟帧头有关
帧尾：1字节，固定为0xC0

收到的指令帧头为0x01时，回复"CMD_SCANNER\r\n"给外围设备；例如接收到0x01 0xC0两个字节，就回复"CMD_SCANNER\r\n"
收到的指令帧头为0x02时，回复"CMD_GPIO\r\n"给外围设备；例如接收到0x02 0xC0两个字节，就回复"CMD_GPIO\r\n"
收到的指令帧头为0x03时，回复"CMD_PORT\r\n"给外围设备；例如接收到0x03 0xC0两个字节，就回复"CMD_PORT\r\n"
收到的指令帧头为其余数据时，回复"CMD_ERROR\r\n"给外围设备；例如接收到0x04 0xC0两个字节，就回复"CMD_ERROR\r\n"
]]


--串口ID,1对应uart1
--如果要修改为uart2，把UART_ID赋值为2即可
local UART_ID = 1
--帧头以及帧尾
local FRM_HEAD,FRM_TAIL = 0xaa55,0x0d0a
--rfid 去重缓存的超时时间
local  rfid_buffer_timeout = 20
local  rfid_buffer_max_count = 100
--串口读到的数据缓冲区
local rdbuf = ""
require "misc"

local function getTime()
    local tm = misc.getClock()
    return string.format("%04d/%02d/%02d,%02d:%02d:%02d", tm.year, tm.month, tm.day, tm.hour, tm.min, tm.sec)
end

--初始化rfid缓冲池
local start_time = os.time()
local rfids_buf = {["start_time"]=start_time,["rfid_count"]=0,["buf"]={}}
--require "HashMap"
--local rfid_map = HashMap:new()

local function parse_rfid(body)
    if not body then return false end
    if body:len() ~= 9 then 
        log.info("parse_rfid fail,body.length != 9")
        return false 
    end
    local id = string.sub(body,1,6):toHex()
    local type = tonumber(string.byte(body,7))
    local status = tonumber(string.byte(body,8))
    local rssi = tonumber(string.byte(body,9))
    local rfid = {["id"]=id,["type"]=type,["status"]=status,["rssi"]=rssi}
    return rfid
end

--[[
函数名：parse
功能  ：按照帧结构解析处理一条完整的帧数据
参数  ：
        data：所有未处理的数据
返回值：第一个返回值是一条完整帧报文的处理结果，第二个返回值是未处理的数据
]]
local function parse(data)
    if not data then return end    
    if data:len() < 14 then return end
    
    local frm_head = tonumber(string.format( "%02x",string.byte(data,1)) .. string.format( "%02x",string.byte(data,2)),16)
    
    local tail = string.find(data,string.char(0x0d)..string.char(0x0a))
    if not tail then 
        log.info("end char:0x0d0a not found,wait for more ... ", data:toHex())
        return false,data 
    end 
    if frm_head ~= FRM_HEAD then
        log.info("FRM_HEAD ERROR,drop it, frm_head = ", frm_head, ", FRM_HEAD = ", FRM_HEAD)
        return false,string.sub(data,tail+2,-1) 
    end

    local frm_len = tonumber(string.byte(data,3))

    local body,result = string.sub(data,4,tail-1)
    --检测body完整性
    if (frm_len-2) ~= body:len() then
        log.info("frm body length error, frm_len-2 = ",frm_len-2,", body:len() = ", body:len(), ", body:toHex() = ", body:toHex())
        return false,string.sub(data,tail+2,-1) 
    end
    
    --log.info("uart1Task.parse",data:toHex(),frm_head,body:toHex())
    
    --解析rfid
    local rfid_info = parse_rfid(body)
    if not rfid_info then 
        log.info("parse_rfid() failed!")
        return false,string.sub(data,tail+2,-1)
    end

    --检测到超时时，发布数据并重置 rfids_buf
    local cur_time = os.time()
    if (cur_time - rfids_buf.start_time >= rfid_buffer_timeout) or (rfids_buf.rfid_count >= rfid_buffer_max_count) then
        if rfids_buf.rfid_count > 0 then
            --log.info(">>>>>>> uartTaskTest.parse pub_packet_data", cur_time, rfids_buf.rfid_count)
            sys.publish("pub_packet_data", rfids_buf)
        end
        rfids_buf = {["start_time"]=cur_time,["rfid_count"]=0,["buf"]={}}
    end

    --新增数据
    if not rfids_buf["buf"][rfid_info.id] then
        --log.info(">>>>>>> push rfid to buf,rfid:", rfid_info.id)
        rfids_buf.rfid_count = rfids_buf.rfid_count + 1
        rfids_buf["buf"][rfid_info.id] = {["time"]=cur_time,["recv_count"]=1,["rssi"]=rfid_info.rssi,["type"]=rfid_info.type,["status"]=rfid_info.status}
        return true,string.sub(data,tail+2,-1)
    end

    --更新数据
    local recv_count = rfids_buf["buf"][rfid_info.id]["recv_count"] + 1
    rfids_buf["buf"][rfid_info.id] = {["time"]=cur_time,["recv_count"]=recv_count,["rssi"]=rfid_info.rssi,["type"]=rfid_info.type,["status"]=rfid_info.status}
    --log.info(">>>>>>> update rfid_buf,rfid:", rfid_info.id, ", recv_count:", recv_count)

    return true,string.sub(data,tail+2,-1)    
end

--[[
函数名：proc
功能  ：处理从串口读到的数据
参数  ：
        data：当前一次从串口读到的数据
返回值：无
]]
local function proc(data)
    if not data or string.len(data) == 0 then return end
    --追加到缓冲区
    rdbuf = rdbuf..data    
    
    local result,unproc
    unproc = rdbuf
    --根据帧结构循环解析未处理过的数据
    while true do
        result,unproc = parse(unproc)
        if not unproc or unproc == "" or not result then
            break
        end
    end

    rdbuf = unproc or ""
end

--[[
函数名：read
功能  ：读取串口接收到的数据
参数  ：无
返回值：无
]]
local function read()
    local data = ""
    --底层core中，串口收到数据时：
    --如果接收缓冲区为空，则会以中断方式通知Lua脚本收到了新数据；
    --如果接收缓冲器不为空，则不会通知Lua脚本
    --所以Lua脚本中收到中断读串口数据时，每次都要把接收缓冲区中的数据全部读出，这样才能保证底层core中的新数据中断上来，此read函数中的while语句中就保证了这一点
    while true do        
        data = uart.read(UART_ID,"*l")
        if not data or string.len(data) == 0 then break end
        --打开下面的打印会耗时
        log.info("testUart.read bin",data)
        --log.info("testUart.read hex",data:toHex())
        
        --处理串口收到的rfid数据
        proc(data)
    end
end

--[[
函数名：write
功能  ：通过串口发送数据
参数  ：
        s：要发送的数据
返回值：无
]]
function write(s)
    log.info("testUart.write",s)
    uart.write(UART_ID,s.."\r\n")
end

local function writeOk()
    log.info("testUart.writeOk")
end

--检测 rfids_buf是否超时
sys.timerLoopStart(function ()
    --log.info(">>>>>>> uart1Task.timerLoopStart ")
    --检测到超时时，发布数据并重置 rfids_buf
    local cur_time = os.time()
    if (cur_time - rfids_buf.start_time >= rfid_buffer_timeout) or (rfids_buf.rfid_count >= rfid_buffer_max_count) then
        if rfids_buf.rfid_count > 0 then
            --log.info(">>>>>>> uartTaskTest.timerLoopStart pub_packet_data", cur_time, rfids_buf.rfid_count)
            sys.publish("pub_packet_data", rfids_buf)
        end
        rfids_buf = {["start_time"]=cur_time,["rfid_count"]=0,["buf"]={}}
    end
end, 100)

--保持系统处于唤醒状态，此处只是为了测试需要，所以此模块没有地方调用pm.sleep("testUart")休眠，不会进入低功耗休眠状态
--在开发“要求功耗低”的项目时，一定要想办法保证pm.wake("testUart")后，在不需要串口时调用pm.sleep("testUart")
pm.wake("testUart")
--注册串口的数据接收函数，串口收到数据后，会以中断方式，调用read接口读取数据
uart.on(UART_ID,"receive",read)
--注册串口的数据发送通知函数
uart.on(UART_ID,"sent",writeOk)

--配置并且打开串口
--波特率，可选1200，2400，4800，9600，10400，14400，19200，28800，38400，57600，115200，230400，460800，921600
--uart.setup(UART_ID,921600,8,uart.PAR_NONE,uart.STOP_1)
--uart.setup(UART_ID,460800,8,uart.PAR_NONE,uart.STOP_1)
--如果需要打开“串口发送数据完成后，通过异步消息通知”的功能，则使用下面的这行setup，注释掉上面的一行setup
uart.setup(UART_ID,115200,8,uart.PAR_NONE,uart.STOP_1,nil,1)
uart.set_rs485_oe(UART_ID, pio.P2_0) --仅4G 0013版本之后支持