--- 模块功能：数据链路激活、socketCh395管理(创建、连接、数据收发、状态维护)
-- @module socketCh395
-- @author openLuat
-- @license MIT
-- @copyright openLuat
-- @release 2017.9.25
require "link"
require "utils"
module(..., package.seeall)

local sockets = {}


-- 单次发送数据最大值
local SENDSIZE = 1024
-- 缓冲区最大下标
local INDEX_MAX = 2048
-- 是否有socket正处在链接
local socketsConnected = 0

-- CH395配置信息
local configurationCh395 = nil
-- 以太网模块供电设置函数
local powerCbFnc = nil
-- 获取芯片版本（使用0x44以上版本)
local ch395Version = nil
-- 芯片MAC地址
local CH395MAC = nil
local resvnum = 0

TCPCLIENT = 0
UDPCLIENT = 1
RAW = 3
TCPSERVER = 4

local function str2short(str)
    local f, n = pack.unpack(str, '<H')
    return f and f > 0 and n or 0
end

local function shorts(n)
    return pack.pack('<H', n)
end

local function sub_z(data, num)
    return string.sub(data, num + 1, data:len())
end
local function ip2num(str)
    if (not (str and #str == 4)) then
        return ''
    end
    local t = {pack.unpack(str, 'bbbb')}
    return string.format('%d.%d.%d.%d', t[2], t[3], t[4], t[5])
end
local function iptostr(ip)
    local d1, d2, d3, d4 = string.match(ip, '(%d+)%.(%d+)%.(%d+).(%d+)')
    return {string.sub(shorts(d1), 1, 1), string.sub(shorts(d2), 1, 1), string.sub(shorts(d3), 1, 1),
            string.sub(shorts(d4), 1, 1)}
end
------------
local function spiSend(id, data)
    --log.info('send SPI data:', data:toHex())
    local dataSpi
    if configurationCh395['spiCs'] then
        local setSpi_CS = pins.setup(configurationCh395['spiCs'], 0)
        dataSpi = spi.send_recv(id, data)
        setSpi_CS(1)
    else
        dataSpi = spi.send_recv(id, data)
    end
    -- log.info('recv SPI data', dataSpi:toHex())
    return dataSpi
end
-- 命令执行查询
local function inquire2c(time)
    local num = 0
    while true do
        sys.wait(time or 10)
        local data = string.sub(spiSend(spi.SPI_1, '\x2c\xff'), 2, 2)
        if data ~= '\x10' then
            return data
        end
        num = num + 1
        if num > 100 then
            return data
        end
    end
end
-- 获取MAC地址
function getMac()
    return CH395MAC
end

-- 本地端口，初始化默认端口
local socketLocalPort = 0
-- 动态获取本地端口号，每次获取累加
local function socketTcpClientPort()
    -- socketLocalPort = socketLocalPort + 123
    -- if socketLocalPort > 65535 then
    --     socketLocalPort = 1000
    -- end
    -- return socketLocalPort
    local time = string.sub(rtos.tick(), 3)
    if socketLocalPort < 8 then
        socketLocalPort = socketLocalPort + 1
    else
        socketLocalPort = 0
    end
    return (socketLocalPort + time) * 5
end

-- 初始化socket
local function SocketClientInit(type, socketId, soalAddress, soalPort, localPort)
    localPort = localPort or socketTcpClientPort()
    local addr = iptostr(soalAddress)
    -- 设置协议类型
    if type == TCPCLIENT then
        spiSend(spi.SPI_1, string.char(0x34, socketId, 3))
    elseif type == UDPCLIENT then
        spiSend(spi.SPI_1, string.char(0x34, socketId, 2))
    end
    -- 设置本地端口
    spiSend(spi.SPI_1, '\x33' .. string.char(socketId) .. shorts(tonumber(localPort)))
    -- 设置目的端口号
    spiSend(spi.SPI_1, '\x32' .. string.char(socketId) .. shorts(tonumber(soalPort)))
    -- 设置目的地址
    spiSend(spi.SPI_1, string.char(0x31, socketId) .. addr[1] .. addr[2] .. addr[3] .. addr[4])
    -- 打开socket
    spiSend(spi.SPI_1, string.char(0x35, socketId))
    -- 查询执行状态
    local state = inquire2c(50)
    log.info('socketCh395', 'open socket' .. socketId .. state:toHex())
    if state ~= '\x00' or type == UDPCLIENT then
        if type ~= UDPCLIENT then
            log.info('socketCh395', 'open socket err', state:toHex())
        else
            sys.timerStart(function()
                sys.publish('SOCK_CONN_CNF', {
                    ['socket_index'] = socketId,
                    ['id'] = 34,
                    ['result'] = 0
                })
            end, 200)

        end

        return state
    end
    spiSend(spi.SPI_1, string.char(0x37, socketId))
    state = inquire2c()
    if state == '\x00' then
        --sys.publish('SOCK_CONN_CNF', {
        --    ['socket_index'] = socketId,
        --    ['id'] = 34,
        --    ['result'] = 0
        --})
    else
        log.info('socketCh395', 'open socket' .. socketId, state:toHex())
    end

    return state
end

-- 配置8路socket收发缓存
local function socketBufferConfig()
    -- 只有硬件版本大于47才有4-7路
    local b = 0
    for i = 0, 7 do
        spiSend(spi.SPI_1, string.char(0x52, i, b, 4))
        b = b + 4
        spiSend(spi.SPI_1, string.char(0x53, i, b, 2))
        b = b + 2
        sys.wait(500)
    end
end
-- 关闭套接字连接
local function sockectCh395Close(socketId)
    if sockets[socketId] == nil or sockets[socketId] == true then
        log.info('socketCh395', 'close err, not socket ' .. socketId)
    end

    if sockets[socketId] == true or sockets[socketId].protocol == 'TCPSERVERCLIENT' then
        -- server客户端断开连接
        spiSend(spi.SPI_1, string.char(0x38, socketId))
        local state = inquire2c()
        log.info('socketCh395', 'close server socket ' .. socketId)
        sys.publish('SOCK_CLOSE_CNF', {
            ['socket_index'] = socketId,
            ['id'] = 33,
            ['result'] = 0
        })
    elseif sockets[socketId].protocol == 'TCPSERVER' then
        -- server关闭，断开连接，关闭所有server通道
        log.info('socketCh395', 'close server  ' .. socketId)
        for i, v in ipairs(sockets) do
            if sockets[i] ~= true and not sockets[i] and sockets[i].protocol == 'TCPSERVERCLIENT' then
                local id = sockets[i].id
                spiSend(spi.SPI_1, string.char(0x38, sockets[i].id))
                spiSend(spi.SPI_1, string.char(0x3D, socketId))
                sockets[i] = nil
                log.info('socketCh395', 'close server socket ' .. id)
            end
        end

        spiSend(spi.SPI_1, string.char(0x3D, socketId))
        log.info('socketCh395', 'close server  ' .. socketId)
        local state = inquire2c()
        sys.publish('SOCK_CLOSE_CNF', {
            ['socket_index'] = socketId,
            ['id'] = 33,
            ['result'] = 0
        })
    else
        spiSend(spi.SPI_1, string.char(0x3D, socketId))
        local stateClose = inquire2c(10)
        log.info('sockectCh395', 'close socket' .. socketId .. 'true' .. stateClose:toHex())
        sys.publish('SOCK_CLOSE_CNF', {
            ['socket_index'] = socketId,
            ['id'] = 33,
            ['result'] = 0
        })
    end

end
local function ipError()

    if link.isReady() and link.getNetwork() == link.CH395 then
        link.setReady(link.CH395, false)
        sys.publish('IP_ERROR_IND')
        log.info('socketCh395', 'IP_ERROR_IND')
    end
end
-- 处理中断
local function interruptProcess()
    local intAll = string.sub(spiSend(spi.SPI_1, '\x19\xff\xff'), 2, -1)
    -- log.info('INT30', intAll:toHex())
    intAll = str2short(intAll)
    if intAll == 0 or intAll == 65535 then
        return
    end
    -- 处理PHY中断
    if bit.isset(intAll, 2) then
        local statePhy = string.sub(spiSend(spi.SPI_1, '\x26\xff'), 2, -1)
        if statePhy == '\x01' then
            sys.publish("PHY_RESULT", false)
            log.info('socketCh395', 'phy false')
            ipError()
        elseif statePhy == '\x08' then
            sys.publish("PHY_RESULT", true)
            log.info('socketCh395', 'phy true')
        end
    end
    -- 处理DHCP中断
    if bit.isset(intAll, 3) then
        -- DHCP中断
        local stateDhcp = string.sub(spiSend(spi.SPI_1, '\x42\xff'), 2, -1)
        if stateDhcp == '\x00' then
            log.info('socketCh395', 'DHCP true')
        elseif stateDhcp == '\x01' then
            log.info('socketCh395', 'DHCP false')
            ipError()
        end
    end
    -- 处理不可达中断
    if bit.isset(intAll, 0) then
        -- 读取不可达信息？
        log.info('socketCh395', 'Unreachable interrupt')
        -- getUnreachIpport()
    end
    -- 处理IP冲突中断
    if bit.isset(intAll, 1) then
        log.info("IP", 'IP conflict')
        -- 建议重新修改本地IP，并初始化芯片（未加）
    end

    -- socket0-7中断
    local socketIntId = {}
    for i = 4, 11 do
        if bit.isset(intAll, i) then
            table.insert(socketIntId, (i - 4))
        end
    end
    local socketCloss = {}
    -- 逐个socket查询中断并处理
    for q = 1, #socketIntId do
        local socketState = string.sub(spiSend(spi.SPI_1, string.char(0x30, socketIntId[q], 0xff, 0xff)), 3, -1)
        -- log.info('INT19:' .. socketIntId[q], socketState:toHex())
        socketState = str2short(socketState)
        -- TCP连接
        if bit.isset(socketState, 3) then
            -- sockets[socketIntId[q]].connected = true
            if sockets[socketIntId[q]] == true then
                local data = string.sub(spiSend(spi.SPI_1,
                    string.char(0x2d, socketIntId[q], 0xff, 0xff, 0xff, 0xff, 0xff, 0xff)), 3, 8)
                -- server
                local socketData = {
                    id = socketIntId[q],
                    ip = ip2num(string.sub(data, 1, 4)),
                    port = str2short(string.sub(data, 5, 6))

                }
                sys.publish('tcpServer', socketData)
            else
                sys.publish('SOCK_CONN_CNF', {
                    ['socket_index'] = socketIntId[q],
                    ['id'] = 34,
                    ['result'] = 0
                })
            end

        end
        -- 接收缓冲区非空
        if bit.isset(socketState, 2) then
            local data_leng
            local data
            data_leng = string.sub(spiSend(spi.SPI_1, string.char(0x3b, socketIntId[q], 0xff, 0xff)), 3, -1)
            -- if data_leng == '\x00\x00' then
            --     break
            -- end
            data = string.sub(spiSend(spi.SPI_1, string.char(0x3c, socketIntId[q]) .. data_leng ..
                string.rep('\xff', str2short(data_leng))), 5, -1)
            sys.timerStart(function()
                sys.publish('MSG_SOCK_RECV_IND', {
                    ['socket_index'] = socketIntId[q],
                    ['id'] = 31,
                    ['result'] = 0,
                    ['recv_len'] = str2short(data_leng),
                    ['recv_data'] = data
                })
            end, 10)

            -- data_leng = string.sub(spiSend(spi.SPI_1, string.char(0x3b, socketIntId[q], 0xff, 0xff)), 3, -1)
            -- data = string.sub(spiSend(spi.SPI_1, string.char(0x3c, socketIntId[q]) .. data_leng ..
            --     string.rep('\xff', str2short(data_leng))), 5, -1)
            -- sys.publish('MSG_SOCK_RECV_IND', {
            --     ['socket_index'] = socketIntId[q],
            --     ['id'] = 31,
            --     ['result'] = 0,
            --     ['recv_len'] = str2short(data_leng),
            --     ['recv_data'] = data
            -- })
        end
        -- 发送缓冲区空闲
        if bit.isset(socketState, 0) then
            if sockets[socketIntId[q]] and sockets[socketIntId[q]] ~= true then
                sockets[socketIntId[q]].sendstate = true
            else
                log.info('socketCh395', 'sendstate err:' .. socketIntId[q])
            end
        end
        -- 发送成功
        if bit.isset(socketState, 1) then

            sys.publish('SOCK_SEND_CNF', {
                ['socket_index'] = socketIntId[q],
                ['id'] = 32,
                ['result'] = 0
            })

        end

        -- TCP断开
        if bit.isset(socketState, 4) then
            table.insert(socketCloss, {
                ['socket_index'] = socketIntId[q],
                ['id'] = 33,
                ['result'] = 0
            })

        end
        -- 超时
        if bit.isset(socketState, 6) then
            -- 超时处理，重新开启重新连接（未加）
            -- 打开socket
            log.info('socketCh395', 'socket conn timeout' .. socketIntId[q], sockets[socketIntId[q]], socketIntId[q])
             if not sockets[socketIntId[q]] then
                 sockectCh395Close(socketIntId[q])
             elseif sockets[socketIntId[q]] ~= 0 then
                 local ty = sockets[socketIntId[q]].protocol
                 local soalAddress = sockets[socketIntId[q]].address
                 local soalPort = sockets[socketIntId[q]].port
                 local localPort = sockets[socketIntId[q]].localPort
                sockectCh395Close(socketIntId[q])
                 --if ty == 'TCP' then
                     --ty = TCPCLIENT
                 --elseif ty == 'UDP' then
                     --ty = UDPCLIENT
                 --end
                 --SocketClientInit(ty, socketIntId[q], soalAddress, soalPort, localPort)
             end

        end
    end
    for i = 0, 7 do
        if sockets[i] then
            local data_leng
            local data
            data_leng = string.sub(spiSend(spi.SPI_1, string.char(0x3b, i, 0xff, 0xff)), 3, -1)
            if data_leng ~= "\x00\x00" then
                data = string.sub(spiSend(spi.SPI_1,
                    string.char(0x3c, i) .. data_leng .. string.rep('\xff', str2short(data_leng))), 5, -1)
                sys.timerStart(function()
                    sys.publish('MSG_SOCK_RECV_IND', {
                        ['socket_index'] = i,
                        ['id'] = 31,
                        ['result'] = 0,
                        ['recv_len'] = str2short(data_leng),
                        ['recv_data'] = data
                    })
                end, 10)

            end

        end
    end
    for w = 1, #socketCloss do
        local data =
            string.sub(spiSend(spi.SPI_1, string.char(0x2F, socketCloss[w]['socket_index'], 0xff, 0xff)), 3, -1)
        local data1 = string.sub(data, 1, 1)
        local data2 = string.sub(data, 2, 2)
        -- if data1 == '\x00' then
        if not sockets[socketCloss[w]['socket_index']] or sockets[socketCloss[w]['socket_index']] == true then
            sys.timerStart(function(...)
                log.info('socketCh395', 'socket ' .. socketCloss[w]['socket_index'] .. 'state' .. data:toHex())
                sys.publish('MSG_SOCK_CLOSE_IND', socketCloss[w])
                log.info('socketCh395', 'Disconnection socket ', socketCloss[w]['socket_index'])
            end, 200)

        elseif sockets[socketCloss[w]['socket_index']].protocol == 'TCPSERVERCLIENT' then
            -- sockets[socketCloss[w]['socket_index']]=true
            sys.timerStart(function(...)
                log.info('socketCh395', 'socket ' .. socketCloss[w]['socket_index'] .. 'state' .. data:toHex())
                sys.publish('MSG_SOCK_CLOSE_IND', socketCloss[w])
                log.info('socketCh395', 'Disconnection socket ', socketCloss[w]['socket_index'])
            end, 200)
        else
            sys.timerStart(function(...)
                log.info('socketCh395', 'socket ' .. socketCloss[w]['socket_index'] .. 'state' .. data:toHex())
                sys.publish('MSG_SOCK_CLOSE_IND', socketCloss[w])
                log.info('socketCh395', 'Disconnection socket ', socketCloss[w]['socket_index'])
            end, 200)
        end

        -- end

    end
    sys.wait(10)
end

local number = 0
sys.taskInit(function()
    while true do
        if number > 0 or sys.waitUntil("interruptProcess") then
            interruptProcess()
            number = number - 1
            -- sys.wait(5)
        end
    end
end)

-- 配置中断检测
local function setInt(state)
    if state then
        pio.pin.setdebounce(5)
        pins.setup(configurationCh395['intPin'], function(a)
            if a == 2 then
                number = number + 2
                sys.publish("interruptProcess")
            else

            end
        end)
        pio.pin.setdebounce(20)
    else
        pins.close(configurationCh395['intPin'])
    end
end

--- 初始化CH395模块
-- @table para 取值如下：
--               para为table类型，表示以太网的配置参数，参数结构如下：
--                 {
--                     mode = 1,                            --1表示客户端；2表示服务器；默认为1
--                     intPin = pio.P0_22,                  --以太网芯片中断通知引脚
--                     rstPin = pio.P0_23,                  --复位以太网芯片引脚
--                     clientNum = 6,                       --server可连路数
--                     spiCs = pio.P0_23,                   --SPI片选
--                     CH395MAC = "84C2E4A82950",           --MAC地址
--                     localAddr = "192.168.1.112",         --本机的地址
--                     localSubnetMas = "255.255.255.0",    --子网掩码
--                     localPort = 1888,                    --server本机的端口
--                     spiCs=pio.P0_7,                      --spi片选
--                     localGateway = "192.168.1.1",        --本机的网关地址
--                     func=function(id, msg, dat)end,      --中断处理函数，处理server中断事件
--                     powerFunc=function(state) end        --控制以太网模块的供电开关函数，ret为true开启供电，false关闭供电
--                     spi = {spi.SPI_1,0,0,8,800000},      --SPI通道参数，id,cpha,cpol,dataBits,clock，默认spi.SPI_1,0,0,8,800000
--                 }
-- @return result 数据接收结果
--                true表示成功
--                false表示失败
-- @usage
-- socketCh395.open(para)
function open(para)
    configurationCh395 = para
    powerCbFnc = nil or para['powerFunc']
    -- 供电及其他前置条件
    if powerCbFnc then
        powerCbFnc(true)
    end
    -- 复位芯片
    spiSend(spi.SPI_1, '\x05')
    -- 开启SPI
    if not spi.setup(para['spi'][1], para['spi'][2], para['spi'][3], para['spi'][4], para['spi'][5], 1) == 1 then
        log.info('socketCh395', 'open spi err')
        return ''
    end
    -- 设置中断
    setInt(true)
    -- 芯片进入SPI模式
    local setGpioFnc_RSTI = pins.setup(para['rstPin'], 0)
    setGpioFnc_RSTI(0)
    sys.wait(100)
    setGpioFnc_RSTI(1)
    sys.wait(200)
    -- 测试是否成功建立通讯
    local state06 = string.sub(spiSend(spi.SPI_1, '\x06\x55\xff'), 3, 3)
    state06 = state06 == '\xaa'
    log.info('CH395 state', state06)
    if not state06 then
        log.info('socketCh395', 'err cannot work')
        return ''
    end
    -- server多连接设置
    if para['mode'] == 2 then
        spiSend(spi.SPI_1, '\x55\x02')
        local stateInit = inquire2c(50)
        if stateInit ~= '\x00' then
            log.info('open server')
        else
            log.info('open server err', stateInit:toHex())
        end
    end

    -- 获取芯片版本
    ch395Version = string.sub(spiSend(spi.SPI_1, '\x01\xff'), 2, 2)

    -- 配置芯片信息
    if para['localAddr'] and para['localGateway'] then
        -- 配置本地信息
        local gateway = iptostr(para['localGateway'])
        local addr = iptostr(para['localAddr'])

        spiSend(spi.SPI_1, '\x22' .. addr[1] .. addr[2] .. addr[3] .. addr[4])
        spiSend(spi.SPI_1, '\x23' .. gateway[1] .. gateway[2] .. gateway[3] .. gateway[4])
        if para['localSubnetMas'] then
            local subnetMas = iptostr(para['localSubnetMas'])
            spiSend(spi.SPI_1, '\x24' .. subnetMas[1] .. subnetMas[2] .. subnetMas[3] .. subnetMas[4])
        end
    end
    -- 设置收发缓存（默认8路）
    socketBufferConfig()
    -- 模块初始化
    spiSend(spi.SPI_1, '\x27')
    local stateInit = inquire2c(50)
    if stateInit ~= '\x00' then
        log.info('socketCh395', 'ch395 INIT err' .. stateInit:toHex())
        return ''
    end

    local result, result2 = sys.waitUntil("PHY_RESULT", 60000)
    if not result or not result2 then
        return ''
    end

    -- 设置MAC地址
    if para['CH395MAC'] and string.len(para['CH395MAC']) == 12 then
        spiSend(spi.SPI_1, '\x21' .. string.fromHex(para['CH395MAC']))
        sys.wait(200)
    end

    -- 获取芯片MAC
    CH395MAC = string.sub(spiSend(spi.SPI_1, string.fromHex('40FFFFFFFFFFFF2cff')), 2, 7)
    if CH395MAC == string.char(0, 0, 0, 0, 0, 0) then
        CH395MAC = nil
    end

    -- DHCP
    if not (para['localAddr'] and para['localGateway']) then
        spiSend(spi.SPI_1, '\x41\x01')
        local stateDhcp = inquire2c(30)
        if stateDhcp ~= '\x00' then
            log.info('socketCh395', 'ch395 INIT err' .. stateDhcp:toHex())
            return ''
        end
    end
    -- 获取本地IP
    for q = 1, 20 do
        sys.wait(500)
        local dataIp = string.sub(spiSend(spi.SPI_1, string.fromHex('43ffffffffffffffffffffffffffffffffffffffff')), 2,
            -1)
        if link.getNetwork() == link.CH395 and string.sub(dataIp, 1, 4) ~= '\xff\xff\xff\xff' and
            string.sub(dataIp, 1, 4) ~= '\x00\x00\x00\x00' then
            local ch395Ip = ip2num(string.sub(dataIp, 1, 4))
            log.info('ip', ch395Ip)
            link.setReady(link.CH395, true)
            sys.publish('IP_READY_IND')
            return ch395Ip
        end
    end
    return ''
end

---  开关模块
function close()
    link.setReady(link.CH395, false)
    sys.publish('IP_ERROR_IND')
    -- 关闭所有socket
    for i = 0, 7 do
        spiSend(spi.SPI_1, string.char(0x3D, i))
        sockets[i] = nil
    end
    -- 关闭中断检测
    setInt(false)
    -- 关闭SPI
    if not spi.close(configurationCh395['spi'][1]) == 1 then
        log.info('socketCh395 close spi err', configurationCh395['spi'][1], configurationCh395['spi'][2],
            configurationCh395['spi'][3], configurationCh395['spi'][4], configurationCh395['spi'][5], 1)
        return false
    end

    -- 关闭模块
    if powerCbFnc then
        powerCbFnc(false)
    end
    return true
end

---建立套接字连接
local function sockectCh395Conn(type, addr, port, lcoalPort, data)
    local socketId = nil

    for i = 0, 7 do
        if not sockets[i] then
            socketId = i
            data.id=i
            sockets[i] = data
            break
        end
        if i == 7 then
            log.info('socketCh395', 'No socket available ')
            return nil
        end
    end
    if type == TCPCLIENT or type == UDPCLIENT then
        local tcpClientState = SocketClientInit(type, socketId, addr, port, lcoalPort)
        if tcpClientState == '\x00' then
            return socketId
        else
            spiSend(spi.SPI_1, string.char(0x3D, socketId))
            local stateClose = inquire2c(50)
            if stateClose == '\x00' then
                log.info('sockectCh395', 'close socket' .. socketId .. 'true')
            end
            sockets[socketId] = nil
            return nil
        end
    elseif type == TCPSERVER then

    end
end

-- 发送数据
local function sockectCh395Send(socketId, data)
    for i = 1, 10 do
        if sockets[socketId] and sockets[socketId] ~= true and sockets[socketId].sendstate then
            spiSend(spi.SPI_1, '\x39' .. string.char(socketId) .. shorts(#data) .. data)
            local state = inquire2c(50)
            if state == '\x00' then
                sys.publish('SOCK_SEND_CNF', {
                    ['socket_index'] = socketId,
                    ['id'] = 32,
                    ['result'] = 0
                })
            else
                sys.publish('SOCK_SEND_CNF', {
                    ['socket_index'] = socketId,
                    ['id'] = 32,
                    ['result'] = 1
                })
            end
            log.info('socketCh395', socketId .. 'send state' .. state:toHex())
            break
        elseif not sockets[socketId] or sockets[socketId] == true then
            -- log.info('socketCh395', 'send err, not socket ' .. socketId)
        else
            sys.wait(100)
        end
    end
end

-- 接收数据
local function sockectCh395Recv(socketId, buffLen)
    local data_leng = string.sub(spiSend(spi.SPI_1, string.char(0x3b, socketId, 0xff, 0xff)), 3, -1)
    local data = string.sub(spiSend(spi.SPI_1, string.char(0x3c, socketId) .. data_leng ..
        string.rep('\xff', str2short(data_leng))), 5, -1)
    return data
end
-- table 深拷贝
local function clone(tb)
    local ret = {}
    for k, v in pairs(tb) do
        ret[k] = type(v) == "table" and clone(v) or v
    end
    return ret
end
-- 创建server
local function initServer(port, num, data)
    if num > 7 then
        return
    end
    local dd = true
    local serverTable = {}
    local serverid = nil
    for i = 0, 7 do
        if not sockets[i] then
            table.insert(serverTable, i)
            if dd then
                sockets[i] = data
                dd = false
            else

                sockets[i] = clone(data)
            end

            if #serverTable == num + 1 then
                break
            end

        end
        if i == 7 then
            log.info('socketCh395', 'No socket available ')
            for q = 1, #serverTable do
                sockets[serverTable[q]] = nil
            end
            return nil
        end
    end
    for i = 1, #serverTable do
        spiSend(spi.SPI_1, string.char(0x34, serverTable[i], 3))
        spiSend(spi.SPI_1, string.char(0x33, serverTable[i]) .. shorts(port))
        if i == 1 then
            spiSend(spi.SPI_1, string.char(0x35, serverTable[i]))
            sockets[i].id = serverTable[i]
            serverid = serverTable[i]
            local state = inquire2c(50)
            if state == '\x00' then
                sockets[serverTable[i]].id = serverTable[i]
                sockets[serverTable[i]].protocol = 'TCPSERVER'
            else
                log.info('socket open err', state:toHex())
                log.info('socketCh395', 'socket open err')
            end

        else
            local state = inquire2c(50)
            if state == '\x00' then
                log.info('socketCh395', 'server open' .. serverTable[i])

                sockets[serverTable[i]].protocol = 'TCPSERVERCLIENT' .. serverTable[i]
                sockets[serverTable[i]] = true

            end
            if i == num + 1 then
                spiSend(spi.SPI_1, string.char(0x36, serverid))
                local state = inquire2c(50)
                if state == '\x00' then
                    return serverid
                end

            end
        end
    end

end

------------------------
local function errorInd(error)
    local coSuspended = {}

    for _, c in pairs(sockets) do -- IP状态出错时，通知所有已连接的socket
        if c ~= true then
            c.error = error
            -- 不能打开如下3行代码，IP出错时，会通知每个socket，socket会主动close
            -- 如果设置了connected=false，则主动close时，直接退出，不会执行close动作，导致core中的socket资源没释放
            -- 会引发core中socket耗尽以及socket id重复的问题
            -- c.connected = false
            -- socketsConnected = c.connected or socketsConnected
            -- if error == 'CLOSED' then sys.publish("SOCKET_ACTIVE", socketsConnected) end
            if c.co and coroutine.status(c.co) == "suspended" then
                -- coroutine.resume(c.co, false)
                table.insert(coSuspended, c.co)
            end
        end

    end

    for k, v in pairs(coSuspended) do
        if v and coroutine.status(v) == "suspended" then
            coroutine.resume(v, false, error)
        end
    end
end

sys.subscribe("IP_ERROR_IND", function()
    errorInd('IP_ERROR_IND')
end)
-- sys.subscribe('IP_SHUT_IND', function()errorInd('CLOSED') end)
-- 创建socket函数
local mt = {}
mt.__index = mt
local function socket(protocol, cert, tCoreExtPara)
    local ssl = protocol:match("SSL")
    local co = coroutine.running()
    if not co then
        log.warn("socket.socket: socket must be called in coroutine")
        return nil
    end
    -- if protocol == 'TCPSERVER' and type(tCoreExtPara) == 'table' then
    --     protocol
    -- end
    -- 实例的属性参数表
    local o = {
        id = nil,
        protocol = protocol,
        tCoreExtPara = tCoreExtPara,
        ssl = ssl,
        cert = cert,
        co = co,
        input = {},
        output = {},
        wait = "",
        connected = false,
        iSubscribe = false,
        subMessage = nil,
        isBlock = false,
        msg = nil,
        rcvProcFnc = nil,
        sendstate = true, -- 发送缓冲区状态，true为空闲，可发送数据
        localPort = nil -- 本地端口
    }
    if tCoreExtPara and tCoreExtPara['localport'] and type(tCoreExtPara['localport']) == 'number' then
        o.localPort = tCoreExtPara['port']
    end
    if protocol == 'TCPSERVER' and tCoreExtPara['type']== 'TCPSERVER' then
        o.port = configurationCh395["localPort"]
        local id = initServer(configurationCh395["localPort"], configurationCh395["clientNum"], setmetatable(o, mt))
        if not id then
            log.info('socketCh395', 'server socket err')
            return
        end
    elseif protocol == 'TCPSERVER' and tCoreExtPara['type']~= 'TCPSERVER' then
        o.address = tCoreExtPara['ip']
        o.port = tCoreExtPara['port']
        o.id = tCoreExtPara['id']
        o.protocol = 'TCPSERVERCLIENT'
        sockets[tCoreExtPara['id']] = setmetatable(o, mt)
    end
    return setmetatable(o, mt)
end

--- 创建基于TCP的socket对象
-- @bool[opt=nil] ssl 是否为ssl连接，true表示是，其余表示否
-- @table[opt=nil] cert 保留参数，ssl功能还未实现。
-- @table[opt=nil] tCoreExtPara 建立链接扩展参数
-- {
--     id =0, --server socket索引ID
--     ip ="192.168.1.1", --server socket client ip
--     port ="8000", --server socket client port
--     type ="TCPSERVER", --server socket type
--     localport ="8000", -- socket client port
-- }
-- @return client，创建成功返回socket客户端对象；创建失败返回nil

function tcp(ssl, cert, tCoreExtPara)
    if tCoreExtPara and tCoreExtPara['type'] == "TCPSERVER" then
        return socket("TCPSERVER", nil, tCoreExtPara)
    elseif tCoreExtPara and tCoreExtPara['type'] ~= "TCPSERVER" then
        return socket("TCPSERVER", nil, tCoreExtPara)
    end
    return socket("TCP" .. (ssl == true and "SSL" or ""), (ssl == true) and cert or nil, tCoreExtPara)
end

--- 创建基于UDP的socket对象
-- @return client，创建成功返回socket客户端对象；创建失败返回nil
-- @usage c = socketCh395.udp()
function udp(localPort)
    return socket("UDP", nil, localPort)
end

--- 连接服务器
-- @string address 服务器地址，支持ip和域名
-- @param port string或者number类型，服务器端口
-- @number[opt=120] timeout 可选参数，连接超时时间，单位秒
-- @return bool result true - 成功，false - 失败
-- @return string ,id '0' -- '8' ,返回通道ID编号
-- @usage  
-- socketClient = socketCh395.tcp()
-- socketClient:connect("www.baidu.com","80")
function mt:connect(address, port, timeout)
    assert(self.co == coroutine.running(), "socket:connect: coroutine mismatch")
    log.info('socketCh395', 'socket data' .. self.protocol, address, port)
    if not link.isReady() then
        log.info("socket.connect: ip not ready")
        return false
    end

    self.address = address
    self.port = port
    local tCoreExtPara = self.tCoreExtPara or {}
    -- 默认缓冲区大小
    local rcvBufferSize = tCoreExtPara.rcvBufferSize or 0
    local d1, d2, d3, d4 = string.match(address, '(%d+)%.(%d+)%.(%d+).(%d+)')
    if not (d1 == nil or d2 == nil or d3 == nil or d4 == nil) then
        if self.protocol == 'TCP' then
            self.id = sockectCh395Conn(TCPCLIENT, address, port, self.localPort, self)

        elseif self.protocol == 'TCPSSL' then
            -- 未实现
            log.info("socketCh395", "no ssl")
        else
            self.id = sockectCh395Conn(UDPCLIENT, address, port, self.localPort, self)
        end
    else
        self.id = -2
    end
    if type(socketcore.sock_conn_ext) == "function" then
        if not self.id or self.id < 0 then
            if self.id == -2 then
                require "http"
                -- 请求腾讯云免费HttpDns解析
                http.request("GET", "119.29.29.29/d?dn=" .. address, nil, nil, nil, 40000,
                    function(result, statusCode, head, body)
                        log.info("socket.httpDnsCb", result, statusCode, head, body)
                        sys.publish("SOCKET_HTTPDNS_RESULT_" .. address .. "_" .. port, result, statusCode, head, body)
                    end)
                local _, result, statusCode, head, body = sys.waitUntil(
                    "SOCKET_HTTPDNS_RESULT_" .. address .. "_" .. port)

                -- DNS解析成功
                if result and statusCode == "200" and body and body:match("^[%d%.]+") then
                    return self:connect(body:match("^([%d%.]+)"), port, timeout)
                end
            end
            self.id = nil
        end
    end
    if not self.id then
        log.info("socket:connect: core sock conn error", self.protocol, address, port, self.cert)
        return false
    end
    log.info("socket:connect-coreid,prot,addr,port,cert,timeout", self.id, self.protocol, address, port, self.cert,
        timeout or 120)
    sockets[self.id] = self
    self.wait = "SOCKET_CONNECT"
    self.timerId = sys.timerStart(coroutine.resume, (timeout or 120) * 1000, self.co, false, "TIMEOUT")
    local result, reason = coroutine.yield()
    if not result and reason == 'server close' then
        return false
    end
    if self.timerId and reason ~= "TIMEOUT" then
        sys.timerStop(self.timerId)
    end
    if not result then
        log.info("socket:connect: connect fail" .. self.id, reason)
        if reason == "RESPONSE" then
            sockets[self.id] = nil
            self.id = nil
        end
        sys.publish("LIB_SOCKET_CONNECT_FAIL_IND", self.ssl, self.protocol, address, port)
        return false
    end
    log.info("socket:connect: connect ok")

    if not self.connected then
        self.connected = true
        socketsConnected = socketsConnected + 1
        sys.publish("SOCKET_ACTIVE", socketsConnected > 0)
    end

    return true, self.id
end

function mt:serverClose()
    if not self then
        return false
    end
    if self.error then
        log.warn('socket.client:asyncSelect', 'error', self.error)
        return false
    end
    coroutine.resume(self.co, false, 'server close')
end

--- server发送数据
-- @number[opt=nil] keepAlive 服务器和客户端最大通信间隔时间,也叫心跳包最大时间,单位秒
-- @string[opt=nil] pingreq 心跳包的字符串
-- @return boole,false 失败，true 表示成功
-- @usage
-- socketClient = socketCh395.tcp()
-- socketClient:connect("www.baidu.com","80")
-- while socketClient:serverSelect() do end
function mt:serverSelect(keepAlive, pingreq)
    assert(self.co == coroutine.running(), "socket:asyncSelect: coroutine mismatch")
    if self.error then
        log.warn('socket.client:asyncSelect', 'error', self.error)
        return false
    end
    self.wait = "SOCKET_SEND"
    local dataLen = 0
    -- log.info("socket.asyncSelect #self.output",#self.output)
    while #self.output ~= 0 do
        local data = table.concat(self.output)
        dataLen = string.len(data)
        self.output = {}
        local sendSize = SENDSIZE
        for i = 1, dataLen, sendSize do
            -- 按最大MTU单元对data分包
            sockectCh395Send(self.id, data:sub(i, i + sendSize - 1))
            if self.timeout then
                self.timerId = sys.timerStart(coroutine.resume, self.timeout * 1000, self.co, false, "TIMEOUT")
            end
            -- log.info("socket.asyncSelect self.timeout",self.timeout)
            local result, reason = coroutine.yield()
            if not result and reason == 'server close' then
                return false
            end
            log.info('发送结果', result, reason)
            if self.timerId and reason ~= "TIMEOUT" then
                sys.timerStop(self.timerId)
            end
            sys.publish("SOCKET_ASYNC_SEND", result)
            if not result then
                sys.publish("LIB_SOCKET_SEND_FAIL_IND", self.ssl, self.protocol, self.address, self.port)
                log.warn('socket.asyncSelect', 'send error', data:sub(i, i + sendSize - 1))
                return false
            end
        end
    end
    self.wait = "SOCKET_WAIT"
    -- log.info("socket.asyncSelect",dataLen,self.id)
    if dataLen > 0 then
        sys.publish("SOCKET_SEND", self.id, true)
    end
    if keepAlive and keepAlive ~= 0 then
        if type(pingreq) == "function" then
            sys.timerStart(pingreq, keepAlive * 1000)
        else
            sys.timerStart(self.asyncSend, keepAlive * 1000, self, pingreq or "\0")
        end
    end
    local result, reason = coroutine.yield()
    if not result and reason == 'server close' then
        return false
    end
    return result, reason

end

--- 异步发送数据
-- @number[opt=nil] keepAlive 服务器和客户端最大通信间隔时间,也叫心跳包最大时间,单位秒
-- @string[opt=nil] pingreq 心跳包的字符串
-- @return boole,false 失败，true 表示成功
-- @usage
-- socketClient = socketCh395.tcp()
-- socketClient:connect("www.baidu.com","80")
-- while socketClient:asyncSelect() do end
function mt:asyncSelect(keepAlive, pingreq)
    assert(self.co == coroutine.running(), "socket:asyncSelect: coroutine mismatch")
    if self.error then
        log.warn('socket.client:asyncSelect', 'error', self.error)
        return false
    end

    self.wait = "SOCKET_SEND"
    local dataLen = 0
    -- log.info("socket.asyncSelect #self.output",#self.output)
    while #self.output ~= 0 do
        local data = table.concat(self.output)
        dataLen = string.len(data)
        self.output = {}
        local sendSize = self.protocol == "UDP" and 1472 or SENDSIZE
        for i = 1, dataLen, sendSize do
            -- 按最大MTU单元对data分包
            -- socketcore.sock_send(self.id, data:sub(i, i + sendSize - 1))
            sockectCh395Send(self.id, data:sub(i, i + sendSize - 1))
            if self.timeout then
                self.timerId = sys.timerStart(coroutine.resume, self.timeout * 1000, self.co, false, "TIMEOUT")
            end
            -- log.info("socket.asyncSelect self.timeout",self.timeout)
            local result, reason = coroutine.yield()
            if not result and reason == 'server close' then
                return false
            end
            if self.timerId and reason ~= "TIMEOUT" then
                sys.timerStop(self.timerId)
            end
            sys.publish("SOCKET_ASYNC_SEND", result)
            if not result then
                sys.publish("LIB_SOCKET_SEND_FAIL_IND", self.ssl, self.protocol, self.address, self.port)
                -- log.warn('socket.asyncSelect', 'send error')
                return false
            end
        end
    end
    self.wait = "SOCKET_WAIT"
    -- log.info("socket.asyncSelect",dataLen,self.id)
    if dataLen > 0 then
        sys.publish("SOCKET_SEND", self.id, true)
    end
    if keepAlive and keepAlive ~= 0 then
        if type(pingreq) == "function" then
            sys.timerStart(pingreq, keepAlive * 1000)
        else
            sys.timerStart(self.asyncSend, keepAlive * 1000, self, pingreq or "\0")
        end
    end
    local result, reason = coroutine.yield()
    if not result and reason == 'server close' then
        return false
    end
    return result, reason
end

function mt:getAsyncSend()
    if self.error then
        return 0
    end
    return #(self.output)
end

--- server缓存待发送的数据
-- @string data 数据
-- @number[opt=nil] timeout 可选参数，发送超时时间，单位秒；为nil时表示不支持timeout
-- @return result true - 成功，false - 失败
-- @usage
-- socketClient = socketCh395.tcp()
-- socketClient:connect("www.baidu.com","80")
-- socketClient:serverSend("12345678")
function mt:serverSend(data, timeout)
    if self.error then
        log.warn('socket.client:asyncSend', 'error', self.error)
        return false
    end
    self.timeout = timeout
    table.insert(self.output, data or "")
    -- log.info("socket.asyncSend",self.wait)
    if self.wait == "SOCKET_WAIT" then
        coroutine.resume(self.co, true)
    end
    return true
end
--- server接收数据
-- @return data 表示接收到的数据(如果是UDP，返回最新的一包数据；如果是TCP,返回所有收到的数据)
--              ""表示未收到数据
-- @usage 
-- socketClient = socketCh395.tcp()
-- socketClient:connect("www.baidu.com","80")
-- data = socketClient:serverRecv()
function mt:serverRecv()
    if #self.input == 0 then
        return ""
    end
    if self.protocol == "UDP" then
        return table.remove(self.input)
    else
        local s = table.concat(self.input)
        self.input = {}
        if self.isBlock then
            table.insert(self.input, recv(self.msg.socket_index, self.msg.recv_len))
        end
        return s
    end
end

--- 异步缓存待发送的数据
-- @string data 数据
-- @number[opt=nil] timeout 可选参数，发送超时时间，单位秒；为nil时表示不支持timeout
-- @return result true - 成功，false - 失败
-- @usage
-- socketClient = socketCh395.tcp()
-- socketClient:connect("www.baidu.com","80")
-- socketClient:asyncSend("12345678")
function mt:asyncSend(data, timeout)
    if self.error then
        log.warn('socket.client:asyncSend', 'error', self.error)
        return false
    end
    self.timeout = timeout
    table.insert(self.output, data or "")
    -- log.info("socket.asyncSend",self.wait)
    if self.wait == "SOCKET_WAIT" then
        coroutine.resume(self.co, true)
    end
    return true
end
--- 异步接收数据
-- @return data 表示接收到的数据(如果是UDP，返回最新的一包数据；如果是TCP,返回所有收到的数据)
--              ""表示未收到数据
-- @usage 
-- socketClient = socketCh395.tcp()
-- socketClient:connect("www.baidu.com","80")
-- data = socketClient:asyncRecv()
function mt:asyncRecv()
    if #self.input == 0 then
        return ""
    end
    if self.protocol == "UDP" then
        return table.remove(self.input)
    else
        local s = table.concat(self.input)
        self.input = {}
        if self.isBlock then
            table.insert(self.input, socketcore.sock_recv(self.msg.socket_index, self.msg.recv_len))
        end
        return s
    end
end

--- 同步发送数据
-- @string data 数据
--              此处传入的数据长度和剩余可用内存有关，只要内存够用，可以随便传入数据
--              虽然说此处的数据长度没有特别限制，但是调用core中的socket发送接口时，每次最多发送11200字节的数据
--              例如此处传入的data长度是112000字节，则在这个send接口中，会循环10次，每次发送11200字节的数据
-- @number[opt=120] timeout 可选参数，发送超时时间，单位秒
-- @return result true - 成功，false - 失败
-- @usage
-- socketClient = socketCh395.tcp()
-- socketClient:connect("www.baidu.com","80")
-- socketClient:send("12345678")
function mt:send(data, timeout)
    assert(self.co == coroutine.running(), "socket:send: coroutine mismatch")
    if self.error then
        log.warn('socket.client:send', 'error', self.error)
        return false
    end
    log.debug("socket.send", "total " .. string.len(data or "") .. " bytes", "first 30 bytes", (data or ""):sub(1, 30))
    local sendSize = self.protocol == "UDP" and 1472 or SENDSIZE
    for i = 1, string.len(data or ""), sendSize do
        -- 按最大MTU单元对data分包
        self.wait = "SOCKET_SEND"
        sockectCh395Send(self.id, data:sub(i, i + sendSize - 1))
        self.timerId = sys.timerStart(coroutine.resume, (timeout or 120) * 1000, self.co, false, "TIMEOUT")
        local result, reason = coroutine.yield()
        if not result and reason == 'server close' then
            return false
        end
        if self.timerId and reason ~= "TIMEOUT" then
            sys.timerStop(self.timerId)
        end
        if not result then
            log.info("socket:send" .. self.id, "send fail", reason)
            sys.publish("LIB_SOCKET_SEND_FAIL_IND", self.ssl, self.protocol, self.address, self.port)
            return false
        end
    end
    return true
end

--- 同步接收数据
-- @number[opt=0] timeout 可选参数，接收超时时间，单位毫秒
-- @string[opt=nil] msg 可选参数，控制socket所在的线程退出recv阻塞状态
-- @bool[opt=nil] msgNoResume 可选参数，控制socket所在的线程退出recv阻塞状态
--                false或者nil表示“在recv阻塞状态，收到msg消息，可以退出阻塞状态”，true表示不退出
--                此参数仅lib内部使用，应用脚本不要使用此参数
-- @return result 数据接收结果
--                true表示成功（接收到了数据）
--                false表示失败（没有接收到数据）
-- @return data 
--                如果result为true，data表示接收到的数据(如果是UDP，返回最新的一包数据；如果是TCP,返回所有收到的数据)
--                如果result为false，超时失败，data为"timeout"
--                如果result为false，msg控制退出，data为msg的字符串
--                如果result为false，socket连接被动断开控制退出，data为"CLOSED"
--                如果result为false，PDP断开连接控制退出，data为"IP_ERROR_IND"
-- @return param 如果是msg控制退出，param的值是msg的参数
-- @usage 
-- socketClient = socketCh395.tcp()
-- socketClient:connect("www.baidu.com","80")
-- result,data = socketClient:recv(60000,"APP_SOCKET_SEND_DATA")
function mt:recv(timeout, msg, msgNoResume)
    assert(self.co == coroutine.running(), "socket:recv: coroutine mismatch")
    if self.error then
        log.warn('socket.client:recv', 'error', self.error)
        return false
    end
    self.msgNoResume = msgNoResume
    if msg and not self.iSubscribe then
        self.iSubscribe = msg
        self.subMessage = function(data)
            -- if data then table.insert(self.output, data) end
            if self.wait == "+RECEIVE" and not self.msgNoResume then
                if data then
                    table.insert(self.output, data)
                end
                coroutine.resume(self.co, 0xAA)
            end
        end
        sys.subscribe(msg, self.subMessage)
    end
    if msg and #self.output > 0 then
        sys.publish(msg, false)
    end
    if #self.input == 0 then
        self.wait = "+RECEIVE"
        if timeout and timeout > 0 then
            local r, s = sys.wait(timeout)
            if r == nil then
                return false, "timeout"
            elseif r == 0xAA then
                local dat = table.concat(self.output)
                self.output = {}
                return false, msg, dat
            else
                return r, s
            end
        else
            local r, s = coroutine.yield()
            if not r and s == 'server close' then
                return false
            end
            if r == 0xAA then
                local dat = table.concat(self.output)
                self.output = {}
                return false, msg, dat
            else
                return r, s
            end
        end
    end

    if self.protocol == "UDP" then
        local s = table.remove(self.input)
        return true, s
    else
        log.warn("-------------------使用缓冲区---------------")
        local s = table.concat(self.input)
        self.input = {}
        if self.isBlock then
            table.insert(self.input, sockectCh395Recv(self.msg.socket_index, self.msg.recv_len))
        end
        return true, s
    end
end

--- 主动关闭并且销毁一个socket
-- @return nil
-- @usage
-- socketClient = socketCh395.tcp()
-- socketClient:connect("www.baidu.com","80")
-- socketClient:close()
function mt:close()
    assert(self.co == coroutine.running(), "socket:close: coroutine mismatch")
    if self.iSubscribe then
        sys.unsubscribe(self.iSubscribe, self.subMessage)
        self.iSubscribe = false
    end
    -- log.info('socketCh395', 'close' .. self.id)
    -- 此处不要再判断状态，否则在连接超时失败时，conneted状态仍然是未连接，会导致无法close
    -- if self.connected then
    log.info("socket:sock_close", self.id)
    local result, reason

    if self.id then
        sockectCh395Close(self.id)
        self.wait = "SOCKET_CLOSE"
        while true do
            result, reason = coroutine.yield()
            if not result and reason == 'server close' then
                return false
            end
            if reason == "RESPONSE" then
                break
            end
        end
    end
    if self.connected then
        self.connected = false
        if socketsConnected > 0 then
            socketsConnected = socketsConnected - 1
        end
        sys.publish("SOCKET_ACTIVE", socketsConnected > 0)
    end
    if self.input then
        self.input = {}
    end
    if self.protocol == 'TCPSERVERCLIENT' then
        sockets[self.id] = true
    else
        if self.id ~= nil then
            sockets[self.id] = nil
        end
    end

end

-- socket接收自定义控制处理
-- @function[opt=nil] rcvCbFnc，socket接收到数据后，执行的回调函数，回调函数的调用形式为：
-- rcvCbFnc(readFnc,socketIndex,rcvDataLen)
-- rcvCbFnc内部，会判断是否读取数据，如果读取，执行readFnc(socketIndex,rcvDataLen)，返回true；否则返回false或者nil
function mt:setRcvProc(rcvCbFnc)
    assert(self.co == coroutine.running(), "socket:setRcvProc: coroutine mismatch")
    self.rcvProcFnc = rcvCbFnc
end

function on_response(msg)
    local t = {
        [rtos.MSG_SOCK_CLOSE_CNF] = 'SOCKET_CLOSE',
        -- 33
        [rtos.MSG_SOCK_SEND_CNF] = 'SOCKET_SEND',
        -- 32
        [rtos.MSG_SOCK_CONN_CNF] = 'SOCKET_CONNECT'
        -- 34
    }
    if not sockets[msg.socket_index] then
        log.warn('response on nil socket', msg.socket_index, t[msg.id], msg.result)
        return
    end
    if sockets[msg.socket_index] == true then
        return
    end
    log.info(sockets[msg.socket_index].wait, t[msg.id], msg.socket_index, msg.id)
    if sockets[msg.socket_index].wait ~= t[msg.id] then
        log.warn('response on invalid wait', sockets[msg.socket_index].id, sockets[msg.socket_index].wait, t[msg.id],
            msg.socket_index)
        return
    end
    log.info('socket:on_response:', msg.socket_index, t[msg.id], msg.result)
    if sockets[msg.socket_index].protocol == 'TCPSERVERCLIENT' then 
        msg.result=0
    end
    coroutine.resume(sockets[msg.socket_index].co, msg.result == 0, 'RESPONSE')
end
sys.subscribe('SOCK_CONN_CNF', on_response)
sys.subscribe('SOCK_CLOSE_CNF', on_response)
sys.subscribe('SOCK_SEND_CNF', on_response)
-- 被动关闭
sys.subscribe('MSG_SOCK_CLOSE_IND', function(msg)
    local data = string.sub(spiSend(spi.SPI_1, string.char(0x2F, msg.socket_index, 0xff, 0xff)), 3, -1)
    log.info('socketCh395', 'close socket ' .. msg.socket_index .. 'state', data:toHex())
    if string.sub(data, 1, 1) ~= '\x00' then
        return
    end
    log.info('socket.rtos.MSG_SOCK_CLOSE_IND',msg.socket_index)
    if not sockets[msg.socket_index] then
        return

    elseif sockets[msg.socket_index] == true then
        return
    elseif sockets[msg.socket_index].protocol == 'TCPSERVERCLIENT' then
        coroutine.resume(sockets[msg.socket_index].co, false, 'CLOSED')
        sockets[msg.socket_index] = true
        return
    end
    if not sockets[msg.socket_index] then
        log.warn('close ind on nil socket', msg.socket_index, msg.id)
        return
    end

    if sockets[msg.socket_index].connected then
        sockets[msg.socket_index].connected = false
        if socketsConnected > 0 then
            socketsConnected = socketsConnected - 1
        end
        sys.publish('SOCKET_ACTIVE', socketsConnected > 0)
    end


    sockets[msg.socket_index].error = 'CLOSED'
    --[[
    if type(socketcore.sock_destroy) == "function" then
        socketcore.sock_destroy(msg.socket_index)
    end]]
    sys.publish('LIB_SOCKET_CLOSE_IND', sockets[msg.socket_index].ssl, sockets[msg.socket_index].protocol,
        sockets[msg.socket_index].address, sockets[msg.socket_index].port)
    coroutine.resume(sockets[msg.socket_index].co, false, 'CLOSED')
end)
sys.subscribe('MSG_SOCK_RECV_IND', function(msg)
    if type(sockets[msg.socket_index])~='table' then
        log.warn('close ind on nil socket', msg.socket_index, msg.id)
        return
    end
    log.debug('socket.recv', msg.recv_len, sockets[msg.socket_index].rcvProcFnc)
    if sockets[msg.socket_index].rcvProcFnc then
        sockets[msg.socket_index].rcvProcFnc(msg.recv_data)
    else
        if sockets[msg.socket_index].wait == '+RECEIVE' then
            coroutine.resume(sockets[msg.socket_index].co, true, msg.recv_data)
        else -- 数据进缓冲区，缓冲区溢出采用覆盖模式
            if #sockets[msg.socket_index].input > INDEX_MAX then
                log.error('socket recv', 'out of stack', 'block')
                -- sockets[msg.socket_index].input = {}
                sockets[msg.socket_index].isBlock = true
                sockets[msg.socket_index].msg = msg
            else
                sockets[msg.socket_index].isBlock = false

                table.insert(sockets[msg.socket_index].input, msg.recv_data)
            end
            sys.publish('SOCKET_RECV', msg.socket_index)
        end
    end
end)

-- 设置TCP层自动重传的参数
-- @number[opt=4] retryCnt 重传次数；取值范围0到12
-- @number[opt=16] retryMaxTimeout 限制每次重传允许的最大超时时间(单位秒)，取值范围1到16
-- @return nil
-- @usage
-- setTcpResendPara(3,8)
-- setTcpResendPara(4,16)
function setTcpResendPara(retryCnt, retryMaxTimeout)
    ril.request("AT+TCPUSERPARAM=6," .. (retryCnt or 4) .. ",7200," .. (retryMaxTimeout or 16))
end

-- 设置域名解析参数
-- 注意：0027以及之后的core版本才支持此功能
-- @number[opt=4] retryCnt 重传次数；取值范围1到8
-- @number[opt=4] retryTimeoutMulti 重传超时时间倍数，取值范围1到5
--                第n次重传超时时间的计算方式为：第n次的重传超时基数*retryTimeoutMulti，单位为秒
--                重传超时基数表为{1, 1, 2, 4, 4, 4, 4, 4}
--                第1次重传超时时间为：1*retryTimeoutMulti 秒
--                第2次重传超时时间为：1*retryTimeoutMulti 秒
--                第3次重传超时时间为：2*retryTimeoutMulti 秒
--                ...........................................
--                第8次重传超时时间为：8*retryTimeoutMulti 秒
-- @return nil
-- @usage
-- socket.setDnsParsePara(8,5)
function setDnsParsePara(retryCnt, retryTimeoutMulti)
    ril.request("AT*DNSTMOUT=" .. (retryCnt or 4) .. "," .. (retryTimeoutMulti or 4))
end

function setIpStatis(interval)

end

--- 打印所有socket的状态
-- @return 无
-- @usage socketCh395.printStatus()
function printStatus()
    for _, client in pairs(sockets) do
        for k, v in pairs(client) do
            log.info('socket.printStatus', 'client', client.id, k, v)
        end
    end
end

-- 设置数据传输后，允许进入休眠状态的延时时长
-- 3024版本以及之后的版本才支持此功能
-- 此功能设置的参数，设置成功后，掉电会自动保存
-- @number tm，数据传输后，允许进入休眠状态的延时时长，单位为秒，取值范围1到20
--             注意：此时间越短，允许进入休眠状态越快，功耗越低；但是在某些网络环境中，此时间越短，可能会造成数据传输不稳定
--                   建议在可以接受的功耗范围内，此值设置的越大越好
--                   如果没有设置此参数，此延时时长是和基站的配置有关，一般来说是10秒左右
-- @return nil
-- @usage
-- socketCh395.setLowPower(5)
function setLowPower(tm)
    ril.request("AT*RTIME=" .. tm)
end