G31_luatide_proj/cmd.lua

--- A simple command line arguments parser
-- The command line parser supports both long options (--foobar) and short
-- options (-f)
--
-- Strings of form '--OPTION=VALUE' are parsed to { OPTION = 'VALUE' }.
-- Strings of form '--OPTION' are parsed to { OPTION = true }.
-- Multiple '--OPTION=VALUE' are merged into { OPTION = { 'VALUE', 'VALUE', ... } }.
--
-- Strings of form '-O=VALUE' are parsed to { O = 'VALUE' }.
-- Strings of form '-O' are parsed to { O = true }.
-- Multiple '-O=VALUE' are merged into { O = { 'VALUE', 'VALUE', ... } }.
--
-- The argument '--' terminates all options; any following arguments are treated
-- as non-option arguments, even if they begin with a hyphen.
--
-- Based on the luvit-cmdline parser from https://github.com/dvv/luvit-cmdline
-- Modifications by Björn Ritzl, https://github.com/britzl/cmdline
-- @module cmdline
module(..., package.seeall)
require"sim"
require"net"
require"misc"
require "nvm"
require "funlib"
require "ntp"

--[[
	命令行数据及函数
	--历史命令行，可以通过组合按键"[+ A" 或者[+B 商贩或者下翻
	---命令行注册数据，包含命令字，help，执行函数
	--命令输出数组
	--命令上输入数组
	--命令行提示符
	--命令行tab键补充完整
	--命令行注册函数
	--命令行注销函数
	--命令行输入函数
	--命令行处理函数
]]

pm.wake("modbusrtu")

local cmd_uart_id = 1
--local uart_baud = 9600
local uart_baud = 57600

-- 设置tr_en
pmd.ldoset(2,pmd.LDO_VMMC)


local CLI_MAX_COMMANDS = 100 
local CLI_INBUF_SIZE = 256
local PROMPT = '#'
-- history 命令行使用环形缓存区存储，表示最大多少字节
local MAX_HISTORY = 256
local cli={
	inited = 0,
    num = 0,
    echo_disabled = 1,
    msg = "",
	his_idx = 1,
	his_cur = 1,
	history={},	
	cmds = {},
	cmd_in_options = {},
	outbuf = {},
}

-- 命令行输入数组
local inbuf={}
--920数据流缓存
local inbuf920 = ""
--[[
cli_register_command
功能  ：注册命令行函数
参数  ：输入cmda，命令行关键字字符串，helpa 帮助信息 funca 命令执行函数
返回值：成功为1，失败为0
]]
function cli_register_command(cmda,helpa,funca)
	if not cmda or not helpa or not funca then
		--print( "cmd",cmd,help,func)
		log.error("cmd.cli_register_command","cmda/helpa/funca not existed!")
		return 0
	end	
	local command = {key=cmda,help=helpa,func= funca}
	table.insert(cli.cmds,{key=cmda,help=helpa,func= funca})
	cli.num = cli.num +1
	return true
end

--[[
cli_register_command
功能  ：注册命令行函数
参数  cmdin，命令行输入函数
返回值：成功为1，失败为0
]]
function cli_unregister_command(cmdin)
	if not cmdin then
		log.error("cmd.cli_unregister_command","cmd is nil!")
		return 0
	end

	for i = #cli.cmds, 1, -1 do
		if cli.cmds[i].key == cmdin then
			log.debug("cmd.cli_unregister_command","find the cmd",cmdin)
			table.remove(cli.cmds,i)
			cli.num = cli.num -1
			return 1
		end
	end
	log.info("cmd.cli_unregister_command","can't find the cmd",cmdin)
	return 1

end

--向串口发送数据
local function send_uart_data(data)
	if not data then
		log.error("cmd.send_uart_data","data empty!")
		return false
	end

	--pins.setup(pio.P0_24,1)
    uart.write(cmd_uart_id,data)
    --sys.wait(50)
	--pins.setup(pio.P0_24,0)
	return true
end

--[[
厂测命令执行函数：
        
]]
--是否已发握手包
local isHandshake = false
local foundRfid = false
local foundRfidRssi = ""
local function factory_test_command(options)
	if not options then
		log.error("cmd.factory_test_command","options not existed,do nothing!")
		return false
	end
	if type(options) ~= "table" then
		log.error("cmd.factory_test_command","options type error!")
		return false
	end
	if not options.type then
		log.error("cmd.factory_test_command","options.type not existed! options:",json.encode(options))
		return false
	end
	log.info("cmd.factory_test_command","options.type=",options.type)
	local devId = nvm.get("devId")
	local devSn = nvm.get("devSn")

	--厂测握手包
	if options.type == "E7A55AE1" then
		local data = ""
		if not devId or not devSn then
			--新设备
			data = "E65AA1"
		elseif devId ~= "" and devSn ~= "" then
			--已编程设备
			data = "EC61F1"
		end
		local dataBin,errMsg = funlib.hex2bin(data)
		if not dataBin then
			log.error("cmd.factory_test_command",errMsg)
			return false
		end
		if not send_uart_data(dataBin) then
			log.error("cmd.factory_test_command","send_uart_data failed! data:",dataBin:toHex())
			return false
		end
		log.info("cmd.factory_test_command","handshake success")
		--厂测开始后，如果ntp没有完成,强制开始厂测
		if not ntp.isEnd() then
			log.warn("cmd.factory_test_command","ntp sync have not success,force start factory test!")
			sys.publish("TIMER_SYNC_SUCCESS","factory_test_start")
		end
		isHandshake = true
		return true
	end
	
	--写入设备id和序列号包
	if options.type == "E5E5A6" then
		if not isHandshake then
			log.error("cmd.factory_test_command","forbiden write devId and devSn, handshake please!")
			return false
		end
		local data = "E5E5A6"
		if not options.devId then
			log.error("cmd.factory_test_command","options.devId not existed!")
			data = "E6E6A6"
		elseif type(options.devId) ~= "string" then
			log.error("cmd.factory_test_command","options.devId type error!")
			data = "E6E6A6"
		elseif not options.devSn then
			log.error("cmd.factory_test_command","options.devSn not existed!")
			data = "E6E6A6"
		elseif type(options.devSn) ~= "string" then
			log.error("cmd.factory_test_command","options.devSn type error!")
			data = "E6E6A6"
		else
			if devId ~= options.devId then
				if not nvm.set("devId",options.devId) then
					log.error("cmd.factory_test_command","devId write failed! options.devId:",options.devId)
					data = "E6E6A6"
				else
					log.info("cmd.factory_test_command","devId:", nvm.get("devId"))
				end
			end
			if devSn ~= options.devSn then
				if not nvm.set("devSn",options.devSn) then
					log.error("cmd.factory_test_command","devSn write failed! options.devSn:",options.devSn)
					data = "E6E6A6"
				else
					log.info("cmd.factory_test_command","devSn:", nvm.get("devSn"))
				end
			end
		end
		
		local dataBin,errMsg = funlib.hex2bin(data)
		if not dataBin then
			log.error("cmd.factory_test_command",errMsg)
			return false
		end
		if not send_uart_data(dataBin) then
			log.error("cmd.factory_test_command","send_uart_data failed!")
			return false
		end
		return true
	end

	--读取设备id和序列号包
	if options.type == "E5E5A1" then
		if not isHandshake then
			log.error("cmd.factory_test_command","forbiden read devId and devSn, handshake please!")
			return false
		end
		local data = "E6E6A1"
		if not devId then
			log.error("cmd.factory_test_command","devId not existed!")
			data = "E6E6A0"
		elseif type(devId) ~= "string" then
			log.error("cmd.factory_test_command","devId type error!")
			data = "E6E6A0"
		elseif not devSn then
			log.error("cmd.factory_test_command","devSn not existed!")
			data = "E6E6A0"
		elseif type(devSn) ~= "string" then
			log.error("cmd.factory_test_command","devSn type error!")
			data = "E6E6A0"
		end
		
		local dataBin,errMsg = funlib.hex2bin(data)
		if not dataBin then
			log.error("cmd.factory_test_command",errMsg)
			return false
		end
		if data == "E6E6A1" then
			dataBin = dataBin..devId..devSn
			log.info("cmd.factory_test_command","dataBin:",dataBin:toHex())
		end
		if not send_uart_data(dataBin) then
			log.error("cmd.factory_test_command","send_uart_data failed! dataBin:",dataBin:toHex())
			return false
		end
		return true
	end
	
	--读取sim卡iccid
	if options.type == "E1E1A3" then
		if not isHandshake then
			log.error("cmd.factory_test_command","forbiden read simIccid, handshake please!")
			return false
		end
		log.info("cmd.factory_test_command","read simIccid")

		local timer
		local maxRetryCount = 40
		local retryCount = 0
		timer = sys.timerLoopStart(function ()
			local data = ""
			local simIccid = sim.getIccid()
			if simIccid then
				data = "E2E2A1"
				log.info("cmd.factory_test_command","timer:",timer,"data:",data)
				
				local dataBin,errMsg = funlib.hex2bin(data)
				if not dataBin then
					log.error("cmd.factory_test_command",errMsg)
					return false
				end
				dataBin = dataBin..simIccid.."#"
				log.info("cmd.factory_test_command","dataBin:",dataBin:toHex())
				if not send_uart_data(dataBin) then
					log.error("cmd.factory_test_command","send_uart_data failed! dataBin:",dataBin:toHex())
					return false
				end
				sys.timerStop(timer)
				return
			end

			retryCount = retryCount + 1
			log.info("cmd.factory_test_command","sim status:",sim.getStatus(),"retryCount:",retryCount)
			if retryCount >= maxRetryCount then
				log.info("cmd.factory_test_command","wait sim ready timeout")
				data = "E1E1A1"
				local dataBin,errMsg = funlib.hex2bin(data)
				if not dataBin then
					log.error("cmd.factory_test_command",errMsg)
					return false
				end
				if not send_uart_data(dataBin) then
					log.error("cmd.factory_test_command","send_uart_data failed! dataBin:",dataBin:toHex())
					return false
				end
				sys.timerStop(timer)
			end

		end, 100)
		
		return true
	end

	--读取sim卡imsi
	if options.type == "E2E2A7" then
		if not isHandshake then
			log.error("cmd.factory_test_command","forbiden read imsi, handshake please!")
			return false
		end
		
		local timer
		local maxRetryCount = 40
		local retryCount = 0
		timer = sys.timerLoopStart(function ()
			local data = ""
			local simImsi = sim.getImsi()
			if simImsi then
				simImsi = sim.getImsi()
				data = "E3E3A1"
				log.info("cmd.factory_test_command","sim ready, simImsi:",simImsi,"timer:",timer,"data:",data)
				local dataBin,errMsg = funlib.hex2bin(data)
				if not dataBin then
					log.error("cmd.factory_test_command",errMsg)
					return false
				end
				dataBin = dataBin..simImsi.."#"
				log.info("cmd.factory_test_command","dataBin:",dataBin:toHex())
				if not send_uart_data(dataBin) then
					log.error("cmd.factory_test_command","send_uart_data failed! dataBin:",dataBin:toHex())
					return false
				end
				sys.timerStop(timer)
				return
			end
			retryCount = retryCount + 1
			if retryCount >= maxRetryCount then
				log.info("cmd.factory_test_command","wait sim ready timeout")
				sys.timerStop(timer)
				data = "E3E2A1"
				local dataBin,errMsg = funlib.hex2bin(data)
				if not dataBin then
					log.error("cmd.factory_test_command",errMsg)
					return false
				end
				if not send_uart_data(dataBin) then
					log.error("cmd.factory_test_command","send_uart_data failed! dataBin:",dataBin:toHex())
					return false
				end
			end
		end, 100)
		
		return true
	end

	--获取网络rssi
	if options.type == "E9E9A5" then
		if not isHandshake then
			log.error("cmd.factory_test_command","forbiden read netRssi, handshake please!")
			return false
		end

		local timer
		local maxRetryCount = 150
		local retryCount = 0
		timer = sys.timerLoopStart(function ()
			local data = ""
			local netRssi = net.getRssi()
			if net.getNetMode() > 0 and netRssi > 0 then
				data = "E9E0A1"
				log.info("cmd.factory_test_command","net registed, netMode:",net.getNetMode(),"netRssi:",netRssi)
				local dataBin,errMsg = funlib.hex2bin(data)
				if not dataBin then
					log.error("cmd.factory_test_command",errMsg)
					return false
				end
				dataBin = dataBin..string.char(netRssi)
				log.info("cmd.factory_test_command","dataBin:",dataBin:toHex())
				if not send_uart_data(dataBin) then
					log.error("cmd.factory_test_command","send_uart_data failed! dataBin:",dataBin:toHex())
					return false
				end
				sys.timerStop(timer)
				return
			end
			retryCount = retryCount + 1
			if retryCount >= maxRetryCount then
				log.info("cmd.factory_test_command","wait net registed timeout, neRssi:",net.getRssi(),"netMode:",net.getNetMode())
				data = "E9E0A0"
				local dataBin,errMsg = funlib.hex2bin(data)
				if not dataBin then
					log.error("cmd.factory_test_command",errMsg)
					return false
				end
				if not send_uart_data(dataBin) then
					log.error("cmd.factory_test_command","send_uart_data failed! dataBin:",dataBin:toHex())
					return false
				end
				sys.timerStop(timer)
			end
		end, 100)
		return true
	end

	--写入设备型号
	if options.type == "E3E3A6" then
		if not isHandshake then
			log.error("cmd.factory_test_command","forbiden write devId and devSn, handshake please!")
			return false
		end
		local data = "E3E0A1"
		local devModel = nvm.get("devModel")
		if not options.devModel then
			log.error("cmd.factory_test_command","options.devModel not existed!")
			data = "E3E2A0"
		elseif type(options.devModel) ~= "string" then
			log.error("cmd.factory_test_command","options.devModel type error!")
			data = "E3E2A0"
		else
			if devModel ~= options.devModel then
				if not nvm.set("devModel",options.devModel) then
					log.error("cmd.factory_test_command","devId write failed! options.devModel:",options.devModel)
					data = "E3E2A0"
				else
					log.info("cmd.factory_test_command","devModel:", nvm.get("devModel"))
				end
			end
		end
		
		local dataBin,errMsg = funlib.hex2bin(data)
		if not dataBin then
			log.error("cmd.factory_test_command",errMsg)
			return false
		end
		if data == "E3E0A1" then
			dataBin = dataBin..options.devModel
		end
		log.info("cmd.factory_test_command","--------> ",dataBin:toHex())
		if not send_uart_data(dataBin) then
			log.error("cmd.factory_test_command","send_uart_data failed!")
			return false
		end
		return true
	end

	--获取模块imei号
	if options.type == "E4E4A6" then
		if not isHandshake then
			log.error("cmd.factory_test_command","forbiden read iccid, handshake please!")
			return false
		end
		local data = "E4E0A1"
		local moduleImei = misc.getImei()
		if not moduleImei then
			log.error("cmd.factory_test_command","moduleImei not existed!")
			data = "E4E2A0"
		end
		
		local dataBin,errMsg = funlib.hex2bin(data)
		if not dataBin then
			log.error("cmd.factory_test_command",errMsg)
			return false
		end
		if data == "E4E0A1" then
			dataBin = dataBin..moduleImei
			log.info("cmd.factory_test_command","dataBin:",dataBin:toHex())
		end
		if not send_uart_data(dataBin) then
			log.error("cmd.factory_test_command","send_uart_data failed! dataBin:",dataBin:toHex())
			return false
		end
		return true
	end

	--获取指定rifd标签的信号
	if options.type == "E8E8A2" then
		if not isHandshake then
			log.error("cmd.factory_test_command","forbiden read rfid, handshake please!")
			return false
		end
		local data = "E8E3A1"
		if not options.rfid then
			log.error("cmd.factory_test_command","options.rfid not existed!")
			data = "E8E0A0"
		end
		if #options.rfid ~= 8 then
			log.error("cmd.factory_test_command","options.rfid length != 8!")
			data = "E8E0A0"
		end
		
		--通知开始读取指定的rfid标签信号
		sys.publish("factory_test_start_read_rfid",{rfid=options.rfid})

		--等待读取结果
		local timer
		local maxRetryCount = 150
		local retryCount = 0
		timer = sys.timerLoopStart(function ()
			if foundRfid then
				data = "E8E3A1"
				log.info("cmd.factory_test_command","stop timer loop, rfid.rssi:",foundRfidRssi,"rfid:",options.rfid)
				local dataBin,errMsg = funlib.hex2bin(data)
				if not dataBin then
					log.error("cmd.factory_test_command",errMsg)
					foundRfid = false
					foundRfidRssi = ""
					return false
				end
				dataBin = dataBin..string.char(foundRfidRssi)
				log.info("cmd.factory_test_command","dataBin:",dataBin:toHex())
				--初始化参数
				foundRfid = false
				foundRfidRssi = ""
				if not send_uart_data(dataBin) then
					log.error("cmd.factory_test_command","send_uart_data failed! dataBin:",dataBin:toHex())
					return false
				end
				sys.timerStop(timer)
				return
			end
			retryCount = retryCount + 1
			if retryCount >= maxRetryCount then
				log.info("cmd.factory_test_command","wait read rifd timeout,stop timer loop!")
				data = "E8E0A0"
				local dataBin,errMsg = funlib.hex2bin(data)
				if not dataBin then
					log.error("cmd.factory_test_command",errMsg)
					foundRfid = false
					foundRfidRssi = ""
					return false
				end
				--初始化参数
				foundRfid = false
				foundRfidRssi = ""
				if not send_uart_data(dataBin) then
					log.error("cmd.factory_test_command","send_uart_data failed! dataBin:",dataBin:toHex())
					return false
				end
				sys.timerStop(timer)
			end
		end, 100)

		return true
	end

end

cli_register_command("factory","factory test command\r\nUsage: factory --type=xxxx [--devId=630001] [--devSn=xxxxx] [--rfid=xxxx]",factory_test_command)

local isTaskEnd = true
local cmdFoundRfid = false
local cmdFoundRfidRssi = ""
local function cmd_command(options)
	if not options then
		log.error("cmd.cmd_command","options not existed,do nothing!")
		return false
	end
	if type(options) ~= "table" then
		log.error("cmd.cmd_command","options type error!")
		return false
	end
	if not options.type then
		log.error("cmd.cmd_command","options.type not existed! options:",json.encode(options))
		return false
	end
	log.info("cmd.cmd_command","options.type=",options.type)
	--获取指定rifd标签的信号
	if options.type == "read_rfid" then
		local data = ""
		if not options.rfid then
			log.error("cmd.cmd_command","options.rfid not existed!")
			return false
		end
		
		--通知开始读取指定的rfid标签信号
		sys.publish("cmd_start_read_rfid",{rfid=options.rfid})

		--等待读取结果
		local timer
		local maxRetryCount = 150
		local retryCount = 0
		timer = sys.timerLoopStart(function ()
			if cmdFoundRfid then
				data = "rfid:"..options.rfid..", rfid.rssi:"..cmdFoundRfidRssi.."\r\n"
				log.info("cmd.cmd_command","stop timer loop, rfid.rssi:",cmdFoundRfidRssi,"rfid:",options.rfid)
				--初始化参数
				cmdFoundRfid = false
				cmdFoundRfidRssi = ""
				if not send_uart_data(data) then
					log.error("cmd.cmd_command","send_uart_data failed! data:",data)
					return false
				end
				sys.timerStop(timer)
				return
			end
			retryCount = retryCount + 1
			if retryCount >= maxRetryCount then
				log.info("cmd.cmd_command","wait read rifd timeout,stop timer loop!")
				data = "wait read rifd timeout,stop timer loop!\r\n"
				--初始化参数
				cmdFoundRfid = false
				cmdFoundRfidRssi = ""
				if not send_uart_data(data) then
					log.error("cmd.cmd_command","send_uart_data failed! data:",data)
					return false
				end
				sys.timerStop(timer)
			end
		end, 100)

		return true
	end
end
cli_register_command("cmd","cmd command\r\nUsage: cmd --type=xxxx [--rfid=xxxx]",cmd_command)

--[[
测试函数：
        注册函数和注销函数
]]

--[[
--注册函数测试
function dis_systime()
	print("2021-3-26:19:27")
end
function dis_ver()
	print("1.0.0")
end
log.debug(#cli.cmds)
cli_register_command("version","device version",dis_ver)
log.debug(#cli.cmds)
cli_register_command("systime","display system time",dis_systime)
log.debug(#cli.cmds)	

for i = #cli.cmds, 1, -1 do
	print(cli.cmds[i].func())
    if cli.cmds[i].key == "systime" then
		--print("find systime cmd")
		--print(cmds[i].func())
       
    end
	if cli.cmds[i].key == "version" then
		--print("find version")
		--print(cmds[i].func())
	end
	
end

--注销函数测试
table.remove(cmds, 1)
cli_unregister_command("systime")
print(#cli.cmds)
table.remove(cmds, 1)
cli_unregister_command("version")
print(#cli.cmds)
]]

--补齐命令行---
--[[
	cli_tab_complete
	功能  补齐命令行
	参数  无
	返回值：0 失败 1 成功
]]
local function cli_tab_complete(input)
    local n =1
	local  m=0
    local fm = ""
    local instring = ""
	local bp1 = #inbuf
	
    print("\r\n");
    if type(input) ~= 'table' or input == nil then
		log.error("cmd.cli_tab_complete","input is not table or nil")
		return 0
	end
	instring = table.concat(input,nil)
	log.debug("cmd.cli_tab_complete","input string: ",instring,"cli num "..cli.num)
    --show matching commands
	for i=1,CLI_MAX_COMMANDS do
		if  n <= cli.num then
			if cli.cmds[i].key ~= nil then
				--log.debug("key: "..cli.cmds[i].key,"in: "..instring)
				if string.sub(cli.cmds[i].key,1,bp1)== instring then
					m = m+1
					if m == 1 then
						fm = cli.cmds[i].key;
					elseif m == 2 then
						print("%s"..fm," %s"..cli.cmds[i].key)
					else
						print("%s "..cli.cmds[i].key)
					end
				end
				n = n+1
			end
		end
    end
    
	--log.debug("fefkj",fm)
    --there's only one match, so complete the line
    if m == 1 and  fm then	
		bp1 = bp1+1
		local cmd_len = string.len(fm)
		local concat_fm = string.sub(fm,bp1,-1)		
		--log.debug("fm : "..fm,"concat "..concat_fm, "len "..cmd_len,"bp "..bp1)
        if cmd_len< CLI_INBUF_SIZE then			
			table.insert(inbuf,bp1,concat_fm)
			table.insert(inbuf," \0")
			--log.debug("inbuf "..table.concat(inbuf,nil))
         end
    end
   if m >= 2 then
       printf("\r\n");
   end
   
    --just redraw input line
    print(PROMPT..table.concat(inbuf,nil))
	return 1
end

---测试函数 test complete
-- inbuf ={'v','e'}
-- cli_tab_complete(inbuf)
-- inbuf ={'s','y','s'}
-- cli_tab_complete(inbuf)


--[[
cli_get_input
功能  ：接收串口命令行数据
参数  c 输入字符
返回值：成功为1，失败为0，\r\n 收到为2，表示命令行输入结束
]]

--输入字符当前位置
local bp = 1
--输入转义字符
local esc,key1,key2=0

local function cli_get_input(c)	
	if c == '\n' or  c == '\r' then
		-- get whole commands,so process it later
		--inbuf[bp] = '\0'
		--cli.msg = table.concat(inbuf,nil)
		local cmd_str = table.concat(inbuf)
		if string.find(cmd_str,"\r\n") then
			bp = 1
			key1 = 0
			key2 = 0
			esc = 0		
			return 2
		end
		
     end
	-- escape char
     if c == 0x1b then 
		esc  = 1;
		key1 = -1;
		key2 = -1;
		return 1;
    end

	if esc== 1 then 
		if key1 < 0 then
			key1 = c
			--* not '['
			if key1 ~= 0x5b then					 
				inbuf[bp] = 0x1b
				bp = bp+1
				inbuf[bp] = key1;
				bp = bp+1

				if cli.echo_disabled ~= 0 then 
					--    tmp = g_cli_tag_len;
					--    g_cli_tag_len = 0;
					print(string.format("\x1b%c", key1))
				end

				esc = 0;
			end
			return 1;
		end

		if key2 < 0 then  
			key2 = c;
	
		end

		if key2 ~= 0x41  and key2 ~= 0x42 and  key2 ~= 't'  then 
			inbuf[bp] = 0x1b
			bp = bp+1
			inbuf[bp] = key1
			bp = bp+1
			inbuf[bp] = key2
			bp = bp+1
			esc           = 0
			print(string.format("\x1b%c",key1, key2))
			return 1
		end

		if key2 == 0x41 then 
			log.debug("cli up history")	
			bp           = #inbuf;	
			esc           = 0

			print("\r\n#"..table.concat(inbuf))
			return 1;
		end

		if key2 == 0x42  then 
			log.debug("cli_down_history---")
			bp  = #inbuf
			esc           = 0;
			print("\r\n#"..table.concat(inbuf))
			return 1
		end		
	end

	inbuf[bp] = c;
	if c == 0x08  or c == 0x7f then
		if bp > 1 then 
			bp = bp-1
			if (cli.echo_disabled ~= 1) then
			-- 删除键
			print(string.format("%0x %0x", 0x08, 0x08))	
			end
		end
		return 1
	end

	if c == '\t'  then 
		inbuf[bp] = '\0';
		log.debug("cli_tab_complte ")
		cli_tab_complete(inbuf, bp);
		return 1
	end

	if cli.echo_disabled ~= 1 then
	print(c)
	end

	bp = bp +1
	if bp >= 256  then 
		log.error("Error: input buffer overflow\r\n");	
		print("#")
		bp = 0
		return 0
	end	   
end

--[[
	输入测试函数
]]
-- cli_get_input('a')
-- cli_get_input('A')
-- cli_get_input('c')
-- cli_get_input(0x1b)
-- cli_get_input(0x5b)
-- cli_get_input(0x41)
-- --cli_get_input(' ')
-- cli_get_input('d')
-- cli_get_input('\t')
-- cli_get_input('d')
-- cli_get_input(0x1b)
-- cli_get_input(0x5b)
-- cli_get_input(0x42)
-- cli_get_input('f')
-- cli_get_input('\r')
-- print(cli.msg)
-- print(string.len(cli.msg))

--[[
	cli_history_input
	功能  历史命令存入函数
	参数  无
	返回值：成功为1，失败为0，\r 或者\n 收到为2，表示命令行输入结束
]]

local function cli_history_input()
    local his_inbuf    = inbuf
    local  charnum  = #inbuf
    local  his_cur  = cli.his_cur
    local left_num = MAX_HISTORY - his_cur+1
    local    lastchar = '\0'
    local tmp_idx	
	
	if charnum >MAX_HISTORY then
		log.error("cmd.cli_history_input","cmd.cli_history_input","cli too long :",charnum,"> "..MAX_HISTORY)
		return 0
	end
    cli.his_idx = his_cur
	log.debug("cmd.cli_history_input","his-cur ",his_cur,"input =",#inbuf,"left_num:",left_num,"charnum:",charnum)	
    if left_num >= charnum then 
        tmp_idx  = his_cur + charnum-1		
		local j = 1
		for i=his_cur,tmp_idx do
			cli.history[i] = inbuf[j]
			--log.debug("cmd.cli_history_input",cli.history[i])
			j = j+1
		end
		 lastchar = cli.history[tmp_idx]
        --table.insert(cli.history, his_cur, inbuf)
		log.debug("history count:",#cli.history,"fist char:",cli.history[1],"last char:",lastchar,"tmp_idx:",tmp_idx)
    else
        tmp_idx  = (his_cur + charnum-1) % MAX_HISTORY       
		local j = 1
		for i=his_cur,left_num+his_cur-1 do
			cli.history[i] = inbuf[j]
			--log.debug("cmd.cli_history_input",cli.history[i])
			j = j+1
		end		
        --strncpy(&(g_cli->history[his_cur]), inbuf, left_num);
		print(" first time :his_cur",his_cur,"finished char: ",left_num,"unfinished:",(charnum-left_num),"last char:",lastchar,"last_idx:",tmp_idx)
		--local j = left_num+1
		for i=1,charnum-left_num do
			cli.history[i] = inbuf[j]
			--log.debug("cmd.cli_history_input",cli.history[i])
			j = j+1
		end
		lastchar = cli.history[tmp_idx];
		print("second time::his_cur ",tmp_idx,"finished char: ",(charnum-left_num),"unfinished: 0","last char:",lastchar,"last_idx:",tmp_idx)
        --strncpy(&(g_cli->history[0]), inbuf + left_num, charnum - left_num);
    end
    tmp_idx = (tmp_idx+1) % MAX_HISTORY;

    cli.his_cur = tmp_idx;

    --overwrite
    if '\0' ~= lastchar then
        while cli.history[tmp_idx] ~= '\0'
		do
            cli.history[tmp_idx] = '\0';

            tmp_idx = (tmp_idx + 1) % MAX_HISTORY;
        end
    end
	return 1
end



--[[
	历史命令行测试函数
]]
--cli.his_cur =1
---为了测试需要
-- MAX_HISTORY = 19
-- inbuf ={'a','b','c','d','e','f','\0'}
-- cli_history_input()
-- log.debug("history content: "..table.concat(cli.history,nil))
-- inbuf ={'1','2','3','4','5','6','7','8','9','a','b','\0'}
-- cli_history_input()
-- log.debug("history content: "..table.concat(cli.history,nil))
-- inbuf ={'b','p','m','f','\0'}
-- cli_history_input()
-- log.debug("history content: "..table.concat(cli.history,nil))

--local inaddr = {}

--[[
	函数名：cli_history_input
	功能  上翻命令行
	参数  无
	返回值：无
]]

local function cli_up_history()
    local index
    local lastindex = 0
	local history_max_used = #cli.history

	local inaddr = {}	
    lastindex = cli.his_idx;
    index = (cli.his_idx - 1 + history_max_used) % (history_max_used+1);
	log.debug("u1:lastindex: "..lastindex,"index: "..index,"max_used: "..history_max_used)

    while cli.history[index] == '\0' and index ~= cli.his_idx 
		do
        index = (index - 1 + history_max_used) % history_max_used;
    	end
	log.debug("u2:lastindex: "..lastindex,"index: "..index)
    if index ~= cli.his_idx then
        while (cli.history[index] ~= '\0') 
			do
            	index = (index - 1 + MAX_HISTORY) % MAX_HISTORY;
        	end
		log.debug("u3:lastindex: "..lastindex,"index: "..index)
        index = (index+1) % history_max_used;
    end
    cli.his_idx = index;
	
	local i=1
    while cli.history[lastindex] ~= '\0'
		do
         inaddr[i] = cli.history[lastindex];
		 i= i+1
        lastindex = (lastindex + 1) % MAX_HISTORY;		
    	end
	log.debug("u4:lastindex: "..lastindex,"index: "..index)
    inaddr[i] = '\0';
	inbuf = inaddr;
end
--[[
	测试函数
]]
-- cli_up_history()
-- print("history up cmd: "..table.concat(inbuf,nil))
-- --inaddr = {}
-- cli_up_history()
-- print("history up cmd: "..table.concat(inbuf,nil))
-- --inaddr = {}
-- cli_up_history()
-- print("history up cmd: "..table.concat(inbuf,nil))
-- --inaddr = {}
-- cli_up_history()
-- print("history up cmd: "..table.concat(inbuf,nil))

--[[
	cli_down_history
	功能  下翻命令行
	参数  无
	返回值：无
]]
function  cli_down_history()

	local index
    local lastindex = 0

    lastindex = cli.his_idx;
    index     = cli.his_idx;
	local inaddr = {}
	
	local history_max_used = #cli.history
	log.debug("d0:lastindex: "..lastindex,"index: "..index)
    while cli.history[index] ~= '\0'
		do
        	index = (index + 1) % (history_max_used +1)
    	end
	log.debug("d1:lastindex: "..lastindex,"index: "..index)
    if index ~= cli.his_idx then
		   while cli.history[index] == '\0'
			do
            	index = (index + 1) % history_max_used;
			end
		log.debug("d2:lastindex: "..lastindex,"index: "..index)
    end
    cli.his_idx = index;
    local i = 1
    while cli.history[lastindex] ~= '\0'		
		do		
        inaddr[i] = cli.history[lastindex]
		i= i+1
        lastindex = (lastindex + 1) % (history_max_used+1);
    	end
     log.debug("d3:lastindex: "..lastindex,"index: "..index)
    inaddr[i] = '\0'
	inbuf = inaddr
    return
end

--[[
	下翻测试函数
]]
-- cli_down_history()
-- print("history down cmd: "..table.concat(inbuf,nil))
-- cli_down_history()
-- print("history down cmd: "..table.concat(inbuf,nil))
-- cli_down_history()
-- print("history down cmd: "..table.concat(inbuf,nil))

--[[
	Parse command line arguments string,解析命令行
	@param argv Command line arguments to parse
	@return options Options (ie anything)，表示参数，如serverip=192.168.1.1，等号两边不能有空格
	@return args Arguments，表示命令行关键字，如network
]] 
function parse(argv)
	local options = { }
	local arguments = { }
	if not argv then
		return options, arguments
	end
	for i,arg in ipairs(argv) do
		local long_opt = arg:match("^%-%-(.*)")
		local short_opt = arg:match("^%-(.*)")
		if long_opt or short_opt then
			log.info("cmd.parse","long_opt:",long_opt,"short_opt:",short_opt)
			local key, value
			if long_opt then
				key, value = long_opt:match("([a-zA-Z_%-]*)=(.*)")
			else
				key, value = short_opt:match("([a-zA-Z])=(.*)")
			end
			key = key or long_opt or short_opt
			log.info("cmd.parse","key:",key,"value:",value)
			key = key:gsub("\r\n", "")
			value = value:gsub("\r\n", "")
			if value then
				-- option seen once? transform option to array of values
				if type(options[key]) == 'string' then
					options[key] = { options[key], value }
				-- options seen many times? append value
				elseif type(options[key]) == 'table' then
					table.insert(options[key], value)
				-- options was not seen. assign value
				else
					options[key] = value
				end
			-- no value provided. just set option to true
			elseif key and key ~= "" then
				options[key] = true
			-- options stop. copy left arguments
			elseif long_opt then
				for i = i + 1, #argv do
					table.insert(arguments, argv[i])
				end
				break
			end
		else
			table.insert(arguments, arg)
		end
	end
	return options, arguments
end
--[[
	测试函数
]]
-- local options={}
-- local arguments = {}
-- local cmd_str = string.split("config --serverip=192.168.1.1", ' ')
-- options, arguments =parse(cmd_str)
--  log.info("main.cmd", "options:", json.encode(options), "arguments:", json.encode(arguments))


--[[
	lookup_command
	功能  命令行关键字查找命令行
	参数  无
	返回值：0 失败 命令行内容 成功
]]

local function lookup_command(key_name)
    local i = 1
    local n = 0
	local len = string.len(key_name)

    while i <= CLI_MAX_COMMANDS and  n < cli.num 
		do
			if cli.cmds[i].key ~= nil then				
				--See if partial or full match is expected
				if len ~= 0 then 
					if string.sub(cli.cmds[i].key, 1, len) ==key_name then
					    log.debug("cmd.lookup_command","find  cmd :"..cli.cmds[i].key)
						return cli.cmds[i]
					end
				end	
			end					
        i = i+1  
		n = n+1
    end

    return nil
end

--[[
	命令行补齐函数测试
]]

local cmd_tmp = {}
local function dis_server_info()
	log.debug("server_info cmd callback")
	if cli.cmd_in_options ~= nil then
		log.info("cmd.lookup_command","options",json.encode(cli.cmd_in_options))
		cli.outbuf = "cmd dis_server_info finished"
	end
end
-- cli_register_command("config","config server info ",dis_server_info)
-- cmd_tmp = lookup_command("confi")


--[[
	proc_onecmd
	功能  命令行处理函数
	参数  cmd，一条命令行字符数组
	返回值：0 失败 1 成功
]]
local function cli_proc_onecmd(cmd)
  
	local cmd_key ={}
	local options = {}
	local command = {}

	if cmd == nil then 
		log.error("cmd.cli_proc_onecmd", " invalid cmd")
		return 0
	end
	
    cli.cmd_in_options,cmd_key= parse(string.split(cmd,' '))
	if cmd_key == nil then
		log.error("cmd.cli_proc_onecmd", "cmd is not found")
		print("bad command!")
		return 0
	end
	options = cli.cmd_in_options
	log.info("cmd.cli_proc_onecmd", "options:", json.encode(options), "cmd key:", json.encode(cmd_key))
    command = lookup_command(table.concat(cmd_key,nil))
    if command == nil then return 0 end   
	log.info("cmd.cli_proc_onecmd", "found cmd: "..command.key)
    command.func(options)
    print(cli.outbuf)
   	cli.outbuf = ""
    return 1
end

--[[
	命令行测试函数
]]
-- local cmds = "config --serverip=192.168.1.1"
-- cli_proc_onecmd(cmds)

-- --命令行打印函数
-- cli_print(cmd_output)

-- if cmd_output ~= "" then 
-- 	   pins.setup(pio.P0_24,1)
--     uart.write(cmd_uart_id,cmd_output)
--     sys.wait(10)
--     pins.setup(pio.P0_24,0)
-- end

-- 命令行处理完后处理变量
local function cli_pro_after_process()
	inbuf ={}
	cli.outbuf = ""
	bp = 1	
	esc = 0
	key1 = 0
	key2=0
	inbuf920 = ""
end

--注册串口的数据发送通知函数
uart.on(cmd_uart_id,"receive",function() sys.publish("CMD_UART_RECEIVE") end)
--配置并且打开串口
--uart.setup(cmd_uart_id,uart_baud,8,uart.PAR_NONE,uart.STOP_1)
uart.setup(cmd_uart_id,uart_baud,8,uart.PAR_NONE,uart.STOP_1,nil,1) --必须先使用setup，并且最后一个参数是1（打开发送完成后的通知功能）
uart.set_rs485_oe(cmd_uart_id, pio.P0_24)

--[[
--测试网络注册模式和信号强度关系
local timer
local retryCount = 0
timer = sys.timerLoopStart(function ()
	log.info("cmd.factory_test_command","-------> neRssi:",net.getRssi(),"netMode:",net.getNetMode())
	send_uart_data("-------> neRssi:"..net.getRssi()..", netMode:"..net.getNetMode().."\r\n")
	retryCount = retryCount + 1
	if retryCount >= 100 then
		log.info("cmd.factory_test_command","-------> retry timeout")
		send_uart_data("-------> retry timeout\r\n")
		sys.timerStop(timer)
	end
end, 100)
]]
--通知上位机开始厂测
sys.taskInit(function()
	local result,data = sys.waitUntil("SIM_IND", 5000)
	if not result then
		log.warn("cmd.factory_test_notify","wait SIM_IND timeout!")
	else
		log.warn("cmd.factory_test_notify","receive SIM_IND message")
	end
	local result2,data2 = sys.waitUntil("TIMER_SYNC_SUCCESS", 5000)
	if not result2 then
		log.warn("cmd.factory_test_notify","wait TIMER_SYNC_SUCCESS timeout!")
	else
		log.info("cmd.factory_test_notify","receive TIMER_SYNC_SUCCESS message")
	end
	send_uart_data("startup success")
end)

--读取指定rfid号的标签信号成功时
sys.subscribe("factory_test_read_rfid_success", function(rfid)
	if rfid and type(rfid) == "table" then
		if rfid.rssi >= 0 then
			foundRfid = true
			foundRfidRssi = rfid.rssi
			log.info("cmd.factory_test_command.factory_test_read_rfid_success","read rfid success, rfid.rssi:",rfid.rssi,",rfid.rfid:",rfid.rfid)
			--发送厂测停止读标签消息通知
			sys.publish("factory_test_stop_read_rfid")
			--[[
			sys.unsubscribe("factory_test_read_rfid_success",function ()
				log.info("cmd.factory_test_command.factory_test_read_rfid_success","unsubscribe factory_test_read_rfid_success")
			end)
			]]
		else
			log.error("cmd.factory_test_command.factory_test_read_rfid_success","rfid.rssi invalid! rfid.rssi:",rfid.rssi)
		end
	else
		log.error("cmd.factory_test_command.factory_test_read_rfid_success","rfid invalid!")
	end
end)

--读取指定rfid号的标签信号成功时
sys.subscribe("cmd_read_rfid_success", function(rfid)
	if rfid and type(rfid) == "table" then
		if rfid.rssi >= 0 then
			cmdFoundRfid = true
			cmdFoundRfidRssi = rfid.rssi
			log.info("cmd.cmd_command.cmd_read_rfid_success","read rfid success, rfid.rssi:",rfid.rssi,",rfid.rfid:",rfid.rfid)
			--发送厂测停止读标签消息通知
			sys.publish("cmd_stop_read_rfid")
		else
			log.error("cmd.cmd_command.cmd_read_rfid_success","rfid.rssi invalid! rfid.rssi:",rfid.rssi)
		end
	else
		log.error("cmd.cmd_command.cmd_read_rfid_success","rfid invalid!")
	end
end)

-- 返回值： false--不是有效的920数据，不做任何处理  true--有效的920数据，处理后清空inbuf缓存
local function process_920_data()
	if #inbuf920 <= 4 then
		return false
	end
	
	--log.info("cmd.process_920_data",inbuf920:toHex())
	local is_process = false
	--读到920 rfid数据时
	--local res,pos = string.find(inbuf920:toHex(),"1100EE00")
	local res,pos = string.find(inbuf920,string.char(0x0b)..string.char(0x00)..string.char(0xEE)..string.char(0x00))
	if res and #inbuf920 >= pos+8 then
		log.info("cmd.process_920_data","920 rfid data:",inbuf920:toHex(),inbuf920:sub(pos-3,pos+8):toHex())
		sys.publish("receive_920_data", inbuf920:sub(pos-3,pos+8))
		--cli_pro_after_process()
		is_process =  true
	end
	--收到读写器设备信息应答时：0D 00 21 00 03 3F 09 03 3D 3D 1E 0A DA F6
	local res1,pos1 = string.find(inbuf920,string.char(0x0d)..string.char(0x00)..string.char(0x21)..string.char(0x00))
	if res1 and #inbuf920 >= pos1+10 then
		log.info("cmd.process_920_data","920 device data:",inbuf920:toHex(),inbuf920:sub(pos1-3,pos1+10):toHex())
		sys.publish("receive_920_device_info", inbuf920:sub(pos1-3,pos1+10))
		--cli_pro_after_process()
		is_process =  true
	end
	if is_process then
		cli_pro_after_process()
		return true
	end
	return false
end
local function process_data(char)
	local cmd_str = table.concat(inbuf) 
	local last_char = char
	inbuf920 = inbuf920..char
	--如果是920数据就处理，如果不是，按命令行指令处理
	if not process_920_data()  then
		if #inbuf > 1024 then                    
			log.info("cmd.process_data","#inbuf > 1024, drop it!! inbuf:",cmd_str:toHex())
			cli_pro_after_process()
		else 
			if last_char == "" and #inbuf > 0 then
				last_char = cmd_str:sub(-1)
			end
			if last_char ~= "" then
				result = cli_get_input(last_char)
				if 2 ==result then
					log.debug("cmd.process_data","get the cmd and put it in history,#inbuf=",#inbuf,"last_char:toHex():",last_char:toHex())
					cli_history_input()
					log.debug("cmd.process_data","------>cmd_str:",cmd_str:toHex())
					cli_proc_onecmd(cmd_str)
					cli_pro_after_process()
				elseif  0== result  then
					log.debug("cmd.process_data", "get the cmd error")
					cli_pro_after_process()
				else
					-- 1 go on get the cmd
				end
			end
		end
	end
end

--启动串口数据接收任务
-- 串口处理函数
local function cmdTaskRead()
    local char = ''
    local count = 0
	local  result = 0
	--sys.wait(10000)
    while true do
		char = uart.read(cmd_uart_id,1)
        if char == "" then
			local wait_ms = 35000/uart_baud
			if wait_ms < 1 then
				wait_ms = 1
			end
			if not sys.waitUntil("CMD_UART_RECEIVE",wait_ms) then
                -- 3.5个字符的时间间隔，只是用在RTU模式下面，因为RTU模式没有开始符和结束符，
                -- 两个数据包之间只能靠时间间隔来区分，Modbus定义在不同的波特率下，间隔时间是不一样的，
                -- 所以就是3.5个字符的时间，波特率高，这个时间间隔就小，波特率低，这个时间间隔相应就大
                -- 4800  = 7.297ms
                -- 9600  = 3.646ms
                -- 19200  = 1.771ms
                -- 38400  = 0.885ms
                --uart接收数据，如果 35000/uart_baud 毫秒没有收到数据，则打印出来所有已收到的数据，清空数据缓冲区，等待下次数据接收
                --注意：
                --因为在整个GSM模块软件系统中，软件定时器的精确性无法保证，例如本demo配置的是100毫秒，在系统繁忙时，实际延时可能远远超过100毫秒，达到200毫秒、300毫秒、400毫秒等
				--设置的延时时间越短，误差越大
				process_data(char)         
			end
        else
			process_data(char)           
        end
    end
end
--启动串口数据接收任务
sys.taskInit(cmdTaskRead)

--定时读取读写器信息
sys.taskInit(function()
    if not sys.waitUntil("TIMER_SYNC_SUCCESS", 600*1000) then
        log.error("cmd.send_920_read_cmd","wait timer sync timeout,reboot now ...")
        sys.restart("[send_920_read_cmd]wait timer sync timeout")
	end
	--等几分钟再使用484口发数据，以免影响厂测程序
	sys.wait(240*1000)
    while true do
		local read_cmd = string.char(0x04)..string.char(0x00)..string.char(0x21)
		local res, CRC = funlib.get920Crc16(read_cmd)
		if not res then
			log.error("cmd.send_920_read_cmd", "get920Crc16 failed!!",read_cmd:toHex())
			return false
		end

		local read_cmd_hex = read_cmd:toHex()..string.format("%04X",CRC)
		log.info("cmd.send_920_read_cmd", "send 920 read cmd hex:",read_cmd_hex)

		local read_cmd_bin = funlib.hex2str(read_cmd_hex)
		send_uart_data(read_cmd_bin)

        sys.wait(120*1000)
    end
end)