- work_name
	- main.lua
	- app.lua
	- ...

--必须在这个位置定义PROJECT和VERSION变量
--PROJECT：ascii string类型，可以随便定义，只要不使用,就行
--VERSION：ascii string类型，如果使用Luat物联云平台固件升级的功能，必须按照"X.X.X"定义，X表示1位数字；否则可随便定义
PROJECT = "ADC"
VERSION = "1.0.0"

--加载日志功能模块，并且设置日志输出等级
--如果关闭调用log模块接口输出的日志，等级设置为log.LOG_SILENT即可
require "log"
LOG_LEVEL = log.LOGLEVEL_TRACE
--[[
如果使用UART输出日志，打开这行注释的代码"--log.openTrace(true,1,115200)"即可，根据自己的需求修改此接口的参数
如果要彻底关闭脚本中的输出日志（包括调用log模块接口和Lua标准print接口输出的日志），执行log.openTrace(false,第二个参数跟调用openTrace接口打开日志的第二个参数相同)，例如：
1、没有调用过sys.opntrace配置日志输出端口或者最后一次是调用log.openTrace(true,nil,921600)配置日志输出端口，此时要关闭输出日志，直接调用log.openTrace(false)即可
2、最后一次是调用log.openTrace(true,1,115200)配置日志输出端口，此时要关闭输出日志，直接调用log.openTrace(false,1)即可
]]
--log.openTrace(true,1,115200)

require "sys"

require "net"
--每1分钟查询一次GSM信号强度
--每1分钟查询一次基站信息
net.startQueryAll(60000, 60000)

--此处关闭RNDIS网卡功能
--否则，模块通过USB连接电脑后，会在电脑的网络适配器中枚举一个RNDIS网卡，电脑默认使用此网卡上网，导致模块使用的sim卡流量流失
--如果项目中需要打开此功能，把ril.request("AT+RNDISCALL=0,1")修改为ril.request("AT+RNDISCALL=1,1")即可
--注意：core固件：V0030以及之后的版本、V3028以及之后的版本，才以稳定地支持此功能
ril.request("AT+RNDISCALL=0,1")

--加载控制台调试功能模块（此处代码配置的是uart1，波特率115200）
--此功能模块不是必须的，根据项目需求决定是否加载
--使用时注意：控制台使用的uart不要和其他功能使用的uart冲突
--使用说明参考demo/console下的《console功能使用说明.docx》
--require "console"
--console.setup(1, 115200)

--加载硬件看门狗功能模块
--根据自己的硬件配置决定：1、是否加载此功能模块；2、配置Luat模块复位单片机引脚和互相喂狗引脚
--合宙官方出售的Air201开发板上有硬件看门狗，所以使用官方Air201开发板时，必须加载此功能模块
--[[
require "wdt"
wdt.setup(pio.P0_30, pio.P0_31)
]]

--加载网络指示灯和LTE指示灯功能模块
--根据自己的项目需求和硬件配置决定：1、是否加载此功能模块；2、配置指示灯引脚
--合宙官方出售的Air720U开发板上的网络指示灯引脚为pio.P0_1，LTE指示灯引脚为pio.P0_4
require "netLed"
pmd.ldoset(2,pmd.LDO_VLCD)
netLed.setup(true,pio.P0_1,pio.P0_4)
--网络指示灯功能模块中，默认配置了各种工作状态下指示灯的闪烁规律，参考netLed.lua中ledBlinkTime配置的默认值
--如果默认值满足不了需求，此处调用netLed.updateBlinkTime去配置闪烁时长

--加载错误日志管理功能模块【强烈建议打开此功能】
--如下2行代码，只是简单的演示如何使用errDump功能，详情参考errDump的api
require "errDump"
errDump.request("udp://ota.airm2m.com:9072")

--加载远程升级功能模块【强烈建议打开此功能】
--如下3行代码，只是简单的演示如何使用update功能，详情参考update的api以及demo/update
--PRODUCT_KEY = "v32xEAKsGTIEQxtqgwCldp5aPlcnPs3K"
--require "update"
--update.request()

--加载
require "testAdc"

--启动系统框架
sys.init(0, 0)
sys.run()

local level = 0
pmd.ldoset(2,pmd.LDO_VLCD) 
-- GPIO1配置为输出，默认输出低电平，可通过setGpio1Fnc(0或者1)设置输出电平
local setGpio1Fnc = pins.setup(pio.P0_1,0) -- 默认输出值为低（0）
sys.timerLoopStart(function()
    level = level==0 and 1 or 0
    setGpio1Fnc(level)
    log.info("GPIO1的状态:",level)
end,1000)

-- GPIO19配置为输入，可通过getGpio19Fnc()获取输入电平
local getGpio19Fnc = pins.setup(pio.P0_19)
sys.timerLoopStart(function()
    log.info("GPIO19的状态",getGpio19Fnc())
end,1000)

-- GPIO18配置为中断，可通过getGpio18Fnc()获取输入电平，产生中断时，自动执行gpio18IntFnc函数
-- 产生中断时自动调用intFnc(msg)函数：上升沿中断时：msg为cpu.INT_GPIO_POSEDGE；下降沿中断时：msg为cpu.INT_GPIO_NEGEDGE
function gpio18IntFnc(msg)
    log.info("GPIO18中断回调",msg,getGpio18Fnc())
    if msg==cpu.INT_GPIO_POSEDGE then
        log.info("GPIO18中断回调", "上升沿中断")
    else
        log.info("GPIO18中断回调", "下降沿中断")
    end
end
getGpio18Fnc = pins.setup(pio.P0_18,gpio18IntFnc)

--- ADC读取测试
-- @return 无
-- @usage read2()
local function read2()
    --ADC2接口用来读取电压
    local ADC_ID = 2
    -- 读取adc
    -- adcval为number类型，表示adc的原始值，无效值为0xFFFF
    -- voltval为number类型，表示转换后的电压值，单位为毫伏，无效值为0xFFFF
    local adcval,voltval = adc.read(ADC_ID)
    log.info("testAdc2.read",adcval,voltval)
end

--- ADC读取测试
-- @return 无
-- @usage read3()
local function read3()
    --ADC3接口用来读取电压
    local ADC_ID = 3
    -- 读取adc
    -- adcval为number类型，表示adc的原始值，无效值为0xFFFF
    -- voltval为number类型，表示转换后的电压值，单位为毫伏，无效值为0xFFFF
    local adcval,voltval = adc.read(ADC_ID)
    log.info("testAdc3.read",adcval,voltval)
end

require"misc"
--- Vbat读取测试
-- @retrun 无
-- @usage vbatt()
local function vbatt()
    log.info("vbatt.read",misc.getVbatt())
end

-- 开启对应的adc通道
adc.open(2)
adc.open(3)

-- 定时每1秒读取adc值
sys.timerLoopStart(read2,1000)
sys.timerLoopStart(read3,1000)
sys.timerLoopStart(vbatt,1000)

local i2cid = 2 --i2cid

local DS3231_ADDRESS            =   0x68 -- address pin low (GND), default for InvenSense evaluation board
local i2cslaveaddr              =   DS3231_ADDRESS --slave address

---器件通讯地址
local DS3231_CHIP_ID_ADDR       =   0xD0
local DS3231_ID                 =   0x58

---DS3231所用地址

local REG_SEC				    =   0x00
local REG_MIN				    =   0x01
local REG_HOUR			        =   0x02
local REG_DAY				    =   0x03
local REG_WEEK			        =   0x04
local REG_MON				    =   0x05
local REG_YEAR			        =   0x06
local REG_ALM1_SEC  		    =   0x07
local REG_ALM1_MIN 	  	        =   0x08
local REG_ALM1_HOUR     	    =   0x09
local REG_ALM1_DAY_DATE 	    =   0x0A
local REG_ALM2_MIN  		    =   0x0B
local REG_ALM2_HOUR     	    =   0x0C
local REG_ALM2_DAY_DATE 	    =   0x0D
local REG_CONTROL               =   0x0E
local REG_STATUS                =   0x0F
local REG_AGING_OFFSET          =   0x10
local REG_TEMP_MSB 		        =   0x11
local REG_TEMP_LSB 		        =   0x12

local function i2c_send(data)
    i2c.send(i2cid, i2cslaveaddr, data)
end

local function i2c_recv(data,num)
    i2c.send(i2cid, i2cslaveaddr, data)
    local revData = i2c.recv(i2cid, i2cslaveaddr, num)
    return revData
end

local function bcd_to_hex(data)
    local hex = bit.rshift(data,4)*10+bit.band(data,0x0f)
    return hex;
end

local function hex_to_bcd(data)
    local hex = bit.lshift(data/10,4)+data%10
    return hex;
end

--器件初始化
local function DS3231_init()
    i2c_send({REG_CONTROL, 0x04})--close clock out
    log.info("i2c init_ok")
end

local function ds3231_get_temperature()
    local temp
    local T = i2c_recv(REG_TEMP_MSB,2)
    if bit.band(T:byte(1),0x80) then
        --negative temperature
        temp = T:byte(1)
        temp = temp - (bit.rshift(T:byte(2),6)*0.25)--0.25C resolution
    else
        --positive temperature
        temp =  T:byte(1)
        temp = temp + (bit.band(bit.rshift(T:byte(2),6),0x03)*0.25)
    end
	return temp;
end

local function ds3231_read_time()
    -- read time
    local time_data = {}
    local data = i2c_recv(REG_SEC,7)
    time_data.tm_year  = bcd_to_hex(data:byte(7)) + 2000
    time_data.tm_mon   = bcd_to_hex(bit.band(data:byte(6),0x7f)) - 1
    time_data.tm_mday  = bcd_to_hex(data:byte(5))
    time_data.tm_hour  = bcd_to_hex(data:byte(3))
    time_data.tm_min   = bcd_to_hex(data:byte(2))
    time_data.tm_sec   = bcd_to_hex(data:byte(1))
	return time_data
end

local function ds3231_set_time(time)
    -- set time
    local data7 = hex_to_bcd(time.tm_year + 2000)
    local data6 = hex_to_bcd(time.tm_mon + 1)
    local data5 = hex_to_bcd(time.tm_mday)
    local data4 = hex_to_bcd(time.tm_wday+1)
    local data3 = hex_to_bcd(time.tm_hour)
    local data2 = hex_to_bcd(time.tm_min)
    local data1 = hex_to_bcd(time.tm_sec)
    i2c_send({REG_SEC, data1,data2,data3,data4,data5,data6,data7})
end

local function DS3231()
    sys.wait(4000)
    if i2c.setup(i2cid,i2c.SLOW) ~= i2c.SLOW then
        log.error("I2c.init","fail")
        return
    end
    DS3231_init()
    while true do
        log.info("ds3231_get_temperature", ds3231_get_temperature())
        local time = ds3231_read_time()	          log.info("ds3231_read_time",time.tm_year,time.tm_mon,time.tm_mday,time.tm_hour,time.tm_min,time.tm_sec)
        local set_time = {tm_year=2021,tm_mon=3,tm_mday=0,tm_wday=0,tm_hour=0,tm_min=0,tm_sec=0}
        ds3231_set_time(set_time) log.info("ds3231_read_time",time.tm_year,time.tm_mon,time.tm_mday,time.tm_hour,time.tm_min,time.tm_sec)
        sys.wait(1000)
    end
end

sys.taskInit(DS3231)

sys.taskInit(function ()
    local result = spi.setup(spi.SPI_1,0,0,8,800000,1)--初始化spi，
    log.info("spi1",spi.SPI_1)
    log.info("testSpiFlash.init",result)
    local s = string.fromHex("9f000000000000")
    sys.wait(5000)
    while true do
        log.info("testSpiFlash.readFlashID",spi.send_recv(spi.SPI_1,s):toHex())--收发读写
        --下面方法和上面的等价
        log.info("testSpiFlash.sendCommand",spi.send(spi.SPI_1,string.char(0x9f)))--发数据
        log.info("testSpiFlash.readFlashID",spi.recv(spi.SPI_1,6):toHex())--收数据
        sys.wait(1000)
    end
    spi.close(spi.SPI_1)
end)

local function taskRead()
    local cacheData = ""
    while true do
        local s = uart.read(UART_ID,"*l")
        if s == "" then            
            if not sys.waitUntil("UART_RECEIVE",100) then
                --uart接收数据，如果100毫秒没有收到数据，则打印出来所有已收到的数据，清空数据缓冲区，等待下次数据接收
                --注意：
                --串口帧没有定义结构，仅靠软件延时，无法保证帧的完整性，如果对帧接收的完整性有严格要求，必须自定义帧结构（参考testUart.lua）
                --因为在整个GSM模块软件系统中，软件定时器的精确性无法保证，例如本demo配置的是100毫秒，在系统繁忙时，实际延时可能远远超过100毫秒，达到200毫秒、300毫秒、400毫秒等
                --设置的延时时间越短，误差越大
                if cacheData:len()>0 then
                    log.info("testUartTask.taskRead","100ms no data, received length",cacheData:len())
                    --数据太多，如果全部打印，可能会引起内存不足的问题，所以此处仅打印前1024字节
                    log.info("testUartTask.taskRead","received data",cacheData:sub(1,1024))
                    --打印收到的hex
                    log.info("testUartTask.taskRead","received data",cacheData:sub(1,1024):toHex())
                    write(cacheData)
                    cacheData = ""
                end
            end
        else
            cacheData = cacheData..s            
        end
    end
end

function write(s)
    log.info("testUartTask.write",s)
    uart.write(UART_ID,s)
end

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

--注册串口的数据发送通知函数
uart.on(UART_ID,"sent",writeOk)
uart.on(UART_ID,"receive",function() sys.publish("UART_RECEIVE") end)
--配置并且打开串口
uart.setup(UART_ID,115200,8,uart.PAR_NONE,uart.STOP_1)
--需要485通讯时打开下面的语句
--uart.set_rs485_oe(UART_ID, pio.P0_19)
--如果需要打开“串口发送数据完成后，通过异步消息通知”的功能，则使用下面的这行setup，注释掉上面的一行setup
--uart.setup(UART_ID,115200,8,uart.PAR_NONE,uart.STOP_1,nil,1)

--启动串口数据接收任务
sys.taskInit(taskRead)

module(...)

name = "zhangsan"
age = "18"
sex = "male"
hobby = {"reading","swimming"}
something = {a=1,b=2}

require"config"
require"nvm"

nvm.init("config.lua",false)   -- burnSave 本地烧录是否保留已有参数，true为保留，false或者nil为清除

local function testnvm()
    sys.wait(5000)	-- 延时5s等待USB虚拟串口准备好打印
    -- 读取nvm中的初始化数据
    log.info("nvm.读取默认值", nvm.get("name"))
    log.info("nvm.读取默认值", nvm.get("age"))
    log.info("nvm.读取默认值", nvm.get("sex"))
    local hobby = nvm.get("hobby")
    log.info("nvm.读取默认值", hobby[1],hobby[2])
    local some = nvm.get("something")
    log.info("nvm.读取默认值", some["a"])
    sys.wait(1000)

    log.info("nvm.修改", nvm.sett("hobby",1,"read"))
    log.info("nvm.修改", nvm.sett("something","a",235))
    local hobby2 = nvm.get("hobby")
    local so = nvm.get("something")
    log.info("nvm.更新数据", hobby2[1],so["a"])
    nvm.restore()   -- 恢复出厂
end

sys.taskInit(testnvm)

-----------------------encode测试------------------------
local torigin =
{
    KEY1 = "VALUE1",
    KEY2 = "VALUE2",
    KEY3 = "VALUE3",
    KEY4 = "VALUE4",
    KEY5 = {KEY5_1="VALU5_1",KEY5_2="VALU5_2"},
    KEY6 = {1,2,3},
}
local function jsonEncode()
    local jsondata = json.encode(torigin)
    log.info("testJson.encode",jsondata)
end
sys.timerLoopStart(jsonEncode, 1000)
-----------------------encode测试------------------------

-----------------------decode测试------------------------
--{"KEY3":"VALUE3","KEY4":"VALUE4","KEY2":"VALUE2","KEY1":"VALUE1","KEY5":{"KEY5_2":"VALU5_2","KEY5_1":"VALU5_1"}},"KEY6":[1,2,3]}
local function jsonDecode()
    local origin = "{\"KEY3\":\"VALUE3\",\"KEY4\":\"VALUE4\",\"KEY2\":\"VALUE2\",\"KEY1\":\"VALUE1\",\"KEY5\":{\"KEY5_2\":\"VALU5_2\",\"KEY5_1\":\"VALU5_1\"},\"KEY6\":[1,2,3]}"
    local tjsondata,result,errinfo = json.decode(origin)
    if result and type(tjsondata)=="table" then
        log.info("testJson.decode KEY1",tjsondata["KEY1"])
        log.info("testJson.decode KEY2",tjsondata["KEY2"])
        log.info("testJson.decode KEY3",tjsondata["KEY3"])
        log.info("testJson.decode KEY4",tjsondata["KEY4"])
        log.info("testJson.decode KEY5",tjsondata["KEY5"]["KEY5_1"],tjsondata["KEY5"]["KEY5_2"])
        log.info("testJson.decode KEY6",tjsondata["KEY6"][1],tjsondata["KEY6"][2],tjsondata["KEY6"][3])
    else
        log.info("testJson.decode error",errinfo)
    end
end
sys.timerLoopStart(jsonDecode,1000)

-----------------------decode测试------------------------

uart.setup(uart.USB, 0, 0, uart.PAR_NONE, uart.STOP_1)

--[[
函数名：usbreader
功能  ：向USB AT 口发送数据
参数  ：无
返回值：无
]]
local function usbwrite(s)
    log.info("usb send",s)
    uart.write(uart.USB, s) 
end

--[[
函数名：usbreader
功能  ：从USB AT 口接收数据
参数  ：无
返回值：无
]]
local function usbreader()
    local s
    
    --循环读取收到的数据
    while true do
        --每次读取一行
        s = uart.read(uart.USB, "*l", 0)
        if string.len(s) ~= 0 then
                log.info("usb rcv",s);
                usbwrite(s)                
        else
            break
        end
    end
end

uart.on(uart.USB, "receive", usbreader)

module(...,package.seeall)

--[[
函数名：eatSoftDog
功能  ：喂狗
参数  ：无
返回值：无
]]
function eatSoftDog()
    print("eatSoftDog test")
    rtos.eatSoftDog()
end

--[[
函数名：closeSoftDog
功能  ：关闭软狗
参数  ：无
返回值：无
]]
function closeSoftDog()
    print("closeSoftDog test")
    sys.timerStop(eatSoftDog)
    rtos.closeSoftDog()
end

--打开并设置软狗超时时间单位MS,超过设置时间没去喂狗，重启模块
rtos.openSoftDog(10*1000)

--定时喂狗
sys.timerLoopStart(eatSoftDog,5*1000)


--打印版本号
sys.timerLoopStart(log.info,2000,rtos.get_version(),_G.VERSION)

    --单次播放来电铃声，默认音量等级
    --audio.play(CALL,"FILE","/lua/call.mp3")
    --单次播放来电铃声，音量等级7
    --audio.play(CALL,"FILE","/lua/call.mp3",audiocore.VOL7)
    --单次播放来电铃声，音量等级7，播放结束或者出错调用testcb回调函数
    --audio.play(CALL,"FILE","/lua/call.mp3",audiocore.VOL7,testCb)
    --循环播放来电铃声，音量等级7，没有循环间隔(一次播放结束后，立即播放下一次)
    audio.play(CALL,"FILE","/lua/call.mp3",audiocore.VOL7,nil,true)
    --循环播放来电铃声，音量等级7，循环间隔为2000毫秒
    --audio.play(CALL,"FILE","/lua/call.mp3",audiocore.VOL7,nil,true,2000)

--播放tts测试接口，每次打开一行代码进行测试
--audio.play接口要求TTS数据为UTF8编码，因为本文件编辑时采用的是UTF8编码，所以可以直接使用ttsStr，不用做编码转换
--如果用户自己编辑脚本时，采用的不是UTF8编码，需要调用common.XXX2utf8接口进行转换
local ttsStr = "上海合宙通信科技有限公司欢迎您"
local function testPlayTts()
    --单次播放，默认音量等级
    --audio.play(TTS,"TTS",ttsStr)
    --单次播放，音量等级7
    --audio.play(TTS,"TTS",ttsStr,7)
    --单次播放，音量等级7，播放结束或者出错调用testcb回调函数
    --audio.play(TTS,"TTS",ttsStr,7,testCb)
    --循环播放，音量等级7，没有循环间隔(一次播放结束后，立即播放下一次)
    --audio.play(TTS,"TTS",ttsStr,7,nil,true)
    --循环播放，音量等级7，循环间隔为2000毫秒
    audio.play(TTS,"TTS",ttsStr,7,nil,true,2000)
end

sys.taskInit(function()
    while true do        
        sys.wait(2000)  
        --播放多arm文件方式
        local multiFile = {"/lua/alipay.amr","/lua/10.amr","/lua/2.amr","/lua/yuan.amr"}
        audio.play(1,"FILE",multiFile,7,function() sys.publish("armMultiTest") end)
        sys.waitUntil("armMultiTest")
        sys.wait(2000)
        --播放多pcm文件方式
        multiFile = {"/lua/alipay.pcm","/lua/10.pcm","/lua/8.pcm","/lua/yuan.pcm"}
        audio.play(1,"FILE",multiFile,7,function() sys.publish("armMultiTest") end)
        sys.waitUntil("armMultiTest")        
    end
end)
----------------------------------------------------------------------------------------
sys.taskInit(function()
    while true do        
        sys.wait(2000)  
        --播放多mp3文件方式
        local multiFile = {"/lua/0.mp3","/lua/1.mp3","/lua/2.mp3","/lua/3.mp3","/lua/4.mp3"}
        audio.play(1,"FILE",multiFile,2,function() sys.publish("mp3MultiTest") end)
        sys.waitUntil("mp3MultiTest") 
    end
end)

require"uiWin"
require"prompt"
require"idle"


--清空LCD显示缓冲区
disp.clear()
if lcd.WIDTH==128 and lcd.HEIGHT==128 then
--显示logo图片
disp.putimage("/lua/logo_"..(lcd.BPP==1 and "mono.bmp" or "color.png"),lcd.BPP==1 and 41 or 0,lcd.BPP==1 and 18 or 0)
elseif lcd.WIDTH==240 and lcd.HEIGHT==320 then
disp.puttext(common.utf8ToGb2312("欢迎使用Luat"),lcd.getxpos(common.utf8ToGb2312("欢迎使用Luat")),10)
--显示logo图片
disp.putimage("/lua/logo_color_240X320.png",0,80)
else
--从坐标16,0位置开始显示"欢迎使用Luat"
disp.puttext(common.utf8ToGb2312("欢迎使用Luat"),lcd.getxpos(common.utf8ToGb2312("欢迎使用Luat")),0)
--显示logo图片
disp.putimage("/lua/logo_"..(lcd.BPP==1 and "mono.bmp" or "color.png"),lcd.BPP==1 and 41 or 1,lcd.BPP==1 and 18 or 33)
end
--刷新LCD显示缓冲区到LCD屏幕上
disp.update()

--5秒后，打开提示框窗口，提示"3秒后进入待机界面"
--提示框窗口关闭后，自动进入待机界面
sys.timerStart(prompt.open,5000,common.utf8ToGb2312("3秒后"),common.utf8ToGb2312("进入待机界面"),nil,idle.open)

require"misc"
require"ntp"
require"common"

--appid：窗口id
local appid

--[[
函数名：refresh
功能  ：窗口刷新处理
参数  ：无
返回值：无
]]
local function refresh()
    --清空LCD显示缓冲区
    disp.clear()
    local oldColor = lcd.setcolor(0xF100)
    disp.puttext(common.utf8ToGb2312("待机界面"),lcd.getxpos(common.utf8ToGb2312("待机界面")),0)
    local tm = misc.getClock()
    local datestr = string.format("%04d",tm.year).."-"..string.format("%02d",tm.month).."-"..string.format("%02d",tm.day)
    local timestr = string.format("%02d",tm.hour)..":"..string.format("%02d",tm.min)..":"..string.format("%02d",tm.sec)
    --显示日期
    lcd.setcolor(0x07E0)
    disp.puttext(datestr,lcd.getxpos(datestr),24)
    --显示时间
    lcd.setcolor(0x001F)
    disp.puttext(timestr,lcd.getxpos(timestr),44)
    
    --刷新LCD显示缓冲区到LCD屏幕上
    disp.update()
    lcd.setcolor(oldColor)
end

--窗口类型的消息处理函数表
local winapp =
{
    onUpdate = refresh,
}

--[[
函数名：clkind
功能  ：时间更新处理
参数  ：无
返回值：无
]]
local function clkind()
    if uiWin.isActive(appid) then
        refresh()
    end    
end

--[[
函数名：open
功能  ：打开待机界面窗口
参数  ：无
返回值：无
]]
function open()
    appid = uiWin.add(winapp)
end

ntp.timeSync()
sys.timerLoopStart(clkind,1000)
sys.subscribe("TIME_UPDATE_IND",clkind)

--LCD分辨率的宽度和高度(单位是像素)
local WIDTH, HEIGHT = 132,162

--- qrencode.encode(string) 创建二维码信息
-- @param string 二维码字符串
-- @return width 生成的二维码信息宽度
-- @return data 生成的二维码数据
-- @usage local width, data = qrencode.encode("http://www.openluat.com")
local width, data = qrencode.encode('http://www.openluat.com')

--- disp.putqrcode(data, width, display_width, x, y) 显示二维码
-- @param data 从qrencode.encode返回的二维码数据
-- @param width 二维码数据的实际宽度
-- @param display_width 二维码实际显示宽度,显示宽度开根号需要是整数
-- @param x 二维码显示起始坐标x
-- @param y 二维码显示起始坐标y

--- 二维码显示函数
local function appQRCode()
	disp.clear()
    local displayWidth = 100
    disp.putqrcode(data, width, displayWidth, (WIDTH-displayWidth)/2, (HEIGHT-displayWidth)/2)
	disp.update()	
end

appQRCode()

-- 扫码结果回调函数
-- @bool result，true或者false，true表示扫码成功，false表示超时失败
-- @string[opt=nil] codeType，result为true时，表示扫码类型；result为false时，为nil；支持QR-Code和CODE-128两种类型
-- @string[opt=nil] codeStr，result为true时，表示扫码结果的字符串；result为false时，为nil
local function scanCodeCb(result,codeType,codeStr)
    --关闭摄像头预览
    disp.camerapreviewclose()
    --关闭摄像头
    disp.cameraclose()
    --允许系统休眠
    pm.sleep("testScanCode")
    --500毫秒后处理扫描结果
    sys.timerStart(function()
        --如果有LCD，显示扫描结果
        if WIDTH~=0 and HEIGHT~=0 then
            disp.clear()
            if result then
                disp.puttext(common.utf8ToGb2312("扫描成功"),0,5)
                disp.puttext(common.utf8ToGb2312("类型: ")..codeType,0,35)
                log.info("scanCodeCb",codeStr:toHex())
                disp.puttext(common.utf8ToGb2312("结果: ")..codeStr,0,65)
            else
                disp.puttext(common.utf8ToGb2312("扫描失败"),0,5)
            end
            disp.update()
        end
    end,500)

    sys.timerStart(scan,1000)
end

-- 拍照并显示
function takePhotoAndDisplay()
    --唤醒系统
    pm.wake("testTakePhoto")
    --打开摄像头
    disp.cameraopen(1,0,0,1)
    --disp.cameraopen(1,0,0,0)  --因目前core中还有问题没解决，所以不能关闭隔行隔列
    --打开摄像头预览
    --如果有LCD，使用LCD的宽和高
    --如果无LCD，宽度设置为240像素，高度设置为320像素，240*320是Air268F支持的最大分辨率
    disp.camerapreview(0,0,0,0,WIDTH or DEFAULT_WIDTH,HEIGHT or DEFAULT_HEIGHT)
    --设置照片的宽和高像素并且开始拍照
    --此处设置的宽和高和预览时的保持一致
    --此处的第三个参数表示拍摄质量，默认50，100最好
    disp.cameracapture(WIDTH or DEFAULT_WIDTH,HEIGHT or DEFAULT_HEIGHT)
    --设置照片保存路径
    disp.camerasavephoto("/testCamera.jpg")
    log.info("testCamera.takePhotoAndDisplay fileSize",io.fileSize("/testCamera.jpg"))
    --关闭摄像头预览
    disp.camerapreviewclose()
    --关闭摄像头
    disp.cameraclose()
    --允许系统休眠
    pm.sleep("testTakePhoto")

    --testUartSentFile.sendFile()
    --显示拍照图片
    if WIDTH~=0 and HEIGHT~=0 then
        disp.clear()
        disp.putimage("/testCamera.jpg",0,0)
        disp.puttext(common.utf8ToGb2312("照片尺寸: "..io.fileSize("/testCamera.jpg")),0,5)
        disp.update()
    end

    sys.timerStart(takePhotoAndDisplay,5000)
end

function scan()
    --唤醒系统
    pm.wake("testScanCode")
    local ret = 0

    --设置扫码回调函数，默认10秒超时
    scanCode.request(scanCodeCb)

    --打开摄像头
    --ret = disp.cameraopen(1,1) -- 内部配置的gc0310 camera
    --ret = disp.cameraopen_ext(gc6153) -- 外部配置gc6153 camera SDR
    ret = disp.cameraopen_ext(gc0310_sdr) -- 外部配置gc0310 camera SDR
    --ret = disp.cameraopen_ext(gc0310_ddr) -- 外部配置gc0310 camera DDR
    --ret = disp.cameraopen_ext(bf302A_sdr) -- 外部配置bf302A camera SDR

    log.info("testScanCode cameraopen_ext ret ", ret)
    --打开摄像头预览
    --zoom： 放缩设置, 正数放大负数缩小，最大4倍，0不放缩
    --disp.camerapreviewzoom(zoom)
    --缩小2倍
    disp.camerapreviewzoom(-2)
    ret = disp.camerapreview(0,0,0,0,128,160)
    --rotation：反转角度设置 暂时只支持0和90度
    --disp.camerapreviewrotation(90)
end
sys.timerStart(scan,1000)

local function keyMsg(msg)
    --msg.key_matrix_row：行
    --msg.key_matrix_col：列
    --msg.pressed：true表示按下，false表示弹起
    log.info("keyMsg",msg.key_matrix_row,msg.key_matrix_col,msg.pressed)
end

--注册按键消息处理函数
rtos.on(rtos.MSG_KEYPAD,keyMsg)
--初始化键盘阵列
--第一个参数：固定为rtos.MOD_KEYPAD，表示键盘
--第二个参数：目前无意义，固定为0
--第三个参数：表示键盘阵列keyin标记，例如使用了keyin0、keyin1、keyin2、keyin3，则第三个参数为1<<0|1<<1|1<<2|1<<3 = 0x0F
--第四个参数：表示键盘阵列keyout标记，例如使用了keyout0、keyout1、keyout2、keyout3，则第四个参数为1<<0|1<<1|1<<2|1<<3 = 0x0F
rtos.init_module(rtos.MOD_KEYPAD,0,0x0F,0x0F)

require"pm"

--[[
关于休眠这一部分的说明：
目前的休眠处理有两种方式，
一种是底层core内部，自动处理，例如tcp发送或者接收数据时，会自动唤醒，发送接收结束后，会自动休眠；这部分不用lua脚本控制
另一种是lua脚本使用pm.sleep和pm.wake自行控制，例如，uart连接外围设备，uart接收数据前，要主动去pm.wake，这样才能保证前面接收的数据不出错，当不需要通信时，调用pm.sleep；如果有lcd的项目，也是同样道理
不休眠时功耗至少30mA左右
休眠后，飞行模式不到1mA，非飞行模式的功耗还没有数据（后续补充）
如果不是故意控制的不休眠，一定要保证pm.wake("A")了，有地方去调用pm.sleep("A")
]]


pm.wake("A") --执行本句后，A唤醒了模块
pm.wake("A") --执行本句后，A重复唤醒模块，实际上没什么变化
pm.sleep("A") --执行本句后，A休眠了模块，lua部分已经没有功能唤醒模块了，模块是否休眠由core决定

pm.wake("B") --执行本句后，B唤醒了模块
pm.wake("C") --执行本句后，C唤醒了模块
pm.sleep("B") --执行本句后，B休眠了模块，但是lua部分还有C已经唤醒了模块，模块并不会休眠
pm.sleep("C") --执行本句后，C休眠了模块，lua部分已经没有功能唤醒模块了，模块是否休眠由core决定

1. 查看模块是否插入USB，USB连接的状态下模块保持唤醒，无法休眠
2. 使用开发板和自己的板子烧录adc的demo进行对比，看模块是否能够进行休眠
3. 使用pm.isSleep()接口查询脚本休眠状态，看是否是调用了pm.wake(tag)后没有去调用pm.sleep(tag)
4. 屏蔽代码，看是由哪部分代码使模块无法休眠

uart1在core中做了特殊处理，可以实现休眠状态下接收数据不丢失

require"audio"

function sdCardTask()
    sys.wait(5000)
    --挂载SD卡,返回值0表示失败，1表示成功
    io.mount(io.SDCARD)
    
    --第一个参数1表示sd卡
    --第二个参数1表示返回的总空间单位为KB
    local sdCardTotalSize = rtos.get_fs_total_size(1,1)
    log.info("sd card total size "..sdCardTotalSize.." KB")
    
    --第一个参数1表示sd卡
    --第二个参数1表示返回的总空间单位为KB
    local sdCardFreeSize = rtos.get_fs_free_size(1,1)
    log.info("sd card free size "..sdCardFreeSize.." KB")
    
    
    --遍历读取sd卡根目录下的最多10个文件或者文件夹
    if io.opendir("/sdcard0") then
        for i=1,10 do
            local fType,fName,fSize = io.readdir()
            if fType==32 then
                log.info("sd card file",fName,fSize)               
            elseif fType == nil then
                break
            end
        end        
        io.closedir("/sdcard0")
    end
    
    --向sd卡根目录下写入一个pwron.mp3
    io.writeFile("/sdcard0/pwron.mp3",io.readFile("/lua/pwron.mp3"))
    --播放sd卡根目录下的pwron.mp3
    audio.play(0,"FILE","/sdcard0/pwron.mp3",audiocore.VOL7,function() sys.publish("AUDIO_PLAY_END") end)
    sys.waitUntil("AUDIO_PLAY_END")    
    
    --卸载SD卡，返回值0表示失败，1表示成功
    io.unmount(io.SDCARD)
end

sys.taskInit(sdCardTask)

--[[
    函数名：readfile(filename)
    功能：打开所输入文件名的文件，并输出储存在里面额内容
    参数：文件名
    返回值：无                     ]]
local function readfile(filename)--打开指定文件并输出内容

    local filehandle=io.open(filename,"r")--第一个参数是文件名，第二个是打开方式，'r'读模式,'w'写模式，对数据进行覆盖,'a'附加模式,'b'加在模式后面表示以二进制形式打开
    if filehandle then          --判断文件是否存在
        local fileval=filehandle:read("*all")--读出文件内容
      if  fileval  then
           print(fileval)  --如果文件存在，打印文件内容
           filehandle:close()--关闭文件
      else
           print("文件为空")--文件不存在
      end
    else
        print("文件不存在或文件输入格式不正确") --打开失败
    end

end



--[[
    函数名： writevala(filename,value)
    功能：向输入的文件中添加内容，内容附加在原文件内容之后
    参数：第一个文件名，第二个需要添加的内容
    返回值：无                         --]]
local function writevala(filename,value)--在指定文件中添加内容,函数名最后一位就是打开的模式
    local filehandle = io.open(filename,"a+")--第一个参数是文件名，后一个是打开模式'r'读模式,'w'写模式，对数据进行覆盖,'a'附加模式,'b'加在模式后面表示以二进制形式打开
    if filehandle then
        filehandle:write(value)--写入要写入的内容
        filehandle:close()
    else
        print("文件不存在或文件输入格式不正确") --打开失败
    end
end



--[[
    函数名：writevalw(filename,value)
    功能：向输入文件中添加内容，新添加的内容会覆盖掉原文件中的内容
    参数：同上
    返回值：无                 --]]
local function writevalw(filename,value)--在指定文件中添加内容
    local filehandle = io.open(filename,"w")--第一个参数是文件名，后一个是打开模式'r'读模式,'w'写模式，对数据进行覆盖,'a'附加模式,'b'加在模式后面表示以二进制形式打开
    if filehandle then
        filehandle:write(value)--写入要写入的内容
        filehandle:close()
    else
        print("文件不存在或文件输入格式不正确") --打开失败
    end
end


--[[函数名：deletefile(filename)
    功能：删除指定文件
    参数：文件名
    返回值：无             --]]
local function deletefile(filename)
    os.remove(filename)
end

--打印文件系统的剩余空间
print("get_fs_free_size: "..rtos.get_fs_free_size().." Bytes")
sys.timerLoopStart(function() print("get_fs_free_size: "..rtos.get_fs_free_size().." Bytes") end,5000)
--成功创建一个目录(目录已存在，也返回true表示创建成功)
if rtos.make_dir(USER_DIR_PATH) then
    log.info("testFs.readfile")
    readfile(USER_DIR_PATH.."/3.txt")

    log.info("testFs.writevala")
    writevala(USER_DIR_PATH.."/3.txt","great")

    log.info("testFs.readfile")
    readfile(USER_DIR_PATH.."/3.txt")
    log.info("testFs.writevalw")
    writevalw(USER_DIR_PATH.."/3.txt","great")
    log.info("testFs.readfile")
    readfile(USER_DIR_PATH.."/3.txt")

    log.info("testFs.deletefile")
    deletefile(USER_DIR_PATH.."/3.txt")
    log.info("testFs.readfile")
    readfile(USER_DIR_PATH.."/3.txt")
end

require"lbsLoc"

--[[
功能  ：发送查询位置请求
参数  ：无
返回值：无
]]
local function reqLbsLoc()   
    lbsLoc.request(getLocCb)
end

--[[
功能  ：获取基站对应的经纬度后的回调函数
参数  ：
		result：number类型，0表示成功，1表示网络环境尚未就绪，2表示连接服务器失败，3表示发送数据失败，4表示接收服务器应答超时，5表示服务器返回查询失败；为0时，后面的3个参数才有意义
		lat：string类型，纬度，整数部分3位，小数部分7位，例如031.2425864
		lng：string类型，经度，整数部分3位，小数部分7位，例如121.4736522
返回值：无
]]
function getLocCb(result,lat,lng)
    log.info("testLbsLoc.getLocCb",result,lat,lng)
    --获取经纬度成功
    if result==0 then
    --失败
    else
    end
    sys.timerStart(reqLbsLoc,20000)
end

reqLbsLoc()

require"wifiScan"

module(...,package.seeall)

sys.taskInit(function()
    while true do
        sys.wait(5000)
        
        wifiScan.request(function(result,cnt,tInfo)
            log.info("testWifi.scanCb",result,cnt)
            sys.publish("WIFI_SCAN_IND",result,cnt,tInfo)
        end)
        
        local _,result,cnt,tInfo = sys.waitUntil("WIFI_SCAN_IND")
        if result then
            for k,v in pairs(tInfo) do
                log.info("testWifi.scanCb",k,v)
            end
        end
    end
end)

--测试代码开关，取值1,2
local testIdx = 1
local function test(idx)
    --第1种测试代码
    if idx==1 then
        --执行完下面三行代码后，GPS就会一直开启，永远不会关闭
        --因为gps.open(gps.DEFAULT,{tag="TEST1",cb=test1Cb})，这个开启，没有调用gps.close关闭
        gps.open(gps.DEFAULT,{tag="TEST1",cb=test1Cb})

        --10秒内，如果gps定位成功，会立即调用test2Cb，然后自动关闭这个“GPS应用”
        --10秒时间到，没有定位成功，会立即调用test2Cb，然后自动关闭这个“GPS应用”
        gps.open(gps.TIMERORSUC,{tag="TEST2",val=10,cb=test2Cb})

        --300秒时间到，会立即调用test3Cb，然后自动关闭这个“GPS应用”
        gps.open(gps.TIMER,{tag="TEST3",val=300,cb=test3Cb})
    --第2种测试代码
    elseif idx==2 then
        --执行完下面三行代码打开GPS后，5分钟之后GPS会关闭
        gps.open(gps.DEFAULT,{tag="TEST1",cb=test1Cb})
        sys.timerStart(gps.close,300000,gps.DEFAULT,{tag="TEST1"})
        gps.open(gps.TIMERORSUC,{tag="TEST2",val=10,cb=test2Cb})
        gps.open(gps.TIMER,{tag="TEST3",val=60,cb=test3Cb}) 
    end
end

local function test1Cb(tag)
    log.info("testGps.test1Cb",tag)
    printGps()
end

local function test2Cb(tag)
    log.info("testGps.test2Cb",tag)
    printGps()
end

local function test3Cb(tag)
    log.info("testGps.test3Cb",tag)
    printGps()
end

local function nmeaCb(nmeaItem)
    log.info("testGps.nmeaCb",nmeaItem)
end

local function printGps()
    if gps.isOpen() then
        local tLocation = gps.getLocation()
        local speed = gps.getSpeed()
        log.info("testGps.printGps",
            gps.isOpen(),gps.isFix(),
            tLocation.lngType,tLocation.lng,tLocation.latType,tLocation.lat,
            gps.getAltitude(),
            speed,
            gps.getCourse(),
            gps.getViewedSateCnt(),
            gps.getUsedSateCnt())
    end
end

gps.setNmeaMode(2,nmeaCb)

test(testIdx)
sys.timerLoopStart(printGps,2000)

--启动socket客户端任务
sys.taskInit(
    function()
        local retryConnectCnt = 0
        while true do
            if not socket.isReady() then
                retryConnectCnt = 0
                --等待网络环境准备就绪，超时时间是5分钟
                sys.waitUntil("IP_READY_IND",300000)
            end
            
            if socket.isReady() then
                --创建一个socket tcp客户端
                local socketClient = socket.tcp()
                --阻塞执行socket connect动作，直至成功
                if socketClient:connect("180.97.80.55",12415) then
                    retryConnectCnt = 0
                    if socketClient:send("heart data\r\n") then
                        result,data = socketClient:recv(5000)
                        if result then
                            --TODO：处理收到的数据data
                            log.info("socketTask.recv",data)
                        end
                    end
                else
                    retryConnectCnt = retryConnectCnt+1
                end
                
                --断开socket连接
                socketClient:close()
                if retryConnectCnt>=5 then link.shut() retryConnectCnt=0 end
                sys.wait(20000)
            else
                --进入飞行模式，20秒之后，退出飞行模式
                net.switchFly(true)
                sys.wait(20000)
                net.switchFly(false)
            end
        end
    end
)

require"socket"
require"ntp"

--同步网络时间，因为证书校验时会用到系统时间
ntp.timeSync()
--启动socket客户端任务
sys.taskInit(
    function()
        --单向认证测试时，此变量设置为false；双向认证测试时，此变量设置为true
        local mutualAuth = false
        local socketClient,connectResult
        local retryConnectCnt = 0
            
        while true do
            if not socket.isReady() then
                retryConnectCnt = 0
                --等待网络环境准备就绪，超时时间是5分钟
                sys.waitUntil("IP_READY_IND",300000)
            end
            
            if socket.isReady() then
                --双向认证测试
                if mutualAuth then                   
                    --创建一个socket ssl tcp客户端
                    socketClient = socket.tcp(true,{caCert="ca.crt",clientCert="client.crt",clientKey="client.key"})
                    --阻塞执行socket connect动作，直至成功
                    connectResult = socketClient:connect("36.7.87.100","4434")
                --单向认证测试
                else
                    --创建一个socket ssl tcp客户端
                    socketClient = socket.tcp(true,{caCert="ca.crt"})
                    --阻塞执行socket connect动作，直至成功
                    connectResult = socketClient:connect("36.7.87.100","4433")
                end
                
                if connectResult then
                    retryConnectCnt = 0
                    if socketClient:send("GET / HTTP/1.1\r\nHost: 36.7.87.100\r\nConnection: keep-alive\r\n\r\n") then
                        result,data = socketClient:recv(5000)
                        if result then
                            --TODO：处理收到的数据data
                            log.info("socketTask.recv",data)
                        end
                    end
                else
                    retryConnectCnt = retryConnectCnt+1
                end
                
                --断开socket连接
                socketClient:close()
                if retryConnectCnt>=5 then link.shut() retryConnectCnt=0 end
                sys.wait(20000)
            else
                --进入飞行模式，20秒之后，退出飞行模式
                net.switchFly(true)
                sys.wait(20000)
                net.switchFly(false)
            end
        end
    end
)

--启动MQTT客户端任务
sys.taskInit(
    function()
        local retryConnectCnt = 0
        while true do
            if not socket.isReady() then
                retryConnectCnt = 0
                --等待网络环境准备就绪，超时时间是5分钟
                sys.waitUntil("IP_READY_IND",300000)
            end         
            if socket.isReady() then
                local imei = misc.getImei()
                --创建一个MQTT客户端
                local mqttClient = mqtt.client(imei,600,"user","password")
            else
                --进入飞行模式，20秒之后，退出飞行模式
                net.switchFly(true)
                sys.wait(20000)
                net.switchFly(false)
            end
        end
    end
)

   --创建一个MQTT客户端
   local mqttClient = mqtt.client(imei,600,"user","password")
   --连接MQTT
   mqttClient:connect("lbsmqtt.airm2m.com",1884,"tcp")

if mqttClient:subscribe({["/event0"]=0, ["/中文event1"]=1}) then
   mqttOutMsg.init()
   --循环处理接收和发送的数据
   while true do
     if not mqttInMsg.proc(mqttClient) then log.error("mqttTask.mqttInMsg.proc error") break end
     if not mqttOutMsg.proc(mqttClient) then log.error("mqttTask.mqttOutMsg proc error") break end
   end
   mqttOutMsg.unInit()
   end

--- MQTT客户端数据接收处理
-- @param mqttClient，MQTT客户端对象
-- @return 处理成功返回true，处理出错返回false
-- @usage mqttInMsg.proc(mqttClient)
function proc(mqttClient)
    local result,data
    while true do
        result,data = mqttClient:receive(60000,"APP_SOCKET_SEND_DATA")
        --接收到数据
        if result then
            log.info("mqttInMsg.proc",data.topic,string.toHex(data.payload))
                
            --TODO：根据需求自行处理data.payload
        else
            break
        end
    end
	
    return result or data=="timeout" or data=="APP_SOCKET_SEND_DATA"
end

--数据发送的消息队列
local msgQueue = {}

--插入发发送的数据到消息队列
local function insertMsg(topic,payload,qos,user)
    table.insert(msgQueue,{t=topic,p=payload,q=qos,user=user})
    sys.publish("APP_SOCKET_SEND_DATA")
end

--主题为"/qos0topic"的消息回调函数
local function pubQos0TestCb(result)
    log.info("mqttOutMsg.pubQos0TestCb",result)
    if result then sys.timerStart(pubQos0Test,10000) end
end

--插入主题为"/qos0topic"的消息到消息队列
function pubQos0Test()
    insertMsg("/qos0topic","qos0data",0,{cb=pubQos0TestCb})
end

--主题为"/中文qos1topic"的消息回调函数
local function pubQos1TestCb(result)
    log.info("mqttOutMsg.pubQos1TestCb",result)
    if result then sys.timerStart(pubQos1Test,20000) end
end

--插入主题为"/中文qos1topic"的消息到消息队列
function pubQos1Test()
    insertMsg("/中文qos1topic","中文qos1data",1,{cb=pubQos1TestCb})
end

--从消息队列中取出消息，发送到服务器 
function proc(mqttClient)
    while #msgQueue>0 do
        local outMsg = table.remove(msgQueue,1)
        local result = mqttClient:publish(outMsg.t,outMsg.p,outMsg.q)
        if outMsg.user and outMsg.user.cb then outMsg.user.cb(result,outMsg.user.para) end
        if not result then return end
    end
    return true
end