Core API 文档发布时间: Fri Oct 20 17:32:19 2023常用外部设备LED灯独立按键0.96寸oled屏1602LCD(IIc接口)TF卡读写TF卡读写扩展(仅适用于C1)数码管和矩阵键盘TM1650四位数码管显示全彩RGB LedPCF8574扩展IO口WK2124 UART四串口扩展AM1805低功耗SYN6288语音输出LD3320A 语音识别ESP32CAM 摄像头无线局域网Ble低功耗蓝牙(仅C1支持)ThreadMesh组网(仅C1支持)红外无线通信无线广域网Wifi TCP通信(esp8266)Wifi UDP通信(esp8266)MQTT通信NBIOT TCP通信(m5311)NBIOT UDP通信(m5311)NBIOT MQTT通信(m5311)4G TCP和UDP通信(ML302和EC800)4G HTTP通信(ML302)4G MQTT通信(ML302和EC800)Lora通信Wifi TCP通信(内部Wifi,仅C2支持)Wifi UDP通信(内部Wifi,仅C2支持)Wifi MQTT通信(内部Wifi,仅C2支持)云接入机智云无线RFIDIC卡功能(RC522读写卡模块)ID卡读卡功能(em4001,em4102读卡器)UHF读写标签功能(R200读卡器)有线通信:连接电脑以太网TCP通信(W5500)以太网UDP通信(W5500)传感器:环境测量SHT3x温湿度传感器BMP280气压计/温度传感器BH1750光照强度传感器红外非接触式测温SM9541压力和温度测量传感器:物理测量MPU6050六轴传感器TCS3472颜色及色温传感器APDS9960(光照度,靠近检测、手势检测传感器)HX711称重/压力/电桥测量QMC5883三轴磁场强度/指南针ADXL345三轴加速度/倾角VL53L0X激光测距超声波测距GPS定位/授时心率/脉搏测量传感器:气体测量CCS811 TVOC/eCO2传感器ENS160/SGP30 TVOC/eCO2传感器ZPH04 PM2.5传感器ZE08K 甲醛传感器Z19C 二氧化碳传感器有线通信:连接电脑USB相关功能CH9329 USB键鼠模拟器单片机常用功能uart通用异步串口gpio引脚输入输出timer定时器iic同步串行总线spi串行外设接口总线PWM(1路或3路)PWM(8路扩展,仅C2支持)AD电压比较器(仅C1支持)脉宽测量脉冲计数自定义脉宽波形序列发生器(仅C2支持)内部Flash读写看门狗(WatchDog)关键调试信息获取(仅C2支持)产测工具相关函数(仅C2支持)工具库函数系统垃圾回收函数系统堆空间使用率统计函数系统日志函数系统复位函数系统唯一ID获取系统时间函数系统延时函数常用字符串处理函数常用校验算法函数Lua代码OTA接口函数常用字节转换函数
提示:查找某个函数时,可使用Ctrl+F搜索相应的函数名称
LIB_LedConfig(p1,p2,p3,p4,p5)
函数描述: LED(LED1~LED4)工作模式配置。注意:LED1~LED4是可以分配在任意D0~D11上的,由开发者自己定义 注意: 该函数只能调用一次
p1 | 需要配置的Led的标识 |
---|---|
"LED1" "LED2" "LED3" "LED4" |
p2 | 选择Led所占用的D端口号 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 点亮Led所需要的电平值,该值由LED的驱动电路所决定 |
---|---|
"L":低电平 "H":高电平 |
p4 | 设置LED在一个亮灭周期中亮的时间 |
---|---|
0-999999999毫秒 |
p5 | 设置LED在一个亮灭周期中灭的时间 |
---|---|
0-999999999毫秒 |
应用示例:
--设置LED2(占用D2端口)以0.2秒亮、0.2秒灭的节奏闪烁,另外假设Led灯是低电平驱动点亮
LIB_LedConfig("LED2","D2","L",200,200)
--LED2开始闪烁
LIB_LedStartWork("LED2")
LIB_LedStartWork(p1)
函数描述: Led开始闪烁
p1 | 需要开始工作的Led的标识 |
---|---|
"LED1" "LED2" "LED3" "LED4" |
应用示例:
xxxxxxxxxx
--设置LED2(占用D2端口)以0.2秒亮、0.2秒灭的节奏闪烁,另外假设Led灯是低电平驱动点亮
LIB_LedConfig("LED2","D2","L",200,200)
--LED2开始闪烁
LIB_LedStartWork("LED2")
LIB_LedStopWork(p1)
函数描述: Led停止闪烁
p1 | 需要停止工作的Led的标识 |
---|---|
"LED1" "LED2" "LED3" "LED4" |
应用示例:
xxxxxxxxxx
--LED2停止闪烁
LIB_LedStopWork("LED2")
LIB_ButtonConfig(p1,p2,p3)
函数描述: 按键(BTN1~BTN7)工作模式的配置。注意:BTN1~BTN8是可以分配在任意D0~D11上的,看你的心情。
p1 | 需要配置的按键的标识 |
---|---|
"BTN1" "BTN2" "BTN3" "BTN4" "BTN5" "BTN6" "BTN7" "BTN8" |
p2 | 选择按键所占用的D端口号 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 按键按下时检测到的有效电平值,该值由按键的电路所决定 |
---|---|
"L":低电平 "H":高电平 |
应用示例:
xxxxxxxxxx
--设置按键3(占用D1口)以低电平有效的方式检测按键动作
LIB_ButtonConfig("BTN3","D1","L")
r1 = LIB_ButtonQuery(p1)
函数描述: 检测按键(Btn1~Btn8)的动作
p1 | 需要检测的按键的标识 |
---|---|
"BTN1" "BTN2" "BTN3" "BTN4" "BTN5" "BTN6" "BTN7" "BTN8" |
r1 | 按键检测返回值 |
---|---|
0: 按键没按下 | |
1: 检测到按键短按动作(3秒之内弹起) | |
2: 检测到按键长按动作(3秒之后弹起) | |
3: 检测到按键持续按压(0.8秒~3秒) | |
4: 检测到按键持续按压(3秒以上) |
注意:当持续按压时,LIB_ButtonQuery会持续返回数值3或4,直到按键弹起后最终会返回一个数值1或2.
应用示例:
xxxxxxxxxx
--设置按键3(占用D0口),假设按键是低电平有效
LIB_ButtonConfig("BTN3","D0","L")
--设置按键4(占用D2口),假设按键是低电平有效
LIB_ButtonConfig("BTN4","D2","L")
--持续检测按键3和4是否有短按动作
while(true)
do
--查询按键3是否短按过
if LIB_ButtonQuery("BTN3") == 1 then
print("Button3 clicked")
end
--查询按键4是否长按过(按压超过3秒后松开)
if LIB_ButtonQuery("BTN4") == 2 then
print("Button4 long pressed")
end
--查询按键4是否一直长按中(持续按压(0.8秒~3秒))
if LIB_ButtonQuery("BTN4") == 3 then
print("Button4 short hold presse")
end
--查询按键4是否一直长按中(持续按压(3秒以上))
if LIB_ButtonQuery("BTN4") == 4 then
print("Button4 long hold presse")
end
end
LIB_0_96_OledConfig(p1)
函数描述: 配置0.96寸oled显示模块和core的连接端口,并初始化开始工作
p1 | oled模块占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
应用示例:
xxxxxxxxxx
--设置0.96寸oled模块占用SCL1和SDA1引脚
LIB_0_96_OledConfig("IIC1")
LIB_0_96_OledPuts(p1,p2,p3)
函数描述: 在p1行,p2列显示字符串。0.96寸oled整个屏幕可以容纳4行且每行长度不超过16列的ascii字符。
p1 | 行号 |
---|---|
"1","2","3","4" |
p2 | 列号 |
---|---|
"1","2","3","4","5","6","7","8" "9","10","11","12","13","14","15","16" |
p3 | 需要显示的字符串 |
---|---|
注意:列号加上字符串长度不能大于16,多出的部分会被截断 |
应用示例:
xxxxxxxxxx
--设置0.96寸oled模块占用SCL1和SDA1引脚
LIB_0_96_OledConfig("IIC1")
cnt = 0
while(true)
do
cnt = cnt + 1
LIB_DelayMs(1000)
--每隔1秒,在第2行的起始处(第1列)显示"cnt = xxxxx"字符串
LIB_0_96_OledPuts("2","1",string.format("cnt = %05d",cnt))
end
LIB_0_96_OledScreenClear()
函数描述: 清除整个屏幕的内容
应用示例:
xxxxxxxxxx
LIB_0_96_OledScreenClear()
LIB_LCD1602Config(p1)
函数描述: 配置LCD1602的连接端口,并初始化开始工作
p1 | IIc LCD1602模块占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
应用示例:
xxxxxxxxxx
--设置LCD1602模块占用SCL0和SDA0引脚
LIB_LCD1602Config("IIC0")
LIB_LCD1602Puts(p1,p2,p3,p4)
函数描述: 在p1行,p2列显示字符串。LCD1602整个屏幕可以容纳2行且每行长度不超过16列的ascii字符。
p1 | 行号 |
---|---|
"1","2","3","4" |
p2 | 列号 |
---|---|
"1","2","3","4","5","6","7","8" "9","10","11","12","13","14","15","16" |
p3 | 需要显示的字符串 |
---|---|
注意:列号加上字符串长度不能大于16,多出的部分会被截断 |
p4 | 背光灯是否打开 |
---|---|
"LightOn","LightOff" |
应用示例:
xxxxxxxxxx
--设置LCD1602模块占用SCL0和SDA0引脚
LIB_LCD1602Config("IIC0")
cnt = 1
while(true)
do
cnt = cnt + 1
LIB_DelayMs(100)
--每隔0.1秒,在第2行的起始处(第1列)显示"cnt = xxxxx"字符串
LIB_LCD1602Puts("2","1",string.format("cnt = %05d",cnt),"LightOn")
end
LIB_LCD1602ScreenClear()
函数描述: 清除整个屏幕的内容
应用示例:
xxxxxxxxxx
LIB_LCD1602ScreenClear()
r1,r2 = LIB_Fread(p1,p2)
函数描述: 从文件指定位置开始读取文件内容,一次读取256字节。注意调用该函数会阻塞程序。
p1 | 字符串型,文件名 |
---|---|
注意: 文件名不要超过8字节,后缀名不要超过3个字节 |
p2 | 整数型,读操作在文件中的起始位置 |
---|---|
以字节为单位 |
r1 | 整数型,返回本次读取的实际字节数 |
---|---|
r1=0,表示已经读到文件末尾或读操作失败 0<r1<256,表示已经读到文件末尾 r1=256,表示读取到256字节且还未到文件末尾 |
r2 | table型,包含实际读取到的内容 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--从main.lua文件的0地址处开始读取256字节
read_number, read_content = LIB_Fread("main.lua",0)
if read_number > 0 then
print(string.format("readed %d bytes", #read_content))
end
LIB_Fwrite(p1,p2)
函数描述: 将table内的数据从指定文件的末尾处写入
p1 | 字符串型,文件名 |
---|---|
注意: 文件名不要超过8字节,后缀名不要超过3个字节 |
p2 | table型 |
---|---|
table内的元素必须为字节型,元素个数不能超过256个 |
应用示例:
xxxxxxxxxx
--向"abc.txt"文件中写入一串整型数据
num_tab = {1,2,3,4,5}
LIB_Fwrite("abc.txt", num_tab)
LIB_Fdelete(p1)
函数描述: 删除文件
p1 | 字符串型,文件名 |
---|---|
注意: 文件名不要超过8字节,后缀名不要超过3个字节 |
应用示例:
xxxxxxxxxx
--删除文件"abc.txt"
LIB_Fdelete("abc.txt")
LIB_Fcache(p1,p2,p3)
函数描述: 缓存将要写入TF卡上文件的数据,当芯片内部4KB缓存将时,会自动将4K数据写入指定文件的末尾处, 注意1:该函数具有阻塞性 注意2:代码中使用该函数后,一定不要再使用print函数以及LIB_SystemLogEnable()函数了,因为会造成TF卡写入冲突。
p1 | 操作选择 |
---|---|
"Write" | 缓存将要写入文件的数据,当4KB缓存将时,会自动将4KB数据写入文件的末尾处并清空缓存,超出的数据将放至缓存起始位置 |
"Flush" | 立马将缓存中的数据写入文件,该功能可用于最后系统将要断电时及时保存剩余数据 |
p2 | 字符串型,文件名 |
---|---|
注意: 文件名不要超过8字节,后缀名不要超过3个字节 |
p3 | table型 |
---|---|
table内的元素必须为字节型,元素个数不能超过256个 |
应用示例:
xxxxxxxxxx
--向abc.txt文件中写入一串整型数据
num_tab = {1,2,3,4,5}
LIB_Fcache("Write", abc.txt", num_tab)
--将缓存中的数据立刻写入abc.txt文件
LIB_Fcache("Flush", abc.txt")
LIB_SegLedsAndMatrixKeysConfig(p1,p2,p3)
函数描述: 配置数码管矩阵键盘模块开始工作。
p1 | 模块DIO引脚所占用的端口号 |
---|---|
"D0","D1","D2","D3","D4","D5","D6","D7", "D8"已被Core的LED1占用,"D9"已被Core的LED2占用,"D10"已被Core的BTN1占用,"D11"已被Core的BTN2占用 |
p2 | 模块CLK引脚所占用的端口号 |
---|---|
"D0","D1","D2","D3","D4","D5","D6","D7", "D8"已被Core的LED1占用,"D9"已被Core的LED2占用,"D10"已被Core的BTN1占用,"D11"已被Core的BTN2占用 |
p3 | 模块STB引脚所占用的端口号 |
---|---|
"D0","D1","D2","D3","D4","D5","D6","D7", "D8"已被Core的LED1占用,"D9"已被Core的LED2占用,"D10"已被Core的BTN1占用,"D11"已被Core的BTN2占用 |
应用示例:
xxxxxxxxxx
--配置数码管矩阵键盘模块的引脚DIO,CLK,STB占用Core的D7,D6,D5引脚,并开始工作
LIB_SegLedsAndMatrixKeysConfig("D7","D6","D5")
r1,r2 = LIB_MatrixKeysRead()
函数描述: 查询矩阵键盘是否有按键按下,并返回按键值
r1 | 整数型,指示是否由按键按下 |
---|---|
0: 没有 1: 有 |
r2 | 整数型,按键值 |
---|---|
1-16 |
应用示例:
xxxxxxxxxx
--配置数码管矩阵键盘模块的引脚DIO,CLK,STB分别占用Core的D7,D6,D5引脚,并开始工作
LIB_SegLedsAndMatrixKeysConfig("D7","D6","D5")
--查询矩阵键盘是否有按键按下,如果有就print输出
while(true)
do
keypress_flag,key_pos = LIB_MatrixKeysRead()
if keypress_flag == 1 then
print(string.format("Key %d Pressed\r\n", key_pos))
end
end
LIB_SegLedsWrite(p1,p2,p3)
函数描述: 设置8位数码管需要显示的数值、小数位个数以及数码管亮度
p1 | 整数型,需要显示的数值 |
---|---|
数值的有效范围需要在-9999999,99999999之间,超过部分将截断 |
p2 | 字符串型,指示p1中的十进制数包含几个小数位 |
---|---|
"0","1","2","3","4","5","6" |
p3 | 字符串型,指示数码管显示亮度 |
---|---|
"LEVEL0","LEVEL1","LEVEL2", "LEVEL3","LEVEL4","LEVEL5", "LEVEL6","LEVEL7","LEVEL8" |
"LEVEL0"是完全灭掉,"LEVEL8"是最亮状态
应用示例:
xxxxxxxxxx
--设置数码管显示8位十进制数值12345.678,亮度为最亮
LIB_SegLedsWrite(12345678, "3", "LEVEL8")
LIB_FourSegLedsConfig(p1,p2)
函数描述: 配置TM1650四位数码管模块开始工作。
p1 | 模块DIO引脚所占用的端口号 |
---|---|
"D0","D1","D2","D3","D4","D5","D6","D7", "D8"已被Core的LED1占用,"D9"已被Core的LED2占用,"D10"已被Core的BTN1占用,"D11"已被Core的BTN2占用 |
p2 | 模块CLK引脚所占用的端口号 |
---|---|
"D0","D1","D2","D3","D4","D5","D6","D7", "D8"已被Core的LED1占用,"D9"已被Core的LED2占用,"D10"已被Core的BTN1占用,"D11"已被Core的BTN2占用 |
应用示例:
xxxxxxxxxx
--配置TM1650四位数码管模块的引脚DIO,CLK占用Core的D7,D6引脚,并开始工作
LIB_FourSegLedsConfig("D7","D6")
LIB_FourSegLedsNumWrite(p1,p2,p3)
函数描述: 设置8位数码管需要显示的数值、小数位个数以及数码管亮度
p1 | 整数型,需要显示的数值 |
---|---|
数值的有效范围需要在-999,9999之间,如果超过将显示极限值 |
p2 | 字符串型,指示p1中的十进制数包含几个小数位 |
---|---|
"0","1","2","3" |
p3 | 字符串型,指示数码管显示亮度 ,"L8"最亮 |
---|---|
"L1","L2","L3","L4","L5","L6","L7","L8" |
应用示例:
x--设置数码管显示数值123.4,亮度为最亮
LIB_FourSegLedsNumWrite(1234, "3", "L8")
--设置数码管显示数值-1,亮度为最亮
LIB_FourSegLedsNumWrite(-1, "0", "L8")
--设置数码管显示数值1,亮度为最暗
LIB_FourSegLedsNumWrite(1, "0", "L1")
LIB_FourSegLedsRawWrite(p1,p2,p3,p4,p5)
函数描述: 设置8位数码管需要显示的数值、小数位个数以及数码管亮度
p1 | 整数型,对应DIG4数码管的原始值 |
---|---|
例如显示值0-9,对应0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F |
p2 | 整数型,对应DIG3数码管的原始值 |
---|---|
例如显示值0-9,对应0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F |
p3 | 整数型,对应DIG2数码管的原始值 |
---|---|
例如显示值0-9,对应0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F |
p4 | 整数型,对应DIG1数码管的原始值 |
---|---|
例如显示值0-9,对应0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F |
p5 | 字符串型,指示数码管显示亮度 ,"L8"最亮 |
---|---|
"L1","L2","L3","L4","L5","L6","L7","L8" |
应用示例:
xxxxxxxxxx
--设置数码管显示1234,亮度为最亮
LIB_FourSegLedsRawWrite(0x06,0x5B,0x4F,0x66,"L8")
--设置数码管显示ABCD,亮度为最暗
LIB_FourSegLedsRawWrite(0x77,0x7C,0x39,0x5E,"L1")
LIB_RGBledConfig(p1,p2,p3)
函数描述: 配置共阴极RGB模块开始工作,模块的R,G,B引脚分别固定占用Core的D0,D1,D2引脚 p1,p2,p3这三个参数用来调整RGB Led白平衡用
p1 | 整数类型,R(红色亮度调整系数) |
---|---|
0%-100% 当您的RGB硬件模块中的红色Led灯偏暗或偏亮,可以调整该百分比系数 |
p2 | 整数类型,G(绿色亮度调整系数) |
---|---|
0%-100% 当您的RGB硬件模块中的绿色Led灯偏暗或偏亮,可以调整该百分比系数 |
p3 | 整数类型,B(蓝色(亮度调整系数)) |
---|---|
0%-100% 当您的RGB硬件模块中的蓝色Led灯偏暗或偏亮,可以调整该百分比系数 |
应用示例:
xxxxxxxxxx
--配置共阴极RGB模块开始工作,模块的R,G,B引脚分别固定占用Core的D0,D1,D2引脚
--三个100表示不调整三色比例,即不考虑白平衡的问题
LIB_RGBledConfig(100,100,100)
LIB_RGBledUpdate(p1,p2,p3)
函数描述: 更新RGB的颜色值
p1 | 整数类型,R(红色) |
---|---|
0-255 |
p2 | 整数类型,G(绿色) |
---|---|
0-255 |
p3 | 整数类型,B(蓝色) |
---|---|
0-255 |
应用示例:
xxxxxxxxxx
--配置共阴极RGB模块开始工作,模块的R,G,B引脚固定占用Core的D0,D1,D2引脚
LIB_RGBledConfig(100,100,100)
--更新RGB Led灯的色值为120,20,200
LIB_RGBledUpdate(120,20,200)
LIB_PCF8574Config(p1)
函数描述: 配置PCF8574模块占用Core的哪一个IIC端口,
p1 | IIc PCF8574占用core的引脚 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
应用示例:
xxxxxxxxxx
--设置PCF8574模块占用Core的SCL0和SDA0引脚
LIB_PCF8574Config("IIC0")
r1,r2 = LIB_PCF8574ReadPort(p1)
函数描述: 读取PCF8574的8个IO口的电平状态 注意:该函数每调用一次会耗时大概200us,这个耗时需要在您设计Lua代码时加以考虑
p1 | 整数类型,PCF8574器件的iic设备地址 |
---|---|
注意:PCF8574和PCF8574A的地址不一样,且它们芯片上的A0,A1,A2三个引脚的状态也决定了八种不同的地址 |
r1 | 整数型,指示是否正确读到端口电平 |
---|---|
0: IIc总线异常或PCF8574器件异常 1: 正确读到端口电平 |
r2 | 整数型,返回一个字节型的端口值(P0-P7) |
---|---|
字节中的最高位是P7 |
应用示例:
xxxxxxxxxx
--设置PCF8574模块占用Core的SCL0和SDA0引脚
LIB_PCF8574Config("IIC0")
--每隔0.3秒读取一次地址为0x27的PCF8574的端口值,如果正常读取到就print输出
while(true)
do
LIB_DelayMs(300)
ok,port = LIB_PCF8574ReadPort(0x27)
if ok == 1 then
print(string.format("Port Value: %02X\r\n", port))
else
print("Read fail, maybe caused by the iic error or device fault!\r\n")
end
end
r1 = LIB_PCF8574WritePort(p1,p2)
函数描述: 向PCF8574写入8个IO口的电平状态 注意:该函数每调用一次会耗时大概200us,这个耗时需要在您设计Lua代码时加以考虑
p1 | 整数类型,PCF8574器件的iic设备地址 |
---|---|
注意:PCF8574和PCF8574A的地址不一样,且它们芯片上的A0,A1,A2三个引脚的状态也决定了八种不同的地址 |
p2 | 整数型,需要写入的字节型的端口值(P0-P7) |
---|---|
字节中的最高位是P7 |
r1 | 整数型,指示是否正确写入端口电平 |
---|---|
0: IIc总线异常或PCF8574器件异常 1: 正确写入端口电平 |
应用示例:
xxxxxxxxxx
--设置PCF8574模块占用Core的SCL0和SDA0引脚
LIB_PCF8574Config("IIC0")
--每隔0.3秒向PCF8574写入端口值0xF0,即P0=P1=P2=P3=0,P4=P5=P6=P7=1
while(true)
do
LIB_DelayMs(300)
ok = LIB_PCF8574WritePort(0x27,0xF0)
if ok == 1 then
print("Write 0xF0 success\r\n")
else
print("Read fail, maybe caused by the iic error or device fault!\r\n")
end
end
LIB_WK2124Config(p1~p5)
函数描述: 配置WK2124模块开始工作,模块需要占用SPI的四个引脚以及由p5参数指定的一个GPIO口
p1 | UART1的串口波特率配置。当为"NONE"时,则不会开启UART1,为系统省掉一定的功耗 |
---|---|
"NONE","B600","B1200","B2400","B4800","B9600","B19200","B38400","B76800", "B1800","B3600","B7200","B14400","B28800","B57600","B115200","B230400" |
p2 | UART2的串口波特率配置。当为"NONE"时,则不会开启UART2,为系统省掉一定的功耗 |
---|---|
"NONE","B600","B1200","B2400","B4800","B9600","B19200","B38400","B76800", "B1800","B3600","B7200","B14400","B28800","B57600","B115200","B230400" |
p3 | UART3的串口波特率配置。当为"NONE"时,则不会开启UART3,为系统省掉一定的功耗 |
---|---|
"NONE","B600","B1200","B2400","B4800","B9600","B19200","B38400","B76800", "B1800","B3600","B7200","B14400","B28800","B57600","B115200","B230400" |
p4 | UART4的串口波特率配置。当为"NONE"时,则不会开启UART4,为系统省掉一定的功耗 |
---|---|
"NONE","B600","B1200","B2400","B4800","B9600","B19200","B38400","B76800", "B1800","B3600","B7200","B14400","B28800","B57600","B115200","B230400" |
p5 | WK2124模块的RST引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
应用示例:
xxxxxxxxxx
--配置WK2124模块开始工作,4个UART扩展口都开启,并且模块占用SPI(CS,MISO,MOSI,CLK)以及D5引脚
LIB_WK2124Config("B115200","B115200","B9600","B9600","D5")
r1,r2 = LIB_WK2124UartRecvQuery(p1)
函数描述: 查询某个"Uart(1~4)"口是否收到数据,并将收到的数据内容以table形式返回。 注意:发送端每次发送的数据不能超过256字节,并且建议发送间隔最好不要小于100ms
p1 | 需要查询的串口,"UARTn" |
---|---|
"UART1","UART2","UART3","UART4" |
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--配置WK2124模块开始工作,4个UART扩展口都开启,并且模块占用SPI(CS,MISO,MOSI,CLK)以及D5引脚
LIB_WK2124Config("B115200","B115200","B9600","B9600","D5")
while(true)
do
--查询Uart1是否收到数据,如果收到就print输出收到的数据
u1_flag,u1_tab = LIB_WK2124UartRecvQuery("UART1")
if u1_flag == 1 then
print("Uart1 Recv:")
--将从uart1串口收到的数据逐个打印出来
for i, v in ipairs(u1_tab) do
print(i, v)
end
end
--查询Uart2是否收到数据,如果收到就print输出收到的数据
u2_flag,u2_tab = LIB_WK2124UartRecvQuery("UART2")
if u2_flag == 1 then
print("Uart2 Recv:")
--将从uart2串口收到的数据逐个打印出来
for i, v in ipairs(u2_tab) do
print(i, v)
end
end
--查询Uart3是否收到数据,如果收到就print输出收到的数据
u3_flag,u3_tab = LIB_WK2124UartRecvQuery("UART3")
if u3_flag == 1 then
print("Uart3 Recv:")
--将从uar3串口收到的数据逐个打印出来
for i, v in ipairs(u3_tab) do
print(i, v)
end
end
--查询Uart4是否收到数据,如果收到就print输出收到的数据
u4_flag,u4_tab = LIB_WK2124UartRecvQuery("UART4")
if u4_flag == 1 then
print("Uart4 Recv:")
--将从uart4串口收到的数据逐个打印出来
for i, v in ipairs(u4_tab) do
print(i, v)
end
end
end
LIB_WK2124UartSend(p1,p2)
函数描述: 向某个"Uart(1~4)"口发送一串数据,注意数据个数不能超过256个
p1 | 需要发送的串口,"UARTn" |
---|---|
"UART1","UART2","UART3","UART4" |
p2 | table类型 |
---|---|
table内的元素必须为字节型,元素个数不能超过256个 |
应用示例:
xxxxxxxxxx
--配置WK2124模块开始工作,4个UART扩展口都开启,并且模块占用SPI(CS,MISO,MOSI,CLK)以及D5引脚
LIB_WK2124Config("B115200","B115200","B9600","B9600","D5")
send_table = {0x01,0x02,0x03,0x04,0x05,0x06} --要发送的数据
while(true)
do
--向Uart1发送一串数据
LIB_WK2124UartSend("UART1", send_table)
LIB_DelayMs(2000)
--向Uart2发送一串数据
LIB_WK2124UartSend("UART2", send_table)
LIB_DelayMs(2000)
--向Uart3发送一串数据
LIB_WK2124UartSend("UART3", send_table)
LIB_DelayMs(2000)
--向Uart4发送一串数据
LIB_WK2124UartSend("UART4", send_table)
LIB_DelayMs(2000)
end
LIB_AM1805Config(p1)
函数描述: 配置AM1805低功耗模块占用Core的哪一个IIC端口
p1 | IIc AM1805占用core的引脚 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
应用示例:
xxxxxxxxxx
--设置AM1805模块占用Core的SCL0和SDA0引脚
LIB_AM1805Config("IIC0")
LIB_AM1805Sleep(p1,p2)
函数描述: 配置AM1805断掉外部系统的电源开始休眠,默认在休眠时间到后唤醒,但也可以增加外部信号唤醒方式。
p1 | 休眠时间 |
---|---|
单位:秒,注意:该值最大值不能超过255*60=15300秒,既255分钟的休眠时间,最小不能低于3秒 |
p2 | 外部信号唤醒方式 |
---|---|
"NONE": 不使用外部信号唤醒 "RISE":上升沿唤醒 "FALL":下降沿唤醒 |
注意:调用LIB_AM1805Sleep()函数前请确保MCU至少已上电1.5秒以上,不然无法正常休眠
应用示例:
xxxxxxxxxx
--设置AM1805模块占用Core的SCL0和SDA0引脚
LIB_AM1805Config("IIC0")
print("power up")
while(GC(1) == true)
do
--5秒钟后断电,休眠10秒再唤醒
LIB_DelayMs(5000)
print("power down")
--设置AM1805模块开始休眠并断掉系统的电,10秒后唤醒,如果休眠
--中途检测到上升沿信号,则立刻唤醒
LIB_AM1805Sleep(10, "RISE")--此时系统将掉电,后面的代码都不再有效了
--mcu lost power from there
end
LIB_SYN6288Config(p1,p2)
函数描述: 配置SYN6288语音模块占用的UART端口,以及需要播放的文字的编码
p1 | SYN6288的UART占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | 需要播放的文本的编码信息 |
---|---|
"GB2312" "GBK" "BIG5" "UNICODE" |
应用示例:
xxxxxxxxxx
--设置SYN6288模块占用TX0、RX0引脚,文本编码为GB2312
LIB_SYN6288Config("UART0","GB2312")
LIB_SYN6288Play(p1)
函数描述: 开始语音播放p1参数所包含的文本内容
p1 | 字符串型,需要播放的语音文字 |
---|---|
字符串长度不能超过200个字节,注意:一个汉字一般占用两个字节 |
应用示例:
xxxxxxxxxx
--设置SYN6288模块占用TX0、RX0引脚,文本编码为GB2312
LIB_SYN6288Config("UART0","GB2312")
while(true)
do
--每隔10秒播放“你好,欢迎光临”
LIB_SYN6288Play("你好,欢迎光临")
LIB_DelayMs(10000)
end
LIB_SYN6288Stop()
函数描述: 停止正在播放的语音内容
应用示例:
xxxxxxxxxx
--停止正在播放的语音内容
LIB_SYN6288Stop()
LIB_LD3320Config(p1,p2,p3,p4)
函数描述: 配置语音识别模块开始工作,以及RST引脚占用Core的端口号
p1 | 模块RST引脚所占用的端口号 |
---|---|
"D0","D1","D2","D3","D4","D5","D6","D7", "D8"已被Core的LED1占用,"D9"已被Core的LED2占用,"D10"已被Core的BTN1占用,"D11"已被Core的BTN2占用 |
p2 | 麦克风音量 ,整数型,值范围必须在0x00~0x7F |
---|---|
值越大代表MIC音量越大,识别启动越敏感,但可能带来更多误识别。 值越小代表MIC音量越小,需要近距离说话才能启动识别功能,好处是对远处的干扰语音没有反应 |
p3 | table类型 要识别的这些短语的代号 |
---|---|
table内的元素必须为字节型,元素个数不能超过50个 |
p4 | table类型 要识别的这些短语 |
---|---|
table内的元素必须为字符串型,元素个数不能超过50个 |
p2需要注意的地方: 注意1:在正常生活条件下的室内环境和比较安静的室外环境,建议设置值为 40H-55H;使用距离在 0.5 米以上为好,避免声音录入产生过激。 注意2:在十分嘈杂的环境中,比如展览会现场,建议设置值为10H-2FH;此时需要使用者嘴巴距离MIC距离为 0~50 厘米以内。
应用示例:
xxxxxxxxxx
--PhraseCode是需要识别的短语的代号,例如识别到用户说"右边"时,我们会得到短语的代号"3"
PhraseCode = {1, 2, 3, 4, 5, 6} --注意: 元素个数不能超过50个!
--Phrase是需要识别的短语,每个短语的长度不能超过79个字节(包含拼音之间的空格)
Phrase = {"ni hao", "zuo bian", "you bian", "quan bu liang", "quan bu mie", "zai jian"} --注意: 元素个数不能超过50个!
--配置LD3320语音识别模块的引脚RST占用Core的D7引脚以及SPI接口,麦克风音量0x43
LIB_LD3320Config("D7",0x43,PhraseCode,Phrase)
r1,r2 = LIB_LD3320GetResult()
函数描述: 查询是否有有效短语识别结果 注意:该函数必须是在检测到模块的IRQ引脚有下降沿信号时才能被调用
r1 | 整数型,指示是否有有效短语被识别到 |
---|---|
0: 没有 1: 有 |
r2 | 整数型,有效的短语识别码 |
---|---|
该短语识别码就是开发者在LIB_LD3320Config函数中传入的P3参数中的编码 |
应用示例:
xxxxxxxxxx
Flag,PhraseCode = LIB_LD3320GetResult()
if Flag == 1 then
print("The detected phrase code is: %d", PhraseCode)
end
Res,Info=LIB_EspCamOp(p1,...)
函数描述: 向Esp32Cam板子下发各种指令,并返回指令的执行结果 注意: 调用该函数会造成Lua应用代码阻塞一段时间,具体时间取决于不同指令的操作,开发者需注意。
p1 | 字符串类型,操作指令 |
---|---|
"Config","PostPhoto","SavePhote","WifiStatus","LedOn","LedOff" | |
每种不同指令p1时,函数LIB_EspCamOp()的输入参数个数和函数返回值意义也不一样,下面会根据不同使用场景来介绍该函数的用法 |
开发者可以选择将Esp32Cam配置成如下四种场景功能之一: (一)Esp32Cam配置成本地相机工作 (二)Esp32Cam配置成远程相机工作 (三)Esp32Cam配置成Web camera模式工作 (四)Esp32Cam配置成Web server camera模式工作(不仅有视频流,还可以远程控制和采集传感器) 下面开始逐一介绍每种工作模式,开发者只需看自己感兴趣的工作模式
(一)当Esp32Cam配置成本地相机工作时:
初始化 | 函数介绍 |
---|---|
函数用法示例 | Res,Info=LIB_EspCamOp("Config","LOCAL_PHOTO","UART0") |
函数意义 | 配置Esp32Cam为本地相机功能,该函数调用成功后,即可通过LIB_EspCamOp("SavePhote","xxx")来执行拍照并自动将图片存入ESP32CAM板子上的SD卡中 |
参数介绍
"Config": 表示开始进入配置流程。
"LOCAL_PHOTO": 表示将Esp32Cam配置成本地相机功能。
"UART0": 表示Core通过UART0(Tx0,Rx0)接口和Esp32Cam进行连接,也可以是"UART1"。
HW: table类型,必须包含4个元素的字符串,定义如下:
xxxxxxxxxx
HW =
{
"MySsid",--Wifi账号,这里其实用不上,随便写即可
"MyPassword",--Wifi密码,这里其实用不上,随便写即可
"FRAMESIZE_SVGA",--摄像头采集图片尺寸为SVGA,SVGA:800*600,尽量不要高于SVGA
"12"--摄像头采集图片的质量为12,必须为"1"~"63",其中"1"质量最高
}
附注:上面的FRAMESIZE可以配置为如下种类:
FRAMESIZE_QQVGA:160*120
FRAMESIZE_QCIF:176*144
FRAMESIZE_HQVGA:240*176
FRAMESIZE_QVGA:320*240
FRAMESIZE_CIF:400*296
FRAMESIZE_VGA:640*400
FRAMESIZE_SVGA:800*600
FRAMESIZE_XGA:1024*768
FRAMESIZE_SXGA:1280*1024
FRAMESIZE_UXGA:1600*1200
FRAMESIZE_QXGA:2048*1536
返回值介绍
Res: 返回1表示成功,可以忽略下面的Info,返回0表示失败,可以打印Info信息来定位失败原因
Info:失败原因,可能是下面的其中一个
xxxxxxxxxx
"Uart time out": Core和Esp32Cam板子通信失败
"ack SD Card Mount Failed, esp will reset": 这种情况建议Core也跟着重启
"ack No SD Card attached, esp will reset": 这种情况建议Core也跟着重启
"ack cam init fail, esp will reset": 这种情况建议Core也跟着重启
拍照并本地保存 | 函数介绍 |
---|---|
函数用法示例 | Res,Info=LIB_EspCamOp("SavePhote","abc") |
函数意义 | 当配置Esp32Cam为本地相机功能后,调用该函数可以用来触发采集一张图片并保存到ESP32CAM的SD卡上面,比如文件名abc.jpg |
返回值介绍
Res: 返回1表示成功,可以忽略下面的Info,返回0表示失败,可以打印Info信息来定位失败原因
Info:失败原因,可能是下面的其中一个
xxxxxxxxxx
"Uart time out": Core和Esp32Cam板子通信失败
"ack cam capture fail, esp will reset": 这种情况建议Core也跟着重启
"ack Failed to open file in writing mode, esp will reset": 这种情况建议Core也跟着重启
(二)当Esp32Cam配置成远程相机工作时:
初始化 | 函数介绍 |
---|---|
函数用法示例 | Res,Info=LIB_EspCamOp("Config","REMOTE_PHOTO","UART0",HW,IP,SERVER,H1,H2,H3) |
函数意义 | 配置Esp32Cam为远程相机功能,该函数调用成功后,即可通过LIB_EspCamOp("PostPhoto"...)来执行拍照并自动http post将图片发送给远程http server |
参数介绍
"Config": 表示开始进入配置流程。
"REMOTE_PHOTO": 表示将Esp32Cam配置成远程相机功能。
"UART0": 表示Core通过UART0(Tx0,Rx0)接口和Esp32Cam进行连接,也可以是"UART1"。
HW: table类型,必须包含4个元素的字符串,定义如下:
xxxxxxxxxx
HW =
{
"MySsid",--Wifi账号
"MyPassword",--Wifi密码
"FRAMESIZE_SVGA",--摄像头采集图片尺寸为SVGA,SVGA:800*600,尽量不要高于SVGA
"12"--摄像头采集图片的质量为12,必须为"1"~"63",其中"1"质量最高
}
附注:上面的FRAMESIZE可以配置为如下种类:
FRAMESIZE_QQVGA:160*120
FRAMESIZE_QCIF:176*144
FRAMESIZE_HQVGA:240*176
FRAMESIZE_QVGA:320*240
FRAMESIZE_CIF:400*296
FRAMESIZE_VGA:640*400
FRAMESIZE_SVGA:800*600
FRAMESIZE_XGA:1024*768
FRAMESIZE_SXGA:1280*1024
FRAMESIZE_UXGA:1600*1200
FRAMESIZE_QXGA:2048*1536
IP: table类型,必须包含5个元素的字符串,定义如下:
xxxxxxxxxx
IP =
{
"Dynamic",--表示动态IP模式,动态IP模式下,忽略下面5项,"Static"时需要配置下面5项
"0.0.0.0",--本机IP地址
"0.0.0.0",--gateway地址
"0.0.0.0",--subnet地址
"0.0.0.0",--首选DNS地址
"0.0.0.0"--次选DNS地址
}
SERVER: table类型,必须包含2个元素的字符串,定义如下:
xxxxxxxxxx
SERVER =
{
"xxx.com",--服务器地址
"80"--服务器端口号
}
H1: table类型,H1是Http Post发送图片的Header的前一部分内容,具体内容开发者自定义,但每行不要超过256个字符:
xxxxxxxxxx
H1 =
{
"POST /api/xxx/yyy?deviceno=123456789 HTTP/1.1\r\n",
"Host: xxx.com\r\n",
"User-Agent: ...\r\n",
"Accept: ... \r\n",
"Accept-Encoding: ...\r\n",
"Connection: ...\r\n",
"Content-Type: ...; boundary=123456789000000000987654321\r\n",
"Content-Length: %d\r\n\r\n"
}
注意0:上面的内容只是示例,具体内容需开发者根据实际情况来定
注意1:上面的deviceno可以换成设备的唯一ID号,这样方便了server端可以识别Post消息的来源
注意2:上面的Content-Length: 后面的%d不要删除,会自动填充 H2 + 图片大小 + H3的和
H2: table类型,H2是Http Post发送图片的Header的后一部分内容,具体内容开发者自定义,但每行不要超过256个字符:
xxxxxxxxxx
H2 =
{
"--123456789000000000987654321\r\n",
"Content-Disposition: form-data; name=\"file\"; filename=\"esp32-cam.jpg\"\r\n",
"Content-Type: application/octet-stream;chartset=UTF-8\r\n\r\n"
}
注意0:上面的内容只是示例,具体内容需开发者根据实际情况来定
H3: string类型,H3是http消息中的boundary,需要和上面H1和H2中的保持相同:
xxxxxxxxxx
H3 = "--123456789000000000987654321--"
注意:上面的内容只是示例,具体内容需开发者根据实际情况来定
返回值介绍
Res: 返回1表示成功,可以忽略下面的Info,返回0表示失败,可以打印Info信息来定位失败原因
Info:失败原因,可能是下面的其中一个
xxxxxxxxxx
"Uart time out": Core和Esp32Cam板子通信失败
"ack staticIP STA config failed, esp will reset": 这种情况建议Core也跟着重启
"ack cam init fail, esp will reset": 这种情况建议Core也跟着重启
"ack para not surport": 这种情况开发者请检查一下传入函数的参数是否在规定范围之内
拍照并上传 | 函数介绍 |
---|---|
函数用法示例 | Res,Info=LIB_EspCamOp("PostPhoto","{","}",2000,300) |
函数意义 | 当配置Esp32Cam为远程相机功能后,调用该函数可以用来触发采集一张图片并上传给服务器 |
当等待服务器响应时间设置的大于零时,比如上面的2000ms时,会在2秒内等待服务器返回包含"{"和"}"部分的消息,比如服务器返回的"{"和"}"中的json消息体 | |
当等待服务器响应时间设置的等于零时,则不等待服务器返回消息,发送万图片后就直接退出函数 | |
另外上面的300表示摄像头在采集图像之前提前300ms打开闪光灯,如果该值为0则不打开摄像头 |
返回值介绍
Res: 返回1表示成功,可以忽略下面的Info,返回0表示失败,可以打印Info信息来定位失败原因
Info:失败原因,可能是下面的其中一个
xxxxxxxxxx
"Uart time out": Core和Esp32Cam板子通信失败
"ack cam capture fail, esp will reset": 这种情况建议Core也跟着重启
"ack got entire http resp timeout": 在预期时间,比如上面的2000ms内没有收到包含"{"和"}"的消息体
"ack connect to server fail": Esp32Cam无法和服务器建立连接
"ack wifi not connected": Esp32Cam没有接入Wifi网络
(三)当Esp32Cam配置成Web camera模式工作时:
初始化 | 函数介绍 |
---|---|
函数用法示例 | Res,Info=LIB_EspCamOp("Config","WEB_VEDIO","UART0",HW,IP,SERVER,H1,H2,H3) |
函数意义 | 配置Esp32Cam为网络摄像机WebServer功能,该函数调用成功后,Esp32Cam即可在本地局域网变成一台IP camera |
参数介绍
"Config": 表示开始进入配置流程。
"WEB_VEDIO": 表示将Esp32Cam配置成网络摄像机WebServer纯视频流功能。
"UART0": 表示Core通过UART0(Tx0,Rx0)接口和Esp32Cam进行连接,也可以是"UART1"。
HW: table类型,必须包含4个元素的字符串,定义如下:
xxxxxxxxxx
HW =
{
"MySsid",--Wifi账号
"MyPassword",--Wifi密码
"FRAMESIZE_SVGA",--摄像头采集图片尺寸为SVGA,SVGA:800*600,尽量不要高于SVGA
"12"--摄像头采集图片的质量为12,必须为"1"~"63",其中"1"质量最高
}
附注:上面的FRAMESIZE可以配置为如下种类:
FRAMESIZE_QQVGA:160*120
FRAMESIZE_QCIF:176*144
FRAMESIZE_HQVGA:240*176
FRAMESIZE_QVGA:320*240
FRAMESIZE_CIF:400*296
FRAMESIZE_VGA:640*400
FRAMESIZE_SVGA:800*600
FRAMESIZE_XGA:1024*768
FRAMESIZE_SXGA:1280*1024
FRAMESIZE_UXGA:1600*1200
FRAMESIZE_QXGA:2048*1536
IP: table类型,必须包含5个元素的字符串,定义如下:
xxxxxxxxxx
IP =
{
"Dynamic",--表示动态IP模式,动态IP模式下,忽略下面5项,"Static"时需要配置下面5项
"0.0.0.0",--本机IP地址
"0.0.0.0",--gateway地址
"0.0.0.0",--subnet地址
"0.0.0.0",--首选DNS地址
"0.0.0.0"--次选DNS地址
}
SERVER: table类型,必须包含2个元素的字符串,定义如下:
xxxxxxxxxx
SERVER =
{
"80"--本机视频流Web Server端口号
}
H1: table类型,H1是Web Server 回复客户端的http header
xxxxxxxxxx
H1 =
{
"multipart/x-mixed-replace;boundary=123456789000000000987654321"
}
注意0:上面的内容只是示例,具体内容需开发者根据实际情况来定
H2: table类型,H2是Web Server 回复客户端的图片信息描述,每行不要超过256个字符:
xxxxxxxxxx
H2 =
{
"Content-Type: image/jpeg\r\nContent-Length: %d\r\n\r\n"
}
注意0:上面的内容只是示例,具体内容需开发者根据实际情况来定
注意1:上面的Content-Length: 后面的%d不要删除,会自动填充图片大小
H3: string类型,H3是http消息中的boundary,需要和上面H1中的保持相同:
xxxxxxxxxx
H3 = "\r\n--123456789000000000987654321\r\n"
注意:上面的内容只是示例,具体内容需开发者根据实际情况来定
返回值介绍
Res: 返回1表示成功,可以忽略下面的Info,返回0表示失败,可以打印Info信息来定位失败原因
Info:失败原因,可能是下面的其中一个
xxxxxxxxxx
"Uart time out": Core和Esp32Cam板子通信失败
"ack staticIP STA config failed, esp will reset": 这种情况建议Core也跟着重启
"ack cam init fail, esp will reset": 这种情况建议Core也跟着重启
"ack web server httpd_start() fail, return code=xx":Http server开启失败
"ack para not surport": 这种情况开发者请检查一下传入函数的参数是否在规定范围之内
(四)当Esp32Cam配置成Web server camera模式工作时:
初始化 | 函数介绍 |
---|---|
函数用法示例 | Res,Info=LIB_EspCamOp("Config","WEB_VEDIO_ENHANCE","UART0",HW,IP,SERVER,H1,H2,H3) |
函数意义 | 配置Esp32Cam为网络摄像机WebServer功能,并且提供html网页服务,该函数调用成功后,Esp32Cam不仅可在本地局域网变成一台IP Camera,且可通过Web网页服务实现更多控制。比如在获取视频流的同时也可获取传感器数据或者控制继电器舵机动作等等 |
参数介绍
"Config": 表示开始进入配置流程。
"WEB_VEDIO_ENHANCE": 表示将Esp32Cam配置成网络摄像机WebServer增强版。
"UART0": 表示Core通过UART0(Tx0,Rx0)接口和Esp32Cam进行连接,也可以是"UART1"。
HW: table类型,必须包含4个元素的字符串,定义如下:
xxxxxxxxxx
HW =
{
"MySsid",--Wifi账号
"MyPassword",--Wifi密码
"FRAMESIZE_SVGA",--摄像头采集图片尺寸为SVGA,SVGA:800*600,尽量不要高于SVGA
"12"--摄像头采集图片的质量为12,必须为"1"~"63",其中"1"质量最高
}
附注:上面的FRAMESIZE可以配置为如下种类:
FRAMESIZE_QQVGA:160*120
FRAMESIZE_QCIF:176*144
FRAMESIZE_HQVGA:240*176
FRAMESIZE_QVGA:320*240
FRAMESIZE_CIF:400*296
FRAMESIZE_VGA:640*400
FRAMESIZE_SVGA:800*600
FRAMESIZE_XGA:1024*768
FRAMESIZE_SXGA:1280*1024
FRAMESIZE_UXGA:1600*1200
FRAMESIZE_QXGA:2048*1536
IP: table类型,必须包含5个元素的字符串,定义如下:
xxxxxxxxxx
IP =
{
"Dynamic",--表示动态IP模式,动态IP模式下,忽略下面5项,"Static"时需要配置下面5项
"0.0.0.0",--本机IP地址
"0.0.0.0",--gateway地址
"0.0.0.0",--subnet地址
"0.0.0.0",--首选DNS地址
"0.0.0.0"--次选DNS地址
}
SERVER: table类型,必须包含2个元素的字符串,定义如下:
xxxxxxxxxx
SERVER =
{
"80"--本机视频流Web http Server端口号
"81"--本机视频流端口号
}
H1: table类型,H1是Web Server 回复客户端的视频流http header
xxxxxxxxxx
H1 =
{
"multipart/x-mixed-replace;boundary=123456789000000000987654321"
}
注意0:上面的内容只是示例,具体内容需开发者根据实际情况来定
H2: table类型,H2是Web Server 回复客户端的图片信息描述,每行不要超过256个字符:
xxxxxxxxxx
H2 =
{
"Content-Type: image/jpeg\r\nContent-Length: %d\r\n\r\n"
}
注意0:上面的内容只是示例,具体内容需开发者根据实际情况来定
注意1:上面的Content-Length: 后面的%d不要删除,会自动填充图片大小
H3: string类型,H3是http消息中的boundary,需要和上面H1中的保持相同:
xxxxxxxxxx
H3 = "\r\n--123456789000000000987654321\r\n"
注意:上面的内容只是示例,具体内容需开发者根据实际情况来定
返回值介绍
Res: 返回1表示成功,可以忽略下面的Info,返回0表示失败,可以打印Info信息来定位失败原因
Info:失败原因,可能是下面的其中一个
xxxxxxxxxx
"Uart time out": Core和Esp32Cam板子通信失败
"ack staticIP STA config failed, esp will reset": 这种情况建议Core也跟着重启
"ack cam init fail, esp will reset": 这种情况建议Core也跟着重启
"ack SD Card Mount Failed, esp will reset":这种情况建议Core也跟着重启
"ack No SD Card attached, esp will reset":这种情况建议Core也跟着重启
"ack error, file %s must not larger than 10240 bytes":SD卡中的.html太大,超过10K了
"ack failed to open %s":无法打开SD卡上的html文件
"ack httpd_start() web_httpd fail, err=%d, esp will reset":Http server开启失败,这种情况建议Core也跟着重启
"ack httpd_start() stream_httpd fail, err=%d, esp will reset":Http 视频流服务开启失败,这种情况建议Core也跟着重启
"ack para not surport": 这种情况开发者请检查一下传入函数的参数是否在规定范围之内
(五)其他:
查询WFIF状态 | 函数介绍 |
---|---|
函数用法示例 | Res,Info=LIB_EspCamOp("WifiStatus") |
函数意义 | 查询Wifi状态 |
返回值介绍
Res: 返回1表示Wifi成功连上,返回0表示没连接上Wifi
Info:当Res=1时,Info包含分配的动态IP或者静态IP地址字符串(比如:192.168.1.55); 当Res=0时,Info包含Wifi的状态字符串
xxxxxxxxxx
Wifi的状态字符串可能是如下一种:
Uart time out
WL_CONNECTED
WL_NO_SHIELD
WL_IDLE_STATUS
WL_NO_SSID_AVAIL
WL_SCAN_COMPLETED
WL_CONNECT_FAILED
WL_CONNECTION_LOST
WL_DISCONNECTED
UNKONW_ERROR
打开摄像头闪光灯 | 函数介绍 |
---|---|
函数用法示例 | Res,Info=LIB_EspCamOp("LedOn") |
函数意义 | 调用该函数后,Esp32Cam板子上的闪光灯会打开。注意该灯不适合长期打开 |
返回值介绍
关闭摄像头闪光灯 | 函数介绍 |
---|---|
函数用法示例 | Res,Info=LIB_EspCamOp("LedOff") |
函数意义 | 调用该函数后,Esp32Cam板子上的闪光灯会关闭 |
返回值介绍
Esp32Cam软复位 | 函数介绍 |
---|---|
函数用法示例 | Res,Info=LIB_EspCamOp("Reset") |
函数意义 | 调用该函数后,过200ms,Esp32Cam会自动执行复位操作 |
返回值介绍
更新Webserver状态 | 函数介绍 |
---|---|
函数用法示例 | Res,Info=LIB_EspCamOp("WebserverUpdate","{"abc":"1"}") |
函数意义 | 当工作模式设置为WEB_VEDIO_ENHANCE时,调用该函数后,会将输入参数中的json字符串数据更新至Esp32Cam webserver,这样用户通过Web网页可以看到相应的数值发生变化,同时用户通过Web网页客户端发来的cmd指令也会体现在该函数的返回结果中 |
返回值介绍
LIB_NrfBleDefaultConfig(p1)
函数描述: 按默认参数配置蓝牙,如果对默认参数的值感兴趣,可查看LIB_NrfBleAdvanceConfig里的应用示例,里面的参数即为默认参数 注意: 如果你的项目中同时用到USB功能时,一定要先调用本函数初始化蓝牙之后,再调用LIB_UsbConfig()函数。
p1 | 蓝牙设备名称,即在手机扫描蓝牙设备时列表上显示的设备名字 |
---|---|
字符串型,长度不要超过32字节 |
service描述: service包含两个特性(Characteristic): 一个用来发送数据,一个用来接收数据
- Rx Characteristic (UUID: 0x0002)用来接收手机的数据 手机蓝牙可以通过ATT Write方式向Rx Characteristic发送数据
- Tx Characteristic (UUID: 0x0003)用来向手机发送数据 如果手机蓝牙为Tx Characteristic使能了notification,那么设备就可以通过发送notification的方式向手机蓝牙发送数据
应用示例:
xxxxxxxxxx
--配置低功耗蓝牙以默认参数工作,设备名称为"MyBle001"
LIB_NrfBleDefaultConfig("MyBle001")
LIB_NrfBleAdvanceConfig(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12)
函数描述: 按指定参数配置蓝牙 注意: 如果你的项目中同时用到USB功能时,一定要先调用本函数初始化蓝牙之后,再调用LIB_UsbConfig()函数。
p1 | 蓝牙设备名称,即在手机扫描蓝牙设备时列表上显示的设备名字。字符串类型,不要超过32字节 |
---|---|
p2 | The advertising interval 蓝牙广播间隔,整数型,单位ms |
p3 | The advertising duration 蓝牙广播持续时长,整数型,单位ms |
p4 | Minimum acceptable connection interval 最小通信间隔,整数型,单位ms |
p5 | Maximum acceptable connection interval 最大通信间隔,整数型,单位ms |
p6 | Slave latency 忽略通信间隔次数,整数型 |
p7 | Connection supervisory timeout 连接失效时间,整数型,单位ms |
p8 | The first connect params_update delay 第一次和手机请求参数更新的时间点,整数型,单位ms |
p9 | The next connect params_update delay 下一次和手机请参数更新的时间点,整数型,单位ms |
p10 | Number of attempts before giving up the connection parameter negotiation,整数型,单位ms |
p11 | uuid类型,整数型,1: 16-bit,2: 128-bit 。注意: 目前仅支持16bit |
p12 | service uuid值, 16bit整数型 |
service描述: service包含两个特性(Characteristic): 一个用来发送数据,一个用来接收数据
- Rx Characteristic (UUID: 0x0002)用来接收手机的数据 手机蓝牙可以通过ATT Write方式向Rx Characteristic发送数据
- Tx Characteristic (UUID: 0x0003)用来向手机发送数据 如果手机蓝牙为Tx Characteristic使能了notification,那么设备就可以通过发送notification的方式向手机蓝牙发送数据
应用示例:
xxxxxxxxxx
--按如下指定参数配置低功耗蓝牙工作:
--设备名称为"MyBle001",广播间隔40ms,广播时长180秒循环广播
--最小连接间隔20ms,最大75ms,0间隔忽略,连接失效时间4秒
--第一次请求参数更新时间5秒,之后每次间隔30秒,尝试请求参数更新次数最多3次就放弃
--uuid类型为16bit,service uuid = 0x0001
LIB_NrfBleAdvanceConfig("MyBle001",40,18000,20,75,0,4000,5000,30000,3,1,0x0001)
r1,r2 = LIB_NrfBleRecv()
函数描述: 查询是否收到蓝牙数据,如果收到数据则返回接收到的蓝牙数据
r1 | 整数型,指示是否收到蓝牙数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到蓝牙的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--配置低功耗蓝牙以默认参数工作,设备名称为"MyBle001"
LIB_NrfBleDefaultConfig("MyBle001")
--查询是否收到蓝牙数据,如果收到就print输出
while(true)
do
recv_flag,recv_tab = LIB_NrfBleRecv()
if recv_flag == 1 then
print(string.format("receive %d bytes", #recv_tab))
end
end
LIB_NrfBleSend(p1)
函数描述: 将table p1中的数据通过蓝牙发送出去
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于255个 为了兼容性建议不超过20个,因为Ble4.0最大包为20个字节 |
应用示例:
xxxxxxxxxx
--配置低功耗蓝牙以默认参数工作,设备名称为"MyBle001"
LIB_NrfBleDefaultConfig("MyBle001")
table = {1,2,3,4,5}
while(true)
do
--每隔3秒发送一次数据
LIB_NrfBleSend(table)
LIB_DelayMs(3000)
end
r1 = LIB_NrfBleConnectQuery()
函数描述: 查询是否已和手机蓝牙建立连接
r1 | 整数型,指示是否建立连接 |
---|---|
0: 未连接 1: 已经连上 |
应用示例:
xxxxxxxxxx
--配置低功耗蓝牙以默认参数工作,设备名称为"MyBle001"
LIB_NrfBleDefaultConfig("MyBle001")
while(true)
do
--每隔3秒查询一次是否已和手机蓝牙建立连接
LIB_DelayMs(3000)
if LIB_NrfBleConnectQuery() == 1 then
print("ble connected")
end
end
LIB_NrfBleIbeaconConfig(p1,p2,p3,p4,p5,p6)
函数描述: 按指定参数配置iBeacon蓝牙广播数据的具体内容,并开始工作 注意: 如果你的项目中同时用到USB功能时,一定要先调用本函数初始化iBeacon蓝牙之后,再调用LIB_UsbConfig()函数。
p1 | CompanyID:整数值, 范围:0x0000~0xFFFF, 其中 0x004C 代表的是Apple id(只有这个 ID,设备才会叫 iBeacon) |
---|---|
p2 | Major: 由 iBeacon 开发者自行设定,是16位的标识符, 例如可以用Major表示表示家电产品的型号 |
p3 | Minor:由 iBeacon 开发者自行设定,是16位的标识符, 例如表示错误代码,用来向外部通知故障、传感器值等 |
p4 | rssi_1m:厂家校准参数,APP通过iBeacon发送信号强度估算出的在 1 米的时候RSSI强度,例如0xC3 = -59db,该值更多的时候只是一个大概的值即可。 |
p5 | adv_interval_ms:设置iBeacon广播间隔,100ms-10240ms |
p6 | uuid:为table类型的iBeacon广播uuid信息,table的元素必须为16个,uuid规定为 ISO/IEC11578:1996 标准的 128 位标识符 |
应用示例:
xxxxxxxxxx
--这里为了实验目的,任意定义了16个数据为作为uuid
uuid = {0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF}
--初始化iBeacon广播信息具体内容,并开启iBeacon蓝牙广播,注意:该函数只能调用一次
--CompanyID=0x004C, Major=0x1234, Minor=0x5678, rssi_1m=0xC3(-59db), 广播间隔=100ms
LIB_NrfBleIbeaconConfig(0x004C,0x1234,0x5678,0x3C,100,uuid)
LIB_NrfBleIbeaconUpdate(p1,p2)
函数描述: beacon开启之后,可以通过本函数来实时设置beacon蓝牙广播中Major和Minor的值,
p1 | Major: 由 iBeacon 开发者自行设定,是16位的标识符, 例如可以用Major表示表示家电产品的型号 |
---|---|
p2 | Minor:由 iBeacon 开发者自行设定,是16位的标识符, 例如表示错误代码,用来向外部通知故障、传感器值等 |
应用示例:
xxxxxxxxxx
var1 = 0x1234
var2 = 0x5678
LIB_NrfBleIbeaconUpdate(var1,var2)
LIB_MeshConfig(p1,p2,p3)
函数描述: 配置设备的网络参数,如果设备是网络中的第一个节点,则自动形成Mesh网络,否则加入已存在的Mesh网络。 PanID参数和Channel参数用来决定加入哪个网络,并保证网络的唯一性,所以在同一个物理空间内,是可以共存多个PanID和Channel不一致的Mesh网络。
注意! 如果用了2.4G Mesh,Ble低功耗蓝牙和USB接口就不能再用了。
p1 | 字符串类型,设备在Mesh网络中扮演的角色 |
---|---|
"Client":上传自己数据给Server,并接收Server端回应的command "Server":一个Mesh网络中只能有一个Server |
p2 | 整数类型,PanID参数 |
---|---|
802.15.4 PAN ID used by Thread Mesh 范围<0-65535> Mesh网络的标识 |
p3 | 整数类型,Channel参数 |
---|---|
802.15.4 channel used by Thread 范围<11-26> Mesh网络的频率 |
应用示例:
xxxxxxxxxx
--配置设备为server节点并开始工作,网络参数为:Pan ID=0x1234 Channel=11
LIB_MeshConfig("Server",0x1234,11)
r1,r2,r3 = LIB_MeshServerRecvData()
函数描述: server查询是否收到client上传的data
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | 字符串型,数据的来源(client名称) |
---|---|
无 |
r3 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--配置设备为server节点并开始工作,网络参数为:Pan ID=0x1234 Channel=11
LIB_MeshConfig("Server",0x1234,11)
--查询是否收到数据,如果收到就print输出
while(true)
do
recv_flag, recv_client_name, recv_data_tab = LIB_MeshServerRecvData()
if recv_flag == 1 then
print(string.format("receive %d bytes data from %s", #recv_data_tab, recv_client_name))
end
end
LIB_MeshServerSendCommand(p1,p2)
函数描述: server向client下发8字节的命令数据。
注意1: 下发的command不会马上被client收到,而是取决于对应的client下次何时上传数据,server会自动在回复给client的response中附带上该command, 这样做是因为client有可能为低功耗传感器设备,并不会一直保持在线。
注意2: 下发的command并不保证一定会被client收到,比如下发一条command给"client01"还没被"client01"收到就被新下发给"client02"的command给覆盖了, 但是Core专门为名称是"CONTROL0" ~ "CONTROL9"的10个client分配了专有command缓存,所以mesh网络内最多可以有10个client可以确保接收命令不被其他client覆盖。
注意3:由于网络负荷大或其他原因,Core并不保证每次下发给client的command能够100%被client收到,这一点"CONTROL(0~9)"也不例外, 所以如果希望server下发的command 100%到达client,不仅client的名字需为“CONTROL(0~9)”,而且需要用户在应用层面上做保障,比如读取下一次client上传的状态 以确认上一次的command是否达到。
p1 | 字符串型,需要下发至的client名称,需为8个字节 |
---|---|
无 |
p2 | table类型 server下发给client的8字节command数据 |
---|---|
table内的元素必须为字节型,元素个数为8个字节 |
应用示例:
xxxxxxxxxx
cmd_tab = {1,2,3,4,5,6,7,8}
--向普通 client发送命令
LIB_MeshServerSendCommand("Client01",cmd_tab)
--向CONTROL client发送命令
LIB_MeshServerSendCommand("CONTROL0",cmd_tab)
r1 = LIB_MeshServerNetStateQuery()
函数描述: 查询sever当前的网络状态
r1 | 整数型 |
---|---|
0: server未加入mesh网络 1: server已加入mesh网络 |
应用示例:
xxxxxxxxxx
if LIB_MeshServerNetStateQuery() == 1 then
print("Server had joined in mesh net\r\n")
end
r1,r2 = LIB_MeshClientRecvCommand()
函数描述: client查询是否收到server下发的8字节command
r1 | 整数型,指示是否收到命令 |
---|---|
0: 未收到命令 1: 收到命令 |
r2 | table型,包含接收到的8字节命令 |
---|---|
无 |
应用示例:
xxxxxxxxxx
recv_flag, recv_cmd_tab = LIB_MeshClientRecvCommand()
if recv_flag == 1 then
print(string.format("receive %d bytes command from server", #recv_cmd_tab))
end
LIB_MeshClientSendData(p1,p2)
函数描述: client向server上传8字节的数据。 此上传过程如果失败Core会自动启动重发机制,如果系统重发了5次都没成功Core会认为和server已断开连接,可以通过LIB_MeshClientNetStateQuery函数查询到连接是否已断开
p1 | 字符串型,client自己的名称,需为8个字节 |
---|---|
无 |
p2 | table类型 client上传给server的8字节数据 |
---|---|
table内的元素必须为字节型,元素个数为8个字节 |
应用示例:
xxxxxxxxxx
data_tab = {1,2,3,4,5,6,7,8}
LIB_MeshClientSendData("Client01",data_tab)
r1 = LIB_MeshClientNetStateQuery()
函数描述: 查询client当前的网络状态
r1 | 整数型 |
---|---|
0: client未加入mesh网络 1: client已加入mesh网络但未和server建立连接 2: 已加入mesh网络且和server建立了连接 |
应用示例:
xxxxxxxxxx
link = LIB_MeshClientNetStateQuery()
if link == 0 then
pirnt("Client had not joined in mesh net\r\n")
elseif link == 1 then
print("Client had joined in mesh net\r\n")
elseif link == 2 then
print("Client had joined in mesh and connected with server\r\n")
end
LIB_IRConfig(p1)
函数描述: 配置红外无线模块占用的引脚端口,该模块适用于NEC编解码协议的红外编码和解码
p1 | 红外无线模块的UART占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
应用示例:
xxxxxxxxxx
--设置红外无线模块占用TX0、RX0引脚,并使能接收和发送
LIB_IRConfig("UART0")
r1,r2 = LIB_IRRecv()
函数描述: 查询是否收到红外遥控数据,如果收到数据则返回接收到的3个字节的遥控数据内容。
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置红外无线模块占用TX0、RX0引脚,并使能接收和发送
LIB_IRConfig("UART0")
while(true)
do
--查询是否收到红外数据,如果收到就print输出收到的数据
recv_flag,recv_tab = LIB_IRRecv()
if recv_flag == 1 then
print(string.format("IR data =%02x %02x %02x", recv_tab[1],recv_tab[2],recv_tab[3]))
end
end
LIB_IRSend(p1)
函数描述: 发送红外遥控数据,必须为包含3个字节的table
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须为3个,这3个数据为开发者任意定义的遥控数据 |
应用示例:
xxxxxxxxxx
--设置红外无线模块占用TX0、RX0引脚,并使能接收和发送
LIB_IRConfig("UART0")
table = {0x01,0x02,0x03} --红外遥控数据
while(true)
do
--每隔5秒发送一次红外遥控数据,数据为 0x01,0x02,0x03
LIB_IRSend(table)
LIB_DelayMs(5000)
end
LIB_24G_Config(p1,p2,p3,p4,p5)
函数描述: 配置NRF24L01/SI24R1 2.4G无线模块占用SPI引脚,以及CE占用的GPIO引脚,并开始工作
p1 | 2.4G无线模块的CE引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p2 | table类型 接收和发送地址,只有发送方和接收方的地址相同才能进行正常通信 |
---|---|
table内的元素必须为字节型,元素个数必须等于5个 |
p3 | 整数型,射频信道,0-125对应2400MHz~2525Mhz |
---|---|
数值范围:0-125 |
p4 | 传输速率设置 |
---|---|
"1Mpbs","2Mpbs","125Kpbs" |
p5 | 发射功率设置 |
---|---|
"-12dB","-6dB","-4dB","0dB","1dB","3dB","4dB","7dB" |
应用示例:
xxxxxxxxxx
--发送模块和接收模块的地址Addr必须一样
Addr = {0x01,0x02,0x03,0x04,0x05}
--设置SI24R1 2.4G无线模块占用MOSI,MISO,CLK,cs,以及D5引脚
--通信信道在2480Mhz,速率125K,发射功率为最大的7dB
LIB_24G_Config("D5", Addr, 80, "125Kpbs", "7dB")
r1,r2 = LIB_24G_Recv()
函数描述: 查询是否收到2.4G对端发来的数据,如果收到数据则返回接收到的数据来源及内容。注意对端发来的每个数据包不要大于32字节,且数据包时间间隔尽量不要小于100ms 注意:由于SI24R1底层收发数据已被固定为每包32字节,所以每次不管对方发送多少字节过来,都是收到32字节,只是多余的字节都会为0。
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--发送模块和接收模块的地址Addr必须一样
Addr = {0x01,0x02,0x03,0x04,0x05}
--设置SI24R1 2.4G无线模块占用MOSI,MISO,CLK,cs,以及D5引脚
--通信信道在2480Mhz,速率125K,发射功率为最大的7dB
LIB_24G_Config("D5", Addr, 80, "125Kpbs", "7dB")
while(GC(1) == true)
do
--查询是否收到数据,如果收到就print输出收到的数据个数,固定为32个
recv_flag,recv_tab = LIB_24G_Recv()
if recv_flag == 1 then
print(string.format("receive %d bytes", #recv_tab))
end
end
LIB_24G_Send(p1)
函数描述: 将p1数组中的数据发送给对端,每包发送的数据量不要超过32字节,每包发送间隔时间也尽量大于100ms 注意:由于SI24R1底层收发数据已被固定为每包32字节,所以不管每次发送多少字节,实际都是32字节,只是多余的字节都会为0。
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数不超过32个 |
应用示例:
xxxxxxxxxx
--发送模块和接收模块的地址Addr必须一样
Addr = {0x01,0x02,0x03,0x04,0x05}
--设置SI24R1 2.4G无线模块占用MOSI,MISO,CLK,cs,以及D5引脚
--通信信道在2480Mhz,速率125K,发射功率为最大的7dB
LIB_24G_Config("D5", Addr, 80, "125Kpbs", "7dB")
tab = {1,2,3,4,5}
while(GC(1) == true)
do
--每隔5秒向对端发送一包5字节的数据,实际上是32字节,只是多余的字节都会为0
LIB_24G_Send(tab)
LIB_DelayMs(5000)
end
LIB_WifiTcpConfig(p1,p2,p3,p4,p5,p6,p7)
函数描述: 配置WIFI模块(esp8266)占用的引脚端口,并以TCP Client方式和Server(服务器)通信
p1 | esp8266模块的UART占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | esp8266模块的reset占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 字符串型,路由器SSID(账号) |
---|---|
无 |
p4 | 字符串型,路由器Password(密码) |
---|---|
无 |
p5 | 字符串型,服务器的IP地址或域名 |
---|---|
无 |
p6 | 整数型,服务器的端口号 |
---|---|
无 |
p7 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于20秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内即没收到服务器的心跳包响应也没收到服务器下发的任意数据,此时Core会认为服务器已断联,Core会重新尝试连接服务器 |
注意1:心跳包是由开发者在Lua代码中以不大于p7的心跳时间间隔向服务器发送一包数据,并且服务器应返回心跳包响应数据。心跳包及响应的具体内容和长度由您和服务器端开发人员商量。 注意2:当p7的值为0的时候,Core默认关闭心跳机制(即Core不会因为服务器长时间没有数据下发而重启wifi模块),但真正开发产品时还是需要您和服务器端开发人员商量好心跳包的策略,这样就能保证wifi模块常年不掉线。
应用示例:
xxxxxxxxxx
--设置esp8266 Wifi模块占用TX0、RX0、D5引脚,TCP Client模式
--路由器账号:mywifi 路由器密码:abc123,tcp服务器域名:www.shineblink.com 端口号:1266
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_WifiTcpConfig函数的p7参数详细介绍
LIB_WifiTcpConfig("UART0","D5","mywifi","abc123","www.shineblink.com",1266,0)
r1,r2 = LIB_WifiTcpRecv()
函数描述: 查询是否收到TCP server发来数据,如果收到数据则返回接收到的数据。注意服务端下发的每个数据包尽量不要大于256字节,且数据包时间间隔尽量不要小于100ms
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置esp8266 Wifi模块占用TX0、RX0、D5引脚,TCP Client模式
--路由器账号:mywifi 路由器密码:abc123,tcp服务器域名:www.shineblink.com 端口号:1266
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_WifiTcpConfig函数的p7参数详细介绍
LIB_WifiTcpConfig("UART0","D5","mywifi","abc123","www.shineblink.com",1266,0)
while(true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,recv_tab = LIB_WifiTcpRecv()
if recv_flag == 1 then
print(string.format("tcp receive %d bytes", #recv_tab))
end
end
LIB_WifiTcpSend(p1)
函数描述: 发送p1数组中的数据,每包发送的数据量不要超过256字节,发送间隔时间也尽量大于100ms 注意:只有当TCP连接成功后,调用该函数才会发送,否则该函数会自动忽略对其的调用
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
应用示例:
xxxxxxxxxx
--设置esp8266 Wifi模块占用TX0、RX0、D5引脚,TCP Client模式
--路由器账号:mywifi 路由器密码:abc123,tcp服务器域名:www.shineblink.com 端口号:1266
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_WifiTcpConfig函数的p7参数详细介绍
LIB_WifiTcpConfig("UART0","D5","mywifi","abc123","www.shineblink.com",1266,0)
table = {1,2,3,4,5}
while(true)
do
--每隔5秒发送一次心跳包数据
LIB_WifiTcpSend(table)
LIB_DelayMs(5000)
end
LIB_WifiUdpConfig(p1,p2,p3,p4,p5,p6,p7)
函数描述: 配置WIFI模块(esp8266)占用的引脚端口,并以UDP方式通信,自身默认UDP端口是1112
p1 | esp8266模块的UART占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | esp8266模块的reset占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 字符串型,路由器SSID(账号) |
---|---|
无 |
p4 | 字符串型,路由器Password(密码) |
---|---|
无 |
p5 | 字符串型,对端的IP地址或域名 |
---|---|
无 |
p6 | 整数型,对端的端口号 |
---|---|
无 |
p7 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于20秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内即没收到心跳包响应也没收到对端发来的任意数据,此时Core会认为通信链路已断开,Core会重新尝试恢复通信链路 |
注意1:心跳包是由开发者在Lua代码中以不大于p7的心跳时间间隔向服务器发送一包数据,UDP的另一端应返回心跳包响应数据。心跳包及响应的具体内容和长度由您自己定义。 注意2:当p7的值为0的时候,Core默认关闭心跳机制(即Core不会因为对端长时间没有数据下发而重启wifi模块),但真正开发产品时还是需要您和对端的开发人员商量好心跳包的策略,这样就能保证wifi模块常年不掉线。
应用示例:
xxxxxxxxxx
--设置esp8266 Wifi模块占用TX0、RX0、D5引脚,UDP模式,端口1112
--路由器账号:mywifi 路由器密码:abc123,UDP要连接的对端IP:192.168.1.101 端口号:5678
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_WifiUdpConfig函数的p7参数详细介绍
LIB_WifiUdpConfig("UART0","D5","mywifi","abc123","192.168.1.101",5678,0)
r1,r2 = LIB_WifiUdpRecv()
函数描述: 查询是否收到UDP对端发来的数据,如果收到数据则返回接收到的数据。注意对端发来的每个数据包尽量不要大于256字节,且数据包时间间隔尽量不要小于100ms
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置esp8266 Wifi模块占用TX0、RX0、D5引脚,UDP模式,端口1112
--路由器账号:mywifi 路由器密码:abc123,UDP要连接的对端IP:192.168.1.101 端口号:5678
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_WifiUdpConfig函数的p7参数详细介绍
LIB_WifiUdpConfig("UART0","D5","mywifi","abc123","192.168.1.101",5678,0)
while(true)
do
--查询是否收到UDP数据,如果收到就print输出收到的字节数
recv_flag,recv_tab = LIB_WifiUdpRecv()
if recv_flag == 1 then
print(string.format("udp receive %d bytes", #recv_tab))
end
end
LIB_WifiUdpSend(p1)
函数描述: 发送p1数组中的数据,每包发送的数据量不要超过256字节,发送间隔时间也尽量大于100ms 注意:只有当esp8266连上AP后,调用该函数才会发送,否则该函数会自动忽略对其的调用
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
应用示例:
xxxxxxxxxx
--设置esp8266 Wifi模块占用TX0、RX0、D5引脚,UDP模式,端口1112
--路由器账号:mywifi 路由器密码:abc123,UDP要连接的对端IP:192.168.1.101 端口号:5678
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_WifiUdpConfig函数的p7参数详细介绍
LIB_WifiUdpConfig("UART0","D5","mywifi","abc123","192.168.1.101",5678,0)
table = {1,2,3,4,5}
while(true)
do
--每隔5秒发送一次心跳包数据
LIB_WifiUdpSend(table)
LIB_DelayMs(5000)
end
LIB_MQTTConfig(p1,p2,p3,p4,p5,p6,p7)
函数描述: 配置MQTT工作
p1 | 选择MQTT通信的载体是WIFI(esp8266)还是以太网(w5500) |
---|---|
"WIFI","ETHERNET" |
p2 | MQTT连接参数: client ID |
---|---|
字符串类型 |
p3 | MQTT连接参数: user name |
---|---|
字符串类型 |
p4 | MQTT连接参数: password |
---|---|
字符串类型 |
p5 | MQTT连接参数: keepalive ,单位:秒 |
---|---|
整数型 |
p6 | MQTT订阅路径: subscribe topic |
---|---|
字符串类型 |
p7 | 订阅消息的QOS等级 |
---|---|
"QOS0","QOS1","QOS2" |
应用示例:
xxxxxxxxxx
--配置MQTT底层为WIFI传输(esp8266),并按照如下参数进行MQTT连接
LIB_MQTTConfig("WIFI","ClientID","UsrName","pswd","60","/subtopic/get","QOS1")
r1,r2,r3 = LIB_MqttRecvSub()
函数描述: 查询是否收到服务器( broker )下发的订阅消息
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | 字符串型,接收到的订阅数据的topic |
---|---|
无 |
r3 | 字符串型,接收到的订阅数据的内容 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置esp8266 Wifi模块占用TX0、RX0、D5引脚,TCP Client模式
--路由器账号:mywifi 路由器密码:abc123,tcp服务器域名:www.shineblink.com 端口号:1883
--心跳包间隔时间180秒。如果需要使用请在ApiDoc文档中查阅关于LIB_WifiTcpConfig函数的p7参数详细介绍
LIB_WifiTcpConfig("UART0","D5","mywifi","abc123","www.shineblink.com",1883,180)
--配置MQTT底层为WIFI传输(esp8266),并按照如下参数进行MQTT连接
LIB_MQTTConfig("WIFI","ClientID","UsrName","pswd","60","/subtopic/get","QOS1")
while(true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,topic,data = LIB_MqttRecvSub()
if recv_flag == 1 then
print(string.format("Get datas on topic %s: %s", topic, data))
end
end
LIB_MqttSendPub(p1,p2,p3)
函数描述: 向服务器订阅的p2主题publish消息 注意:只有当MQTT连接成功后,调用该函数才会发送,否则该函数会自动忽略对其的调用
p1 | QOS等级 |
---|---|
"QOS0","QOS1","QOS2" |
p2 | MQTT发布路径: publish topic |
---|---|
字符串类型 |
p3 | MQTT发布内容 |
---|---|
字符串类型 |
应用示例:
xxxxxxxxxx
--设置esp8266 Wifi模块占用TX0、RX0、D5引脚,TCP Client模式
--路由器账号:mywifi 路由器密码:abc123,tcp服务器域名:www.shineblink.com 端口号:1883
--心跳包间隔时间180秒。如果需要使用请在ApiDoc文档中查阅关于LIB_WifiTcpConfig函数的p7参数详细介绍
LIB_WifiTcpConfig("UART0","D5","mywifi","abc123","www.shineblink.com",1883,180)
--配置MQTT底层为WIFI传输(esp8266),并按照如下参数进行MQTT连接
LIB_MQTTConfig("WIFI","ClientID","UsrName","pswd","60","/subtopic/get","QOS1")
while(true)
do
--每隔5秒向服务器publish一次消息
LIB_MqttSendPub("QOS1", "/pubtopic/update", "helloworld")
LIB_DelayMs(5000)
end
LIB_JsonParse(p1,p2,p3)
函数描述: 根据JsonPath(p2)来提取Json文本(p1)中所要找的文本(value) 注意:该函数只能将Json的value以字符串形式解析出来,不管value是数值型还是字符串型
p1 | Json文本 |
---|---|
字符串类型 |
p2 | Json路径 |
---|---|
字符串类型 |
p3(可选) | 要解析的value数据类型 |
---|---|
"Number":解析数值型(float) "String":解析字符串型 "Bool":解析布尔型 |
r1 | 解析出的value值 |
---|---|
如果参数不含p3,r1返回的只会是字符串类型;如果含p3,r1将根据p3的类型返回不同类型的值 |
应用示例:
xxxxxxxxxx
str1 = "{"foo": { "bar": [ 1, 2, 3] }, "baz": true}"
print(LIB_JsonParse(str1, "$.foo.bar[1]")) --结果: "2"
str2 = "{"val":123: , "nnn": what}"
print(LIB_JsonParse(str2, "$.val")) --结果: "123"
--以下三个分别是解析:数值型,字符串型,布尔型范例,并展示了LIB_JsonParse函数中加或不加类型参数p3时的区别
Json = "{\"val\":35, \"str\":\"hello\", \"bl\":false}"
--解析数值型
Json_Val = LIB_JsonParse(Json, "$.val", "Number")
Tmp_Str = LIB_JsonParse(Json, "$.val")
print(Json_Val) --结果: 35.0(Float型数值)
print(Tmp_Str) --结果: 35(字符串)
--解析字符串型
Json_Str = LIB_JsonParse(Json, "$.str", "String")
Tmp_Str = LIB_JsonParse(Json, "$.str")
print(Json_Str) --结果: hello(字符串)
print(Tmp_Str) --结果: "hello"(字符串,且包含"")
--解析布尔型
Json_Bool = LIB_JsonParse(Json, "$.bl", "Bool")
Tmp_Str = LIB_JsonParse(Json, "$.bl")
print(Json_Bool) --结果: 0(整数型0或1)
print(Tmp_Str) --结果: false(字符串)
LIB_NbTcpConfig(p1,p2,p3,p4,p5,p6,p7,p8)
函数描述: 配置NB模块(m5311)占用的引脚端口,并以TCP Client方式和Server(服务器)通信
p1 | m5311模块的UART引脚占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | m5311模块的RST引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 配置m5311模块的RST引脚是低电平复位还是高电平复位(取决于您的NB模块电路实现原理) |
---|---|
"LOW","HIGH" |
p4 | m5311模块的PWR引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p5 | 配置m5311模块的PWR引脚是低电平开机还是高电平开机(取决于您的NB模块电路实现原理) |
---|---|
"LOW","HIGH" |
p6 | 字符串型,服务器的IP地址 |
---|---|
无 |
p7 | 整数型,服务器的端口号 |
---|---|
无 |
p8 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于20秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内即没收到服务器的心跳包响应也没收到服务器下发的任意数据,此时Core会认为服务器已断联,Core会重新尝试连接服务器 |
注意1:心跳包是由开发者在Lua代码中以不大于p8的心跳时间间隔向服务器发送一包数据,并且服务器应返回心跳包响应数据。心跳包及响应的具体内容和长度由您和服务器端开发人员商量。 注意2:当p8的值为0的时候,Core默认关闭心跳机制(即Core不会因为服务器长时间没有数据下发而重启NB模块),但真正开发产品时还是需要您和服务器端开发人员商量好心跳包的策略,这样就能保证NB模块常年不掉线。
应用示例:
xxxxxxxxxx
--设置m5311 NB模块占用TX0、RX0、D5、D6引脚,TCP Client模式
--tcp服务器IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_NbTcpConfig函数的p8参数详细介绍
LIB_NbTcpConfig("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0)
r1,r2 = LIB_NbTcpRecv()
函数描述: 查询是否收到TCP server发来数据,如果收到数据则返回接收到的数据。注意服务端下发的每个数据包尽量不要大于100字节,且数据包时间间隔尽量不要小于1秒
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置m5311 NB模块占用TX0、RX0、D5、D6引脚,TCP Client模式
--tcp服务器IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_NbTcpConfig函数的p8参数详细介绍
LIB_NbTcpConfig("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0)
while(true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,recv_tab = LIB_NbTcpRecv()
if recv_flag == 1 then
print(string.format("tcp receive %d bytes", #recv_tab))
end
end
LIB_NbTcpSend(p1)
函数描述: 发送p1数组中的数据,每包发送的数据量不要超过100字节,发送间隔时间也尽量大于100ms 注意:只有当TCP连接成功后,调用该函数才会发送,否则该函数会自动忽略对其的调用
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
应用示例:
xxxxxxxxxx
--设置m5311 NB模块占用TX0、RX0、D5、D6引脚,TCP Client模式
--tcp服务器IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_NbTcpConfig函数的p8参数详细介绍
LIB_NbTcpConfig("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0)
table = {1,2,3,4,5}
while(true)
do
--每隔5秒发送一包数据
LIB_NbTcpSend(table)
LIB_DelayMs(5000)
end
LIB_NbUdpConfig(p1,p2,p3,p4,p5,p6,p7,p8)
函数描述: 配置NB模块(m5311)占用的引脚端口,并以Udp方式和Udp对端通信
p1 | m5311模块的UART引脚占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | m5311模块的RST引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 配置m5311模块的RST引脚是低电平复位还是高电平复位(取决于您的NB模块电路实现原理) |
---|---|
"LOW","HIGH" |
p4 | m5311模块的PWR引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p5 | 配置m5311模块的PWR引脚是低电平开机还是高电平开机(取决于您的NB模块电路实现原理) |
---|---|
"LOW","HIGH" |
p6 | 字符串型,Udp对端的IP地址 |
---|---|
无 |
p7 | 整数型,Udp对端的端口号 |
---|---|
无 |
p8 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于20秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内没收到Udp对端发的任何数据,此时Core会认为Udp对端已断联,Core会重新尝试连接Udp对端 |
注意1:心跳包是由开发者在Lua代码中以不大于p8的心跳时间间隔向Udp对端发送一包数据,并且Udp对端应返回心跳包响应数据。心跳包及响应的具体内容和长度由您和Udp对端开发人员商量。 注意2:当p8的值为0的时候,Core默认关闭心跳机制(即Core不会因为长时间没有收到Udp对端数据而重启NB模块),但真正开发产品时还是需要您和Udp对端开发人员商量好心跳包的策略,这样就能保证NB模块常年不掉线。
应用示例:
xxxxxxxxxx
--设置m5311 NB模块占用TX0、RX0、D5、D6引脚,Udp 模式
--Udp对端IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_NbUdpConfig函数的p8参数详细介绍
LIB_NbUdpConfig("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0)
r1,r2 = LIB_NbUdpRecv()
函数描述: 查询是否收到Udp 对端发来数据,如果收到数据则返回接收到的数据。注意Udp对端发的每个数据包尽量不要大于100字节,且数据包时间间隔尽量不要小于1秒
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置m5311 NB模块占用TX0、RX0、D5、D6引脚,Udp 模式
--Udp对端IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_NbUdpConfig函数的p8参数详细介绍
LIB_NbUdpConfig("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0)
while(true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,recv_tab = LIB_NbUdpRecv()
if recv_flag == 1 then
print(string.format("Udp receive %d bytes", #recv_tab))
end
end
LIB_NbUdpSend(p1)
函数描述: 发送p1数组中的数据,每包发送的数据量不要超过100字节,发送间隔时间也尽量大于100ms
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
应用示例:
xxxxxxxxxx
--设置m5311 NB模块占用TX0、RX0、D5、D6引脚,Udp 模式
--Udp对端IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_NbUdpConfig函数的p8参数详细介绍
LIB_NbUdpConfig("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0)
table = {1,2,3,4,5}
while(true)
do
--每隔5秒发送一包数据
LIB_NbUdpSend(table)
LIB_DelayMs(5000)
end
LIB_NbMqttM5311Config(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13)
函数描述: 配置NB-IOT模块(m5311)以MQTT方式工作,并设置相关参数
p1 | m5311模块的UART引脚占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | m5311模块的RST引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 配置m5311模块的RST引脚是低电平复位还是高电平复位(取决于您的NB模块电路实现原理) |
---|---|
"LOW","HIGH" |
p4 | m5311模块的PWR引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p5 | 配置m5311模块的PWR引脚是低电平开机还是高电平开机(取决于您的NB模块电路实现原理) |
---|---|
"LOW","HIGH" |
p6 | 字符串型,服务器的IP地址 |
---|---|
无 |
p7 | 整数型,服务器的端口号 |
---|---|
无 |
p8 | MQTT连接参数: client ID |
---|---|
字符串类型 |
p9 | MQTT连接参数: user name |
---|---|
字符串类型 |
p10 | MQTT连接参数: password |
---|---|
字符串类型 |
p11 | MQTT连接参数: keepalive ,单位:秒 |
---|---|
整数型 |
p12 | MQTT订阅路径: subscribe topic |
---|---|
字符串类型 |
p13 | 订阅消息的QOS等级 |
---|---|
"QOS0","QOS1","QOS2" |
应用示例:
xxxxxxxxxx
--设置m5311 NB模块占用TX0、RX0、D5、D6引脚,MQTT模式
--MQTT服务器地址(适用于ONE NET平台)
server_addr = "183.230.40.96" --中移物联网MQTT接入服务ip地址
server_port = 1883
--MQTT 连接参数(适用于ONE NET平台)
mqtt_con_clientID = "TestDevice001"
mqtt_con_username = "353255"
mqtt_con_password = "version=2018-10-31&res=products%2F353255%2Fdevices%2FTestDevice001&et=1893427200&method=md5&sign=%2F5RJwGwytPWvVDB04K7rnw%3D%3D"
--MQTT topic相关参数(适用于ONE NET平台)
mqtt_sub_topic = "$sys/353255/TestDevice001/cmd/request/+"--订阅用
mqtt_pub_topic = "$sys/353255/TestDevice001/dp/post/json" --发布用
--KeepAlive周期180秒
LIB_NbMqttM5311Config("UART0","D5","HIGH","D6","HIGH",server_addr,server_port,mqtt_con_clientID,mqtt_con_username,mqtt_con_password,180,mqtt_sub_topic,"QOS0")
r1,r2,r3 = LIB_NbMqttM5311RecvSub()
函数描述: 查询是否收到服务器( broker )下发的订阅消息,该消息总长度尽量不要超过256字节
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | 字符串型,接收到的订阅数据的topic |
---|---|
无 |
r3 | 字符串型,接收到的订阅数据的内容 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置m5311 NB模块占用TX0、RX0、D5、D6引脚,MQTT模式
--MQTT服务器地址(适用于ONE NET平台)
server_addr = "183.230.40.96" --中移物联网MQTT接入服务ip地址
server_port = 1883
--MQTT 连接参数(适用于ONE NET平台)
mqtt_con_clientID = "TestDevice001"
mqtt_con_username = "353255"
mqtt_con_password = "version=2018-10-31&res=products%2F353255%2Fdevices%2FTestDevice001&et=1893427200&method=md5&sign=%2F5RJwGwytPWvVDB04K7rnw%3D%3D"
--MQTT topic相关参数(适用于ONE NET平台)
mqtt_sub_topic = "$sys/353255/TestDevice001/cmd/request/+"--订阅用
mqtt_pub_topic = "$sys/353255/TestDevice001/dp/post/json" --发布用
--KeepAlive周期180秒
LIB_NbMqttM5311Config("UART0","D5","HIGH","D6","HIGH",server_addr,server_port,mqtt_con_clientID,mqtt_con_username,mqtt_con_password,180,mqtt_sub_topic,"QOS0")
while(true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,topic,data = LIB_NbMqttM5311RecvSub()
if recv_flag == 1 then
print(string.format("Get datas on topic %s: %s", topic, data))
end
end
LIB_NbMqttM5311SendPub(p1,p2,p3)
函数描述: 向服务器订阅的p2主题publish消息 注意:1. 只有当MQTT连接成功后,调用该函数才会发送,否则该函数会自动忽略对其的调用
- p2和p3的长度总和尽量不要超过200字节
p1 | QOS等级 |
---|---|
"QOS0","QOS1","QOS2" |
p2 | MQTT发布路径: publish topic |
---|---|
字符串类型 |
p3 | MQTT发布内容 |
---|---|
字符串类型 |
应用示例:
xxxxxxxxxx
--设置m5311 NB模块占用TX0、RX0、D5、D6引脚,MQTT模式
--MQTT服务器地址(适用于ONE NET平台)
server_addr = "183.230.40.96" --中移物联网MQTT接入服务ip地址
server_port = 1883
--MQTT 连接参数(适用于ONE NET平台)
mqtt_con_clientID = "TestDevice001"
mqtt_con_username = "353255"
mqtt_con_password = "version=2018-10-31&res=products%2F353255%2Fdevices%2FTestDevice001&et=1893427200&method=md5&sign=%2F5RJwGwytPWvVDB04K7rnw%3D%3D"
--MQTT topic相关参数(适用于ONE NET平台)
mqtt_sub_topic = "$sys/353255/TestDevice001/cmd/request/+"--订阅用
mqtt_pub_topic = "$sys/353255/TestDevice001/dp/post/json" --发布用
--KeepAlive周期180秒
LIB_NbMqttM5311Config("UART0","D5","HIGH","D6","HIGH",server_addr,server_port,mqtt_con_clientID,mqtt_con_username,mqtt_con_password,180,mqtt_sub_topic,"QOS0")
while(true)
do
--每隔5秒向服务器publish一次消息
LIB_NbMqttM5311SendPub("QOS0", mqtt_pub_topic, "helloworld")
LIB_DelayMs(5000)
end
r1,r2,r3,r4,r5 = LIB_NbStatusQuery()
函数描述: 查询NBIOT模块的状态,以及IMEI、IMSI、ICCID号、信号强度 注意:该函数最好在NBIOT模块上电后5秒再调用
r1 | 字符串,指示模块当前的状态 |
---|---|
"power on":模块上电完成 "sim card is detected":检测到sim卡 "celluar connected" 已连上附近基站 |
r2 | 字符串,IMEI号 |
---|---|
数字串 |
r3 | 字符串,IMSI号 |
---|---|
数字串 |
r4 | 字符串,ICCID号 |
---|---|
数字串 |
r5 | 整数型,信号强度(RSSI) |
---|---|
单位: dBm ,最小值:-113dBm。注意:该信号强度只是模块上电入网时的信号强度,并不会实时变化 |
应用示例:
xxxxxxxxxx
State,IMEI,IMSI,ICCID,RSSI = LIB_NbStatusQuery()
print(string.format("module state: %s", State))
print(string.format("module IMEI: %s", IMEI))
print(string.format("module IMSI: %s", IMSI))
print(string.format("module ICCID: %s", ICCID))
print(string.format("module RSSI: %d dBM", RSSI))
LIB_Cat1TcpUdpConfig(p1,p2~p10)
函数描述: 配置4G Cat1 模块(ML302-G)占用的引脚端口,并以TCP Client或UDP方式和Server(服务器)通信,以及是否开启GPS功能和设置GPS模式
p1 | Cat1模块的UART引脚占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | Cat1模块的RST引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 配置Cat1模块的RST引脚是低电平复位还是高电平复位(取决于您的Cat1模块电路实现原理) |
---|---|
"LOW","HIGH" |
p4 | Cat1模块的PWR引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p5 | 配置Cat1模块的PWR引脚是低电平开机还是高电平开机(取决于您的Cat1模块电路实现原理) |
---|---|
"LOW","HIGH" |
p6 | 字符串型,服务器的IP地址或域名 |
---|---|
无 |
p7 | 整数型,服务器的端口号 |
---|---|
无 |
p8 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于20秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内即没收到服务器的心跳包响应也没收到服务器下发的任意数据,此时Core会认为服务器已断联,Core会重新尝试连接服务器 |
p9 | 配置Cat1模块以TCP或者UDP方式和对端服务器通信 |
---|---|
"TCP","UDP" |
p10 | 配置Cat1模块的GPS是否工作,以及GPS的工作模式。注意: GPS工作的前提是和server端的通信正常 |
---|---|
"NO_GPS": 不开启GPS | |
"NORMAL_GPS": 开启GPS,但不使用AGPS功能 | |
"AUTO_AGPS": 开启GPS和AGPS,并且每隔4个小时后如果再次重新上电调用LIB_Cat1TcpUdpConfig会耗费下载星历数据的流量(5KB) | |
"FORCE_AGPS": 开启GPS和AGPS,并且每次重新上电后调用LIB_Cat1TcpUdpConfig必定会耗费下载星历数据的流量(5KB),该模式适合套餐流量充足的或者追求快速定位的 |
注意1:心跳包是由开发者在Lua代码中以不大于p8的心跳时间间隔向服务器发送一包数据,并且服务器应返回心跳包响应数据。心跳包及响应的具体内容和长度由您和服务器端开发人员商量。 注意2:当p8的值为0的时候,Core默认关闭心跳机制(即Core不会因为服务器长时间没有数据下发而重启NB模块),但真正开发产品时还是需要您和服务器端开发人员商量好心跳包的策略,这样就能保证Cat1模块常年不掉线。
应用示例:
xxxxxxxxxx
--设置Cat1模块占用TX0、RX0、D5、D6引脚
--tcp服务器IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpConfig函数的p8参数详细介绍
--TCP Client模式,如果要使用UDP,将"TCP"改成"UDP"即可
--不开启GPS功能,如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpConfig函数的p10参数详细介绍
LIB_Cat1TcpUdpConfig("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0,"TCP","NO_GPS")
r1,r2 = LIB_Cat1TcpUdpRecv()
函数描述: 查询是否收到TCP/UDP Server端发来数据,如果收到数据则返回接收到的数据。注意TCP/UDP Server端下发的每个数据包尽量不要大于256字节,且数据包时间间隔尽量不要小于0.1秒
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置Cat1模块占用TX0、RX0、D5、D6引脚
--tcp服务器IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpConfig函数的p8参数详细介绍
--TCP Client模式,如果要使用UDP,将"TCP"改成"UDP"即可
--不开启GPS功能,如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpConfig函数的p10参数详细介绍
LIB_Cat1TcpUdpConfig("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0,"TCP","NO_GPS")
while(GC(1) == true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,recv_tab = LIB_Cat1TcpUdpRecv()
if recv_flag == 1 then
print(string.format("receive %d bytes", #recv_tab))
end
end
LIB_Cat1TcpUdpSend(p1)
函数描述: 发送p1数组中的数据,每包发送的数据量不要超过220字节,发送间隔时间也尽量大于100ms 注意:只有当TCP/UDP连接成功后,调用该函数才会发送,否则该函数会自动忽略对其的调用
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于等于220个 |
应用示例:
xxxxxxxxxx
--设置Cat1模块占用TX0、RX0、D5、D6引脚
--tcp服务器IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpConfig函数的p8参数详细介绍
--TCP Client模式,如果要使用UDP,将"TCP"改成"UDP"即可
--不开启GPS功能,如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpConfig函数的p10参数详细介绍
LIB_Cat1TcpUdpConfig("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0,"TCP","NO_GPS")
table = {1,2,3,4,5}
while(GC(1) == true)
do
--每隔5秒发送一包数据
LIB_Cat1TcpUdpSend(table)
LIB_DelayMs(5000)
end
LIB_Cat1TcpUdpEC800Config(p1,p2~p10)
函数描述: 配置4G Cat1 模块(EC800)占用的引脚端口,并以TCP Client或UDP方式和Server(服务器)通信,以及是否开启GPS功能和设置GPS模式
p1 | Cat1模块的UART引脚占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | Cat1模块的RST引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 配置Cat1模块的RST引脚是低电平复位还是高电平复位(取决于您的Cat1模块电路实现原理) |
---|---|
"LOW","HIGH" |
p4 | Cat1模块的PWR引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p5 | 配置Cat1模块的PWR引脚是低电平开机还是高电平开机(取决于您的Cat1模块电路实现原理) |
---|---|
"LOW","HIGH" |
p6 | 字符串型,服务器的IP地址或域名 |
---|---|
无 |
p7 | 整数型,服务器的端口号 |
---|---|
无 |
p8 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于20秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内即没收到服务器的心跳包响应也没收到服务器下发的任意数据,此时Core会认为服务器已断联,Core会重新尝试连接服务器 |
p9 | 配置Cat1模块以TCP或者UDP方式和对端服务器通信 |
---|---|
"TCP","UDP" |
p10 | 配置Cat1模块的GPS是否工作,以及GPS的工作模式。注意1: GPS工作的前提是和server端的通信正常,注意2:GPS功能仅EC800M模组支持 |
---|---|
"NO_GPS": 不开启GPS | |
"NORMAL_GPS": 开启GPS,但不使用AP-FLASH GPS热启动功能 | |
"AUTO_AGPS": 开启GPS和EC800M的AP-FLASH GPS热启动功能 |
注意1:心跳包是由开发者在Lua代码中以不大于p8的心跳时间间隔向服务器发送一包数据,并且服务器应返回心跳包响应数据。心跳包及响应的具体内容和长度由您和服务器端开发人员商量。 注意2:当p8的值为0的时候,Core默认关闭心跳机制(即Core不会因为服务器长时间没有数据下发而重启NB模块),但真正开发产品时还是需要您和服务器端开发人员商量好心跳包的策略,这样就能保证Cat1模块常年不掉线。
应用示例:
xxxxxxxxxx
--设置Cat1模块占用TX0、RX0、D5、D6引脚
--tcp服务器IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpEC800Config函数的p8参数详细介绍
--TCP Client模式,如果要使用UDP,将"TCP"改成"UDP"即可
--不开启GPS功能,如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpEC800Config函数的p10参数详细介绍
LIB_Cat1TcpUdpEC800Config("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0,"TCP","NO_GPS")
r1,r2 = LIB_Cat1TcpUdpEC800Recv()
函数描述: 查询是否收到TCP/UDP Server端发来数据,如果收到数据则返回接收到的数据。注意TCP/UDP Server端下发的每个数据包尽量不要大于256字节,且数据包时间间隔尽量不要小于0.1秒
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置Cat1模块占用TX0、RX0、D5、D6引脚
--tcp服务器IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpEC800Config函数的p8参数详细介绍
--TCP Client模式,如果要使用UDP,将"TCP"改成"UDP"即可
--不开启GPS功能,如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpEC800Config函数的p10参数详细介绍
LIB_Cat1TcpUdpEC800Config("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0,"TCP","NO_GPS")
while(GC(1) == true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,recv_tab = LIB_Cat1TcpUdpEC800Recv()
if recv_flag == 1 then
print(string.format("receive %d bytes", #recv_tab))
end
end
LIB_Cat1TcpUdpEC800Send(p1)
函数描述: 发送p1数组中的数据,每包发送的数据量不要超过220字节,发送间隔时间也尽量大于100ms 注意:只有当TCP/UDP连接成功后,调用该函数才会发送,否则该函数会自动忽略对其的调用
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于等于220个 |
应用示例:
xxxxxxxxxx
--设置Cat1模块占用TX0、RX0、D5、D6引脚
--tcp服务器IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpEC800Config函数的p8参数详细介绍
--TCP Client模式,如果要使用UDP,将"TCP"改成"UDP"即可
--不开启GPS功能,如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpEC800Config函数的p10参数详细介绍
LIB_Cat1TcpUdpEC800Config("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0,"TCP","NO_GPS")
table = {1,2,3,4,5}
while(GC(1) == true)
do
--每隔5秒发送一包数据
LIB_Cat1TcpUdpEC800Send(table)
LIB_DelayMs(5000)
end
LIB_Cat1HttpConfig(p1,p2~p10)
函数描述: 配置4G Cat1 模块(ML302-G)占用的引脚端口,并以HTTP方式和Server(服务器)通信,以及是否开启GPS功能和设置GPS模式
p1 | Cat1模块的UART引脚占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | Cat1模块的RST引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 配置Cat1模块的RST引脚是低电平复位还是高电平复位(取决于您的Cat1模块电路实现原理) |
---|---|
"LOW","HIGH" |
p4 | Cat1模块的PWR引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p5 | 配置Cat1模块的PWR引脚是低电平开机还是高电平开机(取决于您的Cat1模块电路实现原理) |
---|---|
"LOW","HIGH" |
p6 | 字符串型,保留 |
---|---|
固定为"NONE" |
p7 | 整数型,保留 |
---|---|
固定为0 |
p8 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于20秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内即没收到服务器的心跳包响应也没收到服务器下发的任意数据,此时Core会认为服务器已断联,Core会重新尝试连接服务器 |
p9 | 配置Cat1模块以HTTP方式和对端服务器通信,目前只有HTTP选项 |
---|---|
"HTTP" |
p10 | 配置Cat1模块的GPS是否工作,以及GPS的工作模式。注意: GPS工作的前提是和server端的通信正常 |
---|---|
"NO_GPS": 不开启GPS | |
"NORMAL_GPS": 开启GPS,但不使用AGPS功能 | |
"AUTO_AGPS": 开启GPS和AGPS,并且每隔4个小时后如果再次重新上电调用LIB_Cat1HttpConfig会耗费下载星历数据的流量(5KB) | |
"FORCE_AGPS": 开启GPS和AGPS,并且每次重新上电后调用LIB_Cat1HttpConfig必定会耗费下载星历数据的流量(5KB),该模式适合套餐流量充足的或者追求快速定位的 |
注意1:心跳包是由开发者在Lua代码中以不大于p8的心跳时间间隔向服务器发送一包数据,并且服务器应返回心跳包响应数据。心跳包及响应的具体内容和长度由您和服务器端开发人员商量。 注意2:当p8的值为0的时候,Core默认关闭心跳机制(即Core不会因为服务器长时间没有数据下发而重启NB模块),但真正开发产品时还是需要您和服务器端开发人员商量好心跳包的策略,这样就能保证Cat1模块常年不掉线。
应用示例:
xxxxxxxxxx
--设置Cat1模块占用TX0、RX0、D5、D6引脚
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1HttpConfig函数的p8参数详细介绍
--HTTP Client模式
--不开启GPS功能,如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1HttpConfig函数的p10参数详细介绍
LIB_Cat1HttpConfig("UART0","D5","HIGH","D6","HIGH","NONE",0,0,"HTTP","NO_GPS")
r1,r2,r3 = LIB_Cat1HttpGet(p1)
函数描述: 向服务器发起GET请求并接收服务器的返回数据,最大支持服务器返回200KB数据 注意:这个函数是阻塞型函数,在Lua代码中应予以考虑,服务器返回的数据是缓存在Buffer中,需调用LIB_Cat1HttpQueryBuff函数来取
p1 | 字符串型,服务器URL地址 |
---|---|
例如:"http:/www.baidu.com:80/index.php" |
r1 | 整数型,函数执行结果 |
---|---|
1:finished 2:time out |
r2 | 整数型,服务器返回的http状态码 |
---|---|
例如200代表OK,404代表无法找到URL指定的资源 |
r3 | 整数型,服务器返回消息的长度, |
---|---|
单位:字节 |
应用示例:
xxxxxxxxxx
--设置Cat1模块占用TX0、RX0、D5、D6引脚
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1HttpConfig函数的p8参数详细介绍
--HTTP Client模式
--不开启GPS功能,如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1HttpConfig函数的p10参数详细介绍
LIB_Cat1HttpConfig("UART0","D5","HIGH","D6","HIGH","NONE",0,0,"HTTP","NO_GPS")
while(true)
do
LIB_DelayMs(10000)
--开始向服务器发送GET请求
result,code,length = LIB_Cat1HttpGet("http:/www.baidu.com:80/index.php")
if result == 1 then
print("LIB_Cat1HttpGet() exec finished")
if code == 200 then --服务器返回Http状态码200,表示OK
print(string.format("Server respond ok, respond content len:%d", length))
end
end
end
r1,r2 = LIB_Cat1HttpQueryBuff(p1,p2)
函数描述: 该函数用来从模组缓存中读取上一次向服务器发请求所返回的数据, 注意:注意每次读取的字符串数据不要超过250个,如果需要读的字符串数据超过250个,应分多次调用该函数来读取
p1 | 整数型,读取buffer中的起始位置 |
---|---|
从0开始 |
p2 | 整数型,读取buffer中的结束位置 |
---|---|
不包含该结束位置的数据 |
r1 | 整数型,实际读出的个数 |
---|---|
如果缓存中的实际个数小于要读取的个数,则返回缓存中的实际个数 |
r2 | 字符串型,从缓存读出的字符串数据 (Http服务器返回的数据应该都是字符) |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置Cat1模块占用TX0、RX0、D5、D6引脚
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1HttpConfig函数的p8参数详细介绍
--HTTP Client模式
--不开启GPS功能,如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1HttpConfig函数的p10参数详细介绍
LIB_Cat1HttpConfig("UART0","D5","HIGH","D6","HIGH","NONE",0,0,"HTTP","NO_GPS")
while(true)
do
LIB_DelayMs(10000)
--开始向服务器发送GET请求
result,code,length = LIB_Cat1HttpGet("http:/www.baidu.com:80/index.php")
if result == 1 then --finish
print("LIB_Cat1HttpGet() exec finished")
--服务器返回Http状态码200,表示OK
if code == 200 then
print(string.format("Server respond ok, respond content len:%d", length))
--从服务器返回的数据中读取前250字节
str_len,str = LIB_Cat1HttpQueryBuff(0,249)
if str_len > 0 then
print(str)--打印输出
end
end
end
end
r1,r2,r3 = LIB_Cat1HttpPost(p1,p2)
函数描述: 向服务器发起POST请求并接收服务器的返回数据,最大支持服务器返回200KB数据 注意:这个函数是阻塞型函数,在Lua代码中应予以考虑,服务器返回的数据是缓存在Buffer中,需调用LIB_Cat1HttpQueryBuff函数来取
p1 | 字符串型,服务器URL地址 |
---|---|
例如:"http:/www.baidu.com:80/index.php" |
p2 | 字符串型,要发送的Post 数据 ,总长度不能超过250 |
---|---|
例如:"{"temperature"25.0,"humidity":70}" |
r1 | 整数型,函数执行结果 |
---|---|
1:finished 2:time out |
r2 | 整数型,服务器返回的http状态码 |
---|---|
例如200代表OK,404代表无法找到URL指定的资源 |
r3 | 整数型,服务器返回消息的长度, |
---|---|
单位:字节 |
应用示例:
xxxxxxxxxx
--设置Cat1模块占用TX0、RX0、D5、D6引脚
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1HttpConfig函数的p8参数详细介绍
--HTTP Client模式
--不开启GPS功能,如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1HttpConfig函数的p10参数详细介绍
LIB_Cat1HttpConfig("UART0","D5","HIGH","D6","HIGH","NONE",0,0,"HTTP","NO_GPS")
while(true)
do
if something_happen then
--开始向服务器发送POST请求
result,code,length = LIB_Cat1HttpPost("http:/www.baidu.com:80/index.php", "{"temperature"25.0,"humidity":70}")
if result == 1 then
print("LIB_Cat1HttpPost() exec finished")
if code == 200 then --服务器返回Http状态码200,表示OK
print(string.format("Server respond ok, respond content len:%d", length))
end
end
end
end
LIB_Cat1MqttML302Config(p1~p14)
函数描述: 配置Cat1 4G 模块(ML302)以MQTT方式工作,并设置相关参数
p1 | ML302模块的UART引脚占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | ML302模块的RST引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 配置ML302模块的RST引脚是低电平复位还是高电平复位(取决于您的Cat1模块电路实现原理) |
---|---|
"LOW","HIGH" |
p4 | ML302模块的PWR引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p5 | 配置ML302模块的PWR引脚是低电平开机还是高电平开机(取决于您的Cat1模块电路实现原理) |
---|---|
"LOW","HIGH" |
p6 | 字符串型,服务器的IP地址 |
---|---|
无 |
p7 | 整数型,服务器的端口号 |
---|---|
无 |
p8 | MQTT连接参数: client ID |
---|---|
字符串类型 |
p9 | MQTT连接参数: user name |
---|---|
字符串类型 |
p10 | MQTT连接参数: password |
---|---|
字符串类型 |
p11 | MQTT连接参数: keepalive ,单位:秒 |
---|---|
整数型 |
p12 | MQTT订阅路径: subscribe topic |
---|---|
字符串类型 |
p13 | 订阅消息的QOS等级 |
---|---|
"QOS0","QOS1","QOS2" |
p14 | 配置Cat1模块的GPS是否工作,以及GPS的工作模式。注意: GPS工作的前提是和server端的通信正常 |
---|---|
"NO_GPS": 不开启GPS | |
"NORMAL_GPS": 开启GPS,但不使用AGPS功能 | |
"AUTO_AGPS": 开启GPS和AGPS,并且每隔4个小时后如果再次重新上电调用LIB_Cat1MqttML302Config会耗费下载星历数据的流量(5KB) | |
"FORCE_AGPS": 开启GPS和AGPS,并且每次重新上电后调用LIB_Cat1MqttML302Config必定会耗费下载星历数据的流量(5KB),该模式适合套餐流量充足的或者追求快速定位的 |
应用示例:
xxxxxxxxxx
--设置ML302 Cat1模块占用TX0、RX0、D5、D6引脚,MQTT模式
--MQTT服务器地址(适用于ONE NET平台)
server_addr = "183.230.40.96" --中移物联网MQTT接入服务ip地址
server_port = 1883
--MQTT 连接参数(适用于ONE NET平台)
mqtt_con_clientID = "TestDevice001"
mqtt_con_username = "353255"
mqtt_con_password = "version=2018-10-31&res=products%2F353255%2Fdevices%2FTestDevice001&et=1893427200&method=md5&sign=%2F5RJwGwytPWvVDB04K7rnw%3D%3D"
--MQTT topic相关参数(适用于ONE NET平台)
mqtt_sub_topic = "$sys/353255/TestDevice001/cmd/request/+"--订阅用
mqtt_pub_topic = "$sys/353255/TestDevice001/dp/post/json" --发布用
--KeepAlive周期180秒
--不开启GPS功能
LIB_Cat1MqttML302Config("UART0","D5","HIGH","D6","HIGH",server_addr,server_port,mqtt_con_clientID,mqtt_con_username,mqtt_con_password,180,mqtt_sub_topic,"QOS0","NO_GPS")
r1,r2,r3 = LIB_Cat1MqttML302RecvSub()
函数描述: 查询是否收到服务器(broker)下发的订阅消息,该消息总长度尽量不要超过256字节
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | 字符串型,接收到的订阅数据的topic |
---|---|
无 |
r3 | 字符串型,接收到的订阅数据的内容 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置ML302 Cat1模块占用TX0、RX0、D5、D6引脚,MQTT模式
--MQTT服务器地址(适用于ONE NET平台)
server_addr = "183.230.40.96" --中移物联网MQTT接入服务ip地址
server_port = 1883
--MQTT 连接参数(适用于ONE NET平台)
mqtt_con_clientID = "TestDevice001"
mqtt_con_username = "353255"
mqtt_con_password = "version=2018-10-31&res=products%2F353255%2Fdevices%2FTestDevice001&et=1893427200&method=md5&sign=%2F5RJwGwytPWvVDB04K7rnw%3D%3D"
--MQTT topic相关参数(适用于ONE NET平台)
mqtt_sub_topic = "$sys/353255/TestDevice001/cmd/request/+"--订阅用
mqtt_pub_topic = "$sys/353255/TestDevice001/dp/post/json" --发布用
--KeepAlive周期180秒
--不开启GPS功能
LIB_Cat1MqttML302Config("UART0","D5","HIGH","D6","HIGH",server_addr,server_port,mqtt_con_clientID,mqtt_con_username,mqtt_con_password,180,mqtt_sub_topic,"QOS0","NO_GPS")
while(true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,topic,data = LIB_Cat1MqttML302RecvSub()
if recv_flag == 1 then
print(string.format("Get datas on topic %s: %s", topic, data))
end
end
LIB_Cat1MqttML302SendPub(p1,p2,p3)
函数描述: 向服务器订阅的p2主题publish消息 注意:1. 只有当MQTT连接成功后,调用该函数才会发送,否则该函数会自动忽略对其的调用
- p2和p3的长度总和尽量不要超过200字节
p1 | QOS等级 |
---|---|
"QOS0","QOS1","QOS2" |
p2 | MQTT发布路径: publish topic |
---|---|
字符串类型 |
p3 | MQTT发布内容 |
---|---|
字符串类型 |
应用示例:
xxxxxxxxxx
--设置ML302 Cat1模块占用TX0、RX0、D5、D6引脚,MQTT模式
--MQTT服务器地址(适用于ONE NET平台)
server_addr = "183.230.40.96" --中移物联网MQTT接入服务ip地址
server_port = 1883
--MQTT 连接参数(适用于ONE NET平台)
mqtt_con_clientID = "TestDevice001"
mqtt_con_username = "353255"
mqtt_con_password = "version=2018-10-31&res=products%2F353255%2Fdevices%2FTestDevice001&et=1893427200&method=md5&sign=%2F5RJwGwytPWvVDB04K7rnw%3D%3D"
--MQTT topic相关参数(适用于ONE NET平台)
mqtt_sub_topic = "$sys/353255/TestDevice001/cmd/request/+"--订阅用
mqtt_pub_topic = "$sys/353255/TestDevice001/dp/post/json" --发布用
--KeepAlive周期180秒
--不开启GPS功能
LIB_Cat1MqttML302Config("UART0","D5","HIGH","D6","HIGH",server_addr,server_port,mqtt_con_clientID,mqtt_con_username,mqtt_con_password,180,mqtt_sub_topic,"QOS0","NO_GPS")
while(true)
do
--每隔5秒向服务器publish一次消息
LIB_Cat1MqttML302SendPub("QOS0", mqtt_pub_topic, "helloworld")
LIB_DelayMs(5000)
end
LIB_Cat1MqttEC800Config(p1~p14)
函数描述: 配置Cat1 4G 模块(EC800)以MQTT方式工作,并设置相关参数
p1 | EC800模块的UART引脚占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | EC800模块的RST引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 配置EC800模块的RST引脚是低电平复位还是高电平复位(取决于您的Cat1模块电路实现原理) |
---|---|
"LOW","HIGH" |
p4 | EC800模块的PWR引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p5 | 配置EC800模块的PWR引脚是低电平开机还是高电平开机(取决于您的Cat1模块电路实现原理) |
---|---|
"LOW","HIGH" |
p6 | 字符串型,服务器的IP地址 |
---|---|
无 |
p7 | 整数型,服务器的端口号 |
---|---|
无 |
p8 | MQTT连接参数: client ID |
---|---|
字符串类型 |
p9 | MQTT连接参数: user name |
---|---|
字符串类型 |
p10 | MQTT连接参数: password |
---|---|
字符串类型 |
p11 | MQTT连接参数: keepalive ,单位:秒 |
---|---|
整数型 |
p12 | MQTT订阅路径: subscribe topic |
---|---|
字符串类型 |
p13 | 订阅消息的QOS等级 |
---|---|
"QOS0","QOS1","QOS2" |
p14 | 配置Cat1模块的GPS是否工作,以及GPS的工作模式。注意1: GPS工作的前提是和server端的通信正常,注意2:GPS功能仅EC800M模组支持 |
---|---|
"NO_GPS": 不开启GPS | |
"NORMAL_GPS": 开启GPS,但不使用AP-FLASH GPS热启动功能 | |
"AUTO_AGPS": 开启GPS和EC800M的AP-FLASH GPS热启动功能 |
应用示例:
xxxxxxxxxx
--设置EC800 Cat1模块占用TX0、RX0、D5、D6引脚,MQTT模式
--MQTT服务器地址(适用于ONE NET平台)
server_addr = "183.230.40.96" --中移物联网MQTT接入服务ip地址
server_port = 1883
--MQTT 连接参数(适用于ONE NET平台)
mqtt_con_clientID = "TestDevice001"
mqtt_con_username = "353255"
mqtt_con_password = "version=2018-10-31&res=products%2F353255%2Fdevices%2FTestDevice001&et=1893427200&method=md5&sign=%2F5RJwGwytPWvVDB04K7rnw%3D%3D"
--MQTT topic相关参数(适用于ONE NET平台)
mqtt_sub_topic = "$sys/353255/TestDevice001/cmd/request/+"--订阅用
mqtt_pub_topic = "$sys/353255/TestDevice001/dp/post/json" --发布用
--KeepAlive周期180秒
--不开启GPS功能
LIB_Cat1MqttEC800Config("UART0","D5","HIGH","D6","HIGH",server_addr,server_port,mqtt_con_clientID,mqtt_con_username,mqtt_con_password,180,mqtt_sub_topic,"QOS0","NO_GPS")
r1,r2,r3 = LIB_Cat1MqttEC800RecvSub()
函数描述: 查询是否收到服务器(broker)下发的订阅消息,该消息总长度尽量不要超过256字节
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | 字符串型,接收到的订阅数据的topic |
---|---|
无 |
r3 | 字符串型,接收到的订阅数据的内容 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置EC800 Cat1模块占用TX0、RX0、D5、D6引脚,MQTT模式
--MQTT服务器地址(适用于ONE NET平台)
server_addr = "183.230.40.96" --中移物联网MQTT接入服务ip地址
server_port = 1883
--MQTT 连接参数(适用于ONE NET平台)
mqtt_con_clientID = "TestDevice001"
mqtt_con_username = "353255"
mqtt_con_password = "version=2018-10-31&res=products%2F353255%2Fdevices%2FTestDevice001&et=1893427200&method=md5&sign=%2F5RJwGwytPWvVDB04K7rnw%3D%3D"
--MQTT topic相关参数(适用于ONE NET平台)
mqtt_sub_topic = "$sys/353255/TestDevice001/cmd/request/+"--订阅用
mqtt_pub_topic = "$sys/353255/TestDevice001/dp/post/json" --发布用
--KeepAlive周期180秒
--不开启GPS功能
LIB_Cat1MqttEC800Config("UART0","D5","HIGH","D6","HIGH",server_addr,server_port,mqtt_con_clientID,mqtt_con_username,mqtt_con_password,180,mqtt_sub_topic,"QOS0","NO_GPS")
while(GC(1) == true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,topic,data = LIB_Cat1MqttEC800RecvSub()
if recv_flag == 1 then
print(string.format("Get datas on topic %s: %s", topic, data))
end
end
LIB_Cat1MqttEC800SendPub(p1,p2,p3)
函数描述: 向对端订阅的p2所指示的主题(topic)发送publish消息 注意:1. 只有当MQTT连接成功后,调用该函数才会发送,否则该函数会自动忽略对其的调用
- p2和p3的长度总和尽量不要超过200字节
p1 | QOS等级 |
---|---|
"QOS0","QOS1","QOS2" |
p2 | MQTT发布路径: publish topic |
---|---|
字符串类型 |
p3 | MQTT发布内容 |
---|---|
字符串类型 |
应用示例:
xxxxxxxxxx
--设置EC800 Cat1模块占用TX0、RX0、D5、D6引脚,MQTT模式
--MQTT服务器地址(适用于ONE NET平台)
server_addr = "183.230.40.96" --中移物联网MQTT接入服务ip地址
server_port = 1883
--MQTT 连接参数(适用于ONE NET平台)
mqtt_con_clientID = "TestDevice001"
mqtt_con_username = "353255"
mqtt_con_password = "version=2018-10-31&res=products%2F353255%2Fdevices%2FTestDevice001&et=1893427200&method=md5&sign=%2F5RJwGwytPWvVDB04K7rnw%3D%3D"
--MQTT topic相关参数(适用于ONE NET平台)
mqtt_sub_topic = "$sys/353255/TestDevice001/cmd/request/+"--订阅用
mqtt_pub_topic = "$sys/353255/TestDevice001/dp/post/json" --发布用
--KeepAlive周期180秒
--不开启GPS功能
LIB_Cat1MqttEC800Config("UART0","D5","HIGH","D6","HIGH",server_addr,server_port,mqtt_con_clientID,mqtt_con_username,mqtt_con_password,180,mqtt_sub_topic,"QOS0","NO_GPS")
while(GC(1) == true)
do
--每隔5秒向服务器publish一次消息
LIB_Cat1MqttEC800SendPub("QOS0", mqtt_pub_topic, "helloworld")
LIB_DelayMs(5000)
end
r1,r2,r3,r4 = LIB_Cat1StatusQuery()
函数描述: 查询Cat1模块的状态,以及IMSI、ICCID号、信号强度 注意:该函数最好在Cat1模块上电后5秒再调用
r1 | 字符串,指示模块当前的状态 |
---|---|
"PowerOff":模块还未开始工作 | |
"PowerOn":模块上电完成 | |
"SimOK":sim卡正常 | |
"Attached":已附着附近的基站 | |
"Connected":已和服务器建立连接 |
r2 | 字符串,Sim卡的IMSI号 |
---|---|
数字串 |
r3 | 字符串,Sim卡的ICCID号 |
---|---|
数字串 |
r4 | 整数型,CSQ信号强度(RSSI) |
---|---|
0:低于-113dB 1:-111dB 2~30:-109dB~-53dB 31:高于-51dB 99:未知 当CSQ值低于10就表明信号不好 | |
注意:该信号强度只是模块上电入网时的信号强度,并不会实时变化 |
应用示例:
xxxxxxxxxx
State,IMSI,ICCID,CSQ = LIB_Cat1StatusQuery()
print(string.format("module State: %s", State))
print(string.format("module IMSI: %s", IMSI))
print(string.format("module ICCID: %s", ICCID))
print(string.format("module CSQ: %d ", CSQ))
r1~r16 = LIB_Cat1GpsQuery()
函数描述: 查询Cat1是产生新的GPS定位数据,返回的数据中包含已浮点化的经度值(r2),纬度值(r3), 海拔高度值(r4),以及标准UTC时间,以供方便开发者使用,但NMEA协议字符串提供更详细的定位信息。
r1 | 整数型,指示是否读到GPS数据 |
---|---|
0: 未读到 1: 已读到 |
r2 | 浮点小数型,经度(longtitude),单位:度 |
---|---|
正数表示东经,负数表示西经 |
r3 | 浮点小数型,纬度(latitude),单位:度 |
---|---|
正数表示北纬,负数表示南纬 |
r4 | 浮点小数型,海拔(altitude),单位:米 |
---|---|
无 |
r5 | 整数型(32位),UTC时间 单位:秒 |
---|---|
无 |
r6 | NMEA协议字符串 time |
---|---|
时间:hhmmss.sss 格式参考NMEA协议的GGA格式 |
r7 | NMEA协议字符串 latitude |
---|---|
维度:ddmm.mmmmN/S 格式参考NMEA协议的GGA格式 |
r8 | NMEA协议字符串 longtitude |
---|---|
经度:dddmm.mmmm/E/W 格式参考NMEA协议的GGA格式 |
r9 | NMEA协议字符串 hdop |
---|---|
水平精度因子 格式参考NMEA协议的GGA格式 |
r10 | NMEA协议字符串 altitude |
---|---|
海拔,单位米 格式参考NMEA协议的GGA格式 |
r11 | NMEA协议字符串 fix |
---|---|
定位类型,0:未定位,2:2D定位,3:3Dd定位 格式参考NMEA协议的GSA格式 |
r12 | NMEA协议字符串 cog |
---|---|
运动角度 格式参考NMEA协议的VTG格式 |
r13 | NMEA协议字符串 spkm |
---|---|
水平运动速度,单位:Km/h 格式参考NMEA协议的VTG格式 |
r14 | NMEA协议字符串 spkn |
---|---|
水平运动速度,单位:Knots 格式参考NMEA协议的VTG格式 |
r15 | NMEA协议字符串 date |
---|---|
日期,日月年 格式参考NMEA协议的RMC格式 |
r16 | NMEA协议字符串 nsat |
---|---|
正在使用的卫星数量 格式参考NMEA协议的GGA格式 |
应用示例:
xxxxxxxxxx
--设置Cat1模块占用TX0、RX0、D5、D6引脚,TCP Client模式
--tcp服务器IP:"103.46.128.49" 端口号:28438
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpConfig函数的p8参数详细介绍
--开启GPS功能,请在ApiDoc文档中查阅关于LIB_Cat1TcpUdpConfig函数的p10参数详细介绍
LIB_Cat1TcpUdpConfig("UART0","D5","HIGH","D6","HIGH","103.46.128.49",28438,0,"TCP","NORMAL_GPS")
--开始大循环
while(true)
do
--查询是否解析到GPS数据
flag,lo_f,la_f,al_f,utc,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16 = LIB_Cat1GpsQuery()
if flag == 1 then
--将读取到的经度、纬度、海拔、UTC时间打印输出
print(string.format("longtitue:%.3f° latitue:%.3f° altitue:%.0fm UTC:%d", lo_f,la_f,al_f,utc))
end
end
LIB_LoraConfig(p1,p2,p3,p4,p5,p6,p7)
函数描述: 配置Lora模块(ATK-LORA-01/02或ATK-MWCC68S/D)占用的引脚端口,以及Lora通信相关参数的初始化 注意1: ATK-MWCC68S和ATK-LORA-02模块不能互相通信,必须要同种型号的模块才可以 注意2: ATK-MWCC68S比ATK-LORA-02模块多出一个RST引脚,不用时可悬空,但也可用来当应用层代码判断CC68模块可能出现异常时复位该模块,以增强通信的稳定可靠性
p1 | Lora模块的UART占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | Lora模块的Aux占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | Lora模块的Md0占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p4 | 整数型,Lora模块的通信地址 |
---|---|
范围:0-65535 |
p5 | 整数型,Lora模块的通信信道 |
---|---|
范围:410Mhz-493Mhz 注意:LORA-02仅支持410Mhz-441Mhz |
p6 | Lora模块的无线通信速率 |
---|---|
"0.3kpbs" "1.2kpbs" "2.4kpbs" "4.8kpbs" "9.6kpbs" "19.2kpbs" "38.4kpbs" "62.5kpbs" 注意:LORA-02模块最大支持到19.2 |
p7 | Lora模块的无线发射功率 |
---|---|
"11dB" "14dB" "17dB" "20dB" "22dB" 注意:LORA-02最大仅支持20dB |
p8(可选) | Lora模块的网络NetID |
---|---|
0-255,只有NetID相同的模组之间才可通信,该参数可用来组网 注意:仅MWCC68S模块支持该参数 |
应用示例:
xxxxxxxxxx
--设置Lora模块占用TX0、RX0、Aux接D5引脚,Md0接D6引脚
--Lora通信参数:地址=100,通信信道=433M,无线速率=9.6kbps,发射功率=20dBm
LIB_LoraConfig("UART0","D5","D6",100,433,"9.6kpbs","20dB")
r1,r2,r3 = LIB_LoraRecv()
函数描述: 查询是否收到Lora对端发来的数据,如果收到数据则返回接收到的数据来源及内容。注意对端发来的每个数据包尽量不要大于16字节,且数据包时间间隔尽量不要小于1秒
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | 整数型,数据来源地址 |
---|---|
Lora地址范围应该在0-65535 |
r3 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置Lora模块占用TX0、RX0、Aux接D5引脚,Md0接D6引脚
--Lora通信参数:地址=100,通信信道=433M,无线速率=9.6kbps,发射功率=20dBm
LIB_LoraConfig("UART0","D5","D6",100,433,"9.6kpbs","20dB")
while(true)
do
--查询是否收到数据,如果收到就print输出收到的数据个数,以及数据来源地址
recv_flag,recv_addr,recv_tab = LIB_LoraRecv()
if recv_flag == 1 then
print(string.format("receive %d bytes from %d", #recv_tab, recv_addr))
end
end
LIB_LoraSend(p1,p2)
函数描述: 将p2数组中的数据发送到地址为p1的Lora对端,每包发送的数据量不要超过16字节,每包发送间隔时间也尽量大于1秒
p1 | 整数型,发送目的地址 |
---|---|
范围:0-65535 |
p2 | table类型 |
---|---|
table内的元素必须为字节型,元素个数尽量不超过16个 |
应用示例:
xxxxxxxxxx
--设置Lora模块占用TX0、RX0、Aux接D5引脚,Md0接D6引脚
--Lora通信参数:地址=100,通信信道=433M,无线速率=9.6kbps,发射功率=20dBm
LIB_LoraConfig("UART0","D5","D6",100,433,"9.6kpbs","20dB")
table = {1,2,3,4,5}
while(true)
do
--每隔5秒向地址为122的对端Lora节点发送一包5字节的数据
LIB_LoraSend(122,table)
LIB_DelayMs(5000)
end
LIB_IntWifiTcpConfig(p1,p2,p3,p4,p5)
函数描述: 配置内部WIFI开始工作,并以TCP Client方式和Server(服务器)通信
p1 | 字符串型,路由器SSID(账号) |
---|---|
无 |
p2 | 字符串型,路由器Password(密码) |
---|---|
无 |
p3 | 字符串型,服务器的IP地址或域名 |
---|---|
无 |
p4 | 整数型,服务器的端口号 |
---|---|
无 |
p5 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于20秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内即没收到服务器的心跳包响应也没收到服务器下发的任意数据,此时Core会认为服务器已断联,Core会自动重启尝试看是否能够修复Wifi通信 |
注意1:心跳包是由开发者在Lua代码中以不大于p5的心跳时间间隔向服务器发送一包数据,并且服务器应返回心跳包响应数据。心跳包及响应的具体内容和长度由您和服务器端开发人员商量。 注意2:当p5的值为0的时候,Core默认关闭心跳机制(即Core不会因为服务器长时间没有数据下发而重启),但真正开发产品时还是需要您和服务器端开发人员商量好心跳包的策略,这样就能保证wifi模块常年不掉线。 注意3:开发者在使用心跳机制时,必须要考虑Core重启带来的后果,权衡重启是否会带来不可接受的后果!
应用示例:
xxxxxxxxxx
--设置TCP Client模式
--路由器账号:mywifi 路由器密码:abc123,tcp服务器域名:www.shineblink.com 端口号:1266
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_IntWifiTcpConfig函数的p5参数详细介绍
LIB_IntWifiTcpConfig("mywifi","abc123","www.shineblink.com",1266,0)
r1,r2 = LIB_IntWifiTcpRecv()
函数描述: 查询是否收到TCP server发来数据,如果收到数据则返回接收到的数据。注意服务端下发的每个数据包不要大于256字节,且数据包时间间隔尽量不要小于200ms
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置TCP Client模式
--路由器账号:mywifi 路由器密码:abc123,tcp服务器域名:www.shineblink.com 端口号:1266
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_IntWifiTcpConfig函数的p5参数详细介绍
LIB_IntWifiTcpConfig("mywifi","abc123","www.shineblink.com",1266,0)
while(GC(1) == true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,recv_tab = LIB_IntWifiTcpRecv()
if recv_flag == 1 then
print(string.format("tcp receive %d bytes", #recv_tab))
end
end
LIB_IntWifiTcpSend(p1)
函数描述: 发送p1数组中的数据,每包发送的数据量不要超过256字节,发送间隔时间也尽量大于200ms 注意:只有当TCP连接成功后,调用该函数才会发送,否则该函数会自动忽略对其的调用
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
应用示例:
xxxxxxxxxx
--设置TCP Client模式
--路由器账号:mywifi 路由器密码:abc123,tcp服务器域名:www.shineblink.com 端口号:1266
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_IntWifiTcpConfig函数的p5参数详细介绍
LIB_IntWifiTcpConfig("mywifi","abc123","www.shineblink.com",1266,0)
table = {1,2,3,4,5}
while(GC(1) == true)
do
--每隔5秒发送一次心跳包数据
LIB_IntWifiTcpSend(table)
LIB_DelayMs(5000)
end
LIB_IntWifiUdpConfig(p1,p2,p3,p4,p5)
函数描述: 配置内部WIFI开始工作,并以UDP Client方式和UDP Server通信
p1 | 字符串型,路由器SSID(账号) |
---|---|
无 |
p2 | 字符串型,路由器Password(密码) |
---|---|
无 |
p3 | 字符串型,服务器的IP地址或域名 |
---|---|
无 |
p4 | 整数型,服务器的端口号 |
---|---|
无 |
p5 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于20秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内即没收到服务器的心跳包响应也没收到服务器下发的任意数据,此时Core会认为服务器已断联,Core会自动重启尝试看是否能够修复Wifi通信 |
注意1:心跳包是由开发者在Lua代码中以不大于p5的心跳时间间隔向服务器发送一包数据,并且服务器应返回心跳包响应数据。心跳包及响应的具体内容和长度由您和服务器端开发人员商量。 注意2:当p5的值为0的时候,Core默认关闭心跳机制(即Core不会因为服务器长时间没有数据下发而重启),但真正开发产品时还是需要您和服务器端开发人员商量好心跳包的策略,这样就能保证wifi模块常年不掉线。 注意3:开发者在使用心跳机制时,必须要考虑Core重启带来的后果,权衡重启是否会带来不可接受的后果!
应用示例:
xxxxxxxxxx
--设置UDP Client模式
--路由器账号:mywifi 路由器密码:abc123,udp服务器域名:www.shineblink.com 端口号:1266
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_IntWifiUdpConfig函数的p5参数详细介绍
LIB_IntWifiUdpConfig("mywifi","abc123","www.shineblink.com",1266,0)
r1,r2 = LIB_IntWifiUdpRecv()
函数描述: 查询是否收到UDP server发来数据,如果收到数据则返回接收到的数据。注意服务端下发的每个数据包不要大于256字节,且数据包时间间隔尽量不要小于200ms
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置UDP Client模式
--路由器账号:mywifi 路由器密码:abc123,udp服务器域名:www.shineblink.com 端口号:1266
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_IntWifiUdpConfig函数的p5参数详细介绍
LIB_IntWifiUdpConfig("mywifi","abc123","www.shineblink.com",1266,0)
while(GC(1) == true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,recv_tab = LIB_IntWifiUdpRecv()
if recv_flag == 1 then
print(string.format("udp receive %d bytes", #recv_tab))
end
end
LIB_IntWifiUdpSend(p1)
函数描述: 发送p1数组中的数据,每包发送的数据量不要超过256字节,发送间隔时间也尽量大于200ms
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
应用示例:
xxxxxxxxxx
--设置UDP Client模式
--路由器账号:mywifi 路由器密码:abc123,udp服务器域名:www.shineblink.com 端口号:1266
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_IntWifiUdpConfig函数的p5参数详细介绍
LIB_IntWifiUdpConfig("mywifi","abc123","www.shineblink.com",1266,0)
table = {1,2,3,4,5}
while(GC(1) == true)
do
--每隔5秒发送一次心跳包数据
LIB_IntWifiUdpSend(table)
LIB_DelayMs(5000)
end
LIB_MQTTC2Config(p1~p11)
函数描述: 配置内部WIFI开始工作,并以MQTT Client方式和MQTT Server通信
p1 | 字符串型,路由器SSID(账号) |
---|---|
无 |
p2 | 字符串型,路由器Password(密码) |
---|---|
无 |
p3 | 字符串型,服务器的IP地址或域名 |
---|---|
无 |
p4 | 整数型,服务器的端口号 |
---|---|
无 |
p5 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于20秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内即没收到服务器的心跳包响应也没收到服务器下发的任意数据,此时Core会认为服务器已断联,Core会自动重启尝试看是否能够修复Wifi通信 |
p6 | MQTT连接参数: client ID |
---|---|
字符串类型 |
p7 | MQTT连接参数: user name |
---|---|
字符串类型 |
p8 | MQTT连接参数: password |
---|---|
字符串类型 |
p9 | MQTT连接参数: keepalive ,单位:秒 |
---|---|
整数型 |
p10 | MQTT订阅路径: subscribe topic |
---|---|
字符串类型 |
p11 | 订阅消息的QOS等级 |
---|---|
"QOS0","QOS1","QOS2" |
注意1:心跳包是由开发者在Lua代码中以不大于p7的心跳时间间隔向服务器发送一包数据,并且服务器应返回心跳包响应数据。心跳包及响应的具体内容和长度由您和服务器端开发人员商量。 注意2:当p5的值为0的时候,Core默认关闭心跳机制(即Core不会因为服务器长时间没有数据下发而重启),但真正开发产品时还是需要您和服务器端开发人员商量好心跳包的策略,这样就能保证wifi模块常年不掉线。 注意3:开发者在使用心跳机制时,必须要考虑Core重启带来的后果,权衡重启是否会带来不可接受的后果!
应用示例:
xxxxxxxxxx
--设置Mqtt Client模式
--路由器账号:mywifi 路由器密码:abc123,Mqtt服务器域名:www.shineblink.com 端口号:1883
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_MQTTC2Config函数的p5参数详细介绍
--Mqtt ClientID="test01", UserName="12345", Password="555666", KeepAlive=60秒, 订阅"/topic/t1", Qos0。
LIB_MQTTC2Config("mywifi","abc123","www.shineblink.com",1883,0,"test01","12345","555666",60,"/topic/t1","QOS0")
r1,r2,r3 = LIB_MqttC2RecvSub()
函数描述: 查询是否收到服务器( broker )下发的订阅消息
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | 字符串型,接收到的订阅数据的topic |
---|---|
无 |
r3 | 字符串型,接收到的订阅数据的内容 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置Mqtt Client模式
--路由器账号:mywifi 路由器密码:abc123,Mqtt服务器域名:www.shineblink.com 端口号:1883
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_MQTTC2Config函数的p5参数详细介绍
--Mqtt ClientID="test01", UserName="12345", Password="555666", KeepAlive=60秒, 订阅"/topic/t1", Qos0。
LIB_MQTTC2Config("mywifi","abc123","www.shineblink.com",1883,0,"test01","12345","555666",60,"/topic/t1","QOS0")
while(GC(1) == true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,topic,data = LIB_MqttC2RecvSub()
if recv_flag == 1 then
print(string.format("Get datas on topic %s: %s", topic, data))
end
end
LIB_MqttC2SendPub(p1,p2,p3)
函数描述: 向服务器订阅的p2主题publish消息 注意:只有当MQTT连接成功后,调用该函数才会发送,否则该函数会自动忽略对其的调用
p1 | QOS等级 |
---|---|
"QOS0","QOS1","QOS2" |
p2 | MQTT发布路径: publish topic |
---|---|
字符串类型 |
p3 | MQTT发布内容 |
---|---|
字符串类型 |
应用示例:
xxxxxxxxxx
--设置Mqtt Client模式
--路由器账号:mywifi 路由器密码:abc123,Mqtt服务器域名:www.shineblink.com 端口号:1883
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_MQTTC2Config函数的p5参数详细介绍
--Mqtt ClientID="test01", UserName="12345", Password="555666", KeepAlive=60秒, 订阅"/topic/t1", Qos0。
LIB_MQTTC2Config("mywifi","abc123","www.shineblink.com",1883,0,"test01","12345","555666",60,"/topic/t1","QOS0")
while(GC(1) == true)
do
--每隔5秒向服务器publish一次消息
LIB_MqttC2SendPub("QOS0", "/pubtopic/update", "helloworld")
LIB_DelayMs(5000)
end
LIB_CloudConfig(p1~p7)
函数描述: 设置连接云的相关参数,并开始连云
p1 | 云代号 |
---|---|
目前固定为"S0" |
p2 | 通信类型 |
---|---|
目前支持"WIFI_C2"和"4G_ML302"和"4G_EC800" 注意:如果选择的是4G_ML302或4G_EC800那么会固定占用开发板的RX0,TXO,D5,D6四个引脚,如果选择的是WIFI_C2则不占用任何引脚 |
p3 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于30秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内即没收到服务器的心跳包响应也没收到服务器下发的任意数据,此时Core会认为服务器已断联,Core会自动重启尝试看是否能够修复Wifi通信或4G通信 |
p4 | 字符串型,ProductName |
---|---|
产品名称,如果是ShineBlink开发板,目前必须为"SBK_01" |
p5 | 字符串型,UI配置信息 |
---|---|
通过p5中字符串的内容,即可定义显示在小程序/App/网页端的数据内容,字符串具体格式定义方法请查阅相关文档 |
p6 | 字符串型,路由器SSID(账号) |
---|---|
注意:如果通信类型为"WIFI_C2"时才需要p6参数 |
p6 | 配置Cat1模块的GPS是否工作,以及GPS的工作模式。注意: GPS工作的前提是和server端的通信正常 |
---|---|
"NO_GPS": 不开启GPS | |
"NORMAL_GPS": 开启GPS,但不使用AGPS功能 | |
"AUTO_AGPS": 开启GPS和AGPS,并且每隔4个小时后如果再次重新上电调用LIB_Cat1HttpConfig会耗费下载星历数据的流量(5KB) | |
"FORCE_AGPS": 开启GPS和AGPS,并且每次重新上电后调用LIB_Cat1MqttML302Config必定会耗费下载星历数据的流量(5KB),该模式适合套餐流量充足的或者追求快速定位的 | |
注意:如果通信类型为"4G_ML302"时才需要p6参数, GPS结果可以通过LIB_Cat1GpsQuery()函数查询 |
p7 | 字符串型,路由器Password(密码) |
---|---|
注意:如果通信类型为"WIFI_C2"时才需要p7参数 |
注意1:心跳包是由开发者在Lua代码中以不大于p3的心跳时间间隔向服务器发送一包数据,并且服务器应返回心跳包响应数据。心跳包及响应的具体内容和长度由您和服务器端开发人员商量。 注意2:当p3的值为0的时候,Core默认关闭心跳机制(即Core不会因为服务器长时间没有数据下发而重启自身或者4G模块),但真正开发产品时还是需要您和服务器端开发人员商量好心跳包的策略,这样就能保证WiFi/4G模块常年不掉线。
应用示例:
xxxxxxxxxx
UI = "[0_RecvBox][1_humi_%_0_100][2_Door][3_Bulb][4_SendBox][5_Light_%_0_100]"
--设置C2自带的WiFi连接云,WiFi账号abcd,密码1234
LIB_CloudConfig("S0", "WIFI_C2", 0, "SBK_01", UI, "abcd", "1234")
--或者设置外接的4G模块EC800连接云,"NO_GPS"表示该模块不带GPS功能
LIB_CloudConfig("S0", "4G_EC800", 0, "SBK_01", UI, "NO_GPS")
r1,r2 = LIB_CloudRecv()
函数描述: 查询是否收到服务器下发的json消息
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | 字符串型,接收到的消息的内容 |
---|---|
无 |
应用示例:
xxxxxxxxxx
UI = "[0_RecvBox][1_humi_%_0_100][2_Door][3_Bulb][4_SendBox][5_Light_%_0_100]"
--设置C2自带的WiFi连接云,WiFi账号abcd,密码1234
LIB_CloudConfig("S0", "WIFI_C2", 0, "SBK_01", UI, "abcd", "1234")
while(GC(1) == true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag, msg = LIB_CloudRecv()
if recv_flag == 1 then
print(string.format("Get msg: %s", msg))
end
end
LIB_CloudSend(p1)
函数描述: 向服务器发送json消息,json消息中的Key值必须和UI描述符中的匹配 注意:只有当云连接成功后,调用该函数才会发送,否则该函数会自动忽略对其的调用。另外该函数的调用时间间隔必须大于1秒以上,低于1秒调用时会被忽略
p1 | 需要发送的消息内容 |
---|---|
字符串类型 |
应用示例:
xxxxxxxxxx
UI = "[0_RecvBox][1_humi_%_0_100][2_Door][3_Bulb][4_SendBox][5_Light_%_0_100]"
--设置C2自带的WiFi连接云,WiFi账号abcd,密码1234
LIB_CloudConfig("S0", "WIFI_C2", 0, "SBK_01", UI, "abcd", "1234")
while(GC(1) == true)
do
--每隔5秒向服务器publish一次消息,告诉云当前湿度值为80%
LIB_CloudSend("{\"humi\":80}")
LIB_DelayMs(5000)
end
LIB_GizWifiConfig(p1~p8)
函数描述: 配置带有GAgent固件的wifi模块(esp8266)占用的引脚端口,wifi模块开始按照函数中的参数自动连接机智云开始工作
p1 | 字符串类型 ,机智云开发平台为产品分配的ProductKey |
---|---|
注意: 当您的产品量产时,这个ProductKey需要保密 |
p2 | 字符串类型 ,机智云开发平台为产品分配的ProductSecret |
---|---|
注意: 当您的产品量产时,这个ProductSecret需要保密 |
p3 | 整数型,数据上传间隔时间,单位:ms,增大数据上传间隔时间有利于节省流量 |
---|---|
注意:该参数只会影响Rs1-Rs6,RL7-RL8,Rf1-Rf4这种整数型和浮点型的数据上传间隔时间 而像In1-In8这些状态位和RawData透传数组只要发生变化WIFI模块就会立刻上传给服务器 |
p4 | 整数型,Core和WIFI模块的最大通讯间隔时间 ,单位:秒,建议该值不要小于120秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内没收到WIFI模块的串口数据,此时Core会认为WIFI模块出问题了,Core会重新尝试通过RST引脚重启WIFI模块 当该值为0时关闭该机制 |
p5 | WIFI模块的UART引脚占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p6 | WIFI模块的RST引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p7 | 配网按键Key占用的core引脚配置(按键低电平有效),当检测到用户短按按键时WIFI模块开启AirLink配网,长按(3秒)时开启SoftAp配网,长按(10秒)时清空WIFI模块上的网络配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p8 | 用来指示WIFI状态的LED灯的引脚占用的core引脚配置,WIFI模块处于AirLink配网状态时LED快闪,处于SoftAp配网状态时LED慢闪(1秒)。处于连接路由器状态时常亮,否则常灭 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
应用示例:
xxxxxxxxxx
--机智云平台为每个产品分配的唯一ProductKey和ProdectSecret
PK = "86de0fb507a54f5ab9583dbe3ffc349a"
PS = "07f6d7ed64ec45d09cebaf2dd73d345e"
--设置PK,PS,上传间隔时间6000ms,并且WIFI模块占用开发板的TX0、RX0、D5(RST)引脚
--如果120秒内没收到WIFI模块的信息,则自动通过RST引脚复位WIFI模块,以提高系统健壮性
--配网按键KEY占用D10引脚,短按开启AirLink配网,长按(3秒)开启SoftAp配网,长按(10秒)删除网络配置
--状态指示灯LED占用D8引脚,LED灯快闪表示WIFI模块处于AirLink中,慢闪表示处于SoftAp中。常亮表示连上了路由器,否则常灭
LIB_GizWifiConfig(PK,PS,6000,120,"UART0","D5","D10","D8")
LIB_Giz4GConfig(p1~p9)
函数描述: 配置带有GAgent固件的4G模块(ML302)占用的引脚端口,4G模块开始按照函数中的参数自动连接机智云开始工作
p1 | 字符串类型 ,机智云开发平台为产品分配的ProductKey |
---|---|
注意: 当您的产品量产时,这个ProductKey需要保密 |
p2 | 字符串类型 ,机智云开发平台为产品分配的ProductSecret |
---|---|
注意: 当您的产品量产时,这个ProductSecret需要保密 |
p3 | 整数型,数据上传间隔时间,单位:ms,增大数据上传间隔时间有利于节省流量 |
---|---|
注意:该参数只会影响Rs1-Rs6,RL7-RL8,Rf1-Rf4这种整数型和浮点型的数据上传间隔时间 而像In1-In8这些状态位和RawData透传数组只要发生变化WIFI模块就会立刻上传给服务器 |
p4 | 整数型,Core和4G模块的最大通讯间隔时间 ,单位:秒,建议该值不要小于120秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内没收到4G模块的串口数据,此时Core会认为4G模块出问题了,Core会重新尝试通过RST引脚重启4G模块 当该值为0时关闭该机制 |
p5 | 4G模块的UART引脚占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p6 | 4G模块的RST引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p7 | 配置4G模块的RST引脚是低电平复位还是高电平复位(取决于您的4G模块电路实现原理) |
---|---|
"LOW","HIGH" |
p8 | 4G模块的PWR引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p9 | 配置4G模块的PWR引脚是低电平开机还是高电平开机(取决于您的4G模块电路实现原理) |
---|---|
"LOW","HIGH" |
应用示例:
xxxxxxxxxx
--机智云平台为每个产品分配的唯一ProductKey和ProdectSecret
PK = "86de0fb507a54f5ab9583dbe3ffc349a"
PS = "07f6d7ed64ec45d09cebaf2dd73d345e"
--设置PK,PS,上传间隔时间6000ms,并且4G模块(ML302)占用开发板的TX0、RX0、D5(RST)、D6(PWR)引脚
--如果120秒内没收到4G模块的信息,则自动通过RST引脚复位4G模块,以提高系统健壮性
LIB_Giz2G4GConfig(PK,PS,6000,120,"UART0","D5","HIGH","D6","HIGH")
LIB_SendToGizCloud(p1,p2)
函数描述: 向机智云发送各种类型的数据
p1 | 字符串类型,要发送的数据的变量句柄 |
---|---|
如果需要发送的是输入开关状态,可以用"In1"~"In8"这8个句柄,发送值必须是0或1 | |
如果需要发送的是-10000~50000之间的整数值,可以用"Rs1"~"Rs6"这6个句柄 | |
如果需要发送的是-10000000~50000000之间的整数值,可以用"RL7"~"RL8"这2个句柄 | |
如果需要发送的是-1000.0~5000.0之间的小数值,可以用"Rf1"~"Rf2"这2个句柄 | |
如果需要发送的是-100.00~500.00之间的小数值,可以用"Rf3"~"Rf4"这2个句柄 | |
如果需要发送的是一串开发者自定义Hex字节数据,可以用"RawData"这个句柄,这个句柄中需放入64字节的数据 |
p2 | 发送的数据值,根据上面p1不同的句柄,类型也不同 |
---|---|
如果p1是"In1"~"In8",该值必须是0或1 | |
如果p1是"Rs1"~"Rs6",该值必须是-10000~50000 | |
如果p1是"RL7"~"RL8",该值必须是-10000000~50000000 | |
如果p1是"Rf1"~"Rf2",该值必须是-1000.0~5000.0 | |
如果p1是"Rf3"~"Rf4",该值必须是-100.00~500.00 | |
如果p1是"RawData",该值一个64字节元素的Table(数组) |
应用示例:
xxxxxxxxxx
--向机智云服务器发送一个开关量为1
LIB_SendToGizCloud("In1", 1)
--向机智云服务器发送一个数值96
LIB_SendToGizCloud("Rs1", 96)
--向机智云服务器发送一个带小数点的值
LIB_SendToGizCloud("Rf4", 200.12)
--向机智云服务器发送64字节的数据
SendData = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60}
LIB_SendToGizCloud("RawData",SendData)
r1,r2 = LIB_RecvFromGizCloud(p1)
函数描述: 从机智云接收各种类型的数据
p1 | 字符串类型,要接收的数据的变量句柄 |
---|---|
如果需要接收的是设置开关状态量,可以用"Sw1"~"Sw8"这8个句柄,如果接收到,则返回的是0或1这样的整数 | |
如果需要接收的是枚举值,可以用"Em1"~"Em2"这2个句柄,如果接收到,则返回的是0,1,3,4,5... 这样的整数 | |
如果需要接收的是在0-100范围的数值,可以用"Ws1"~"Ws4"这4个句柄,如果接收到,则返回的是0-100这样的整数 | |
如果需要接收的是在-10000000 - 50000000范围的数值,可以用"WL5"~"WL8"这4个句柄,如果接收到,则返回的是-10000000 - 50000000这样的整数 | |
如果需要接收的是64字节数据,可以用"RawData"这个句柄,如果接收到,则返回的是一个包含64字节元素的Table(数组) |
r1 | 整数型,指示是否收到机智云发下的数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | 机智云下发的具体数据值,根据上面p1不同的句柄,返回的数据类型也不同 |
---|---|
如果p1是"Sw1"~"Sw8",返回的数据值是0或1这样的整数 | |
如果p1是"Em1"~"Em2",返回的数据值是0,1,3,4,5...这样的整数 | |
如果p1是"Ws1"~"Ws4",返回的数据值是0-100这样的整数 | |
如果p1是"WL5"~"WL8",返回的数据值是-10000000 - 50000000这样的整数 | |
如果p1是"RawData",返回的数据值是一个包含64字节元素的Table(数组) |
应用示例:
xxxxxxxxxx
--查询机智云是否下发了写Sw1开关量的数据
flag,recv_data = LIB_RecvFromGizCloud("Sw1")
if flag == 1 then
if recv_data == 1 then --置1开关
--执行相应的动作,比如开灯,电机通电等
else
--执行相应的动作,比如关灯,电机断电等
end
end
xxxxxxxxxx
--查询机智云是否下发了需要写入的整数数据
flag,recv_data = LIB_RecvFromGizCloud("Ws2")
if flag == 1 then --此时获取到一个范围在0-100的整数
--根据获取的整数值recv_data执行相应的操作
end
xxxxxxxxxx
--查询机智云是否下发了64字节的数组
flag,recv_data = LIB_RecvFromGizCloud("RawData")
if flag == 1 then --此时获取到一个包含64字节元素的table(数组)
--逐个打印这64个元素
for i, v in ipairs(recv_data) do
print(i, v)
end
end
LIB_SetGizWifiMode(p1)
函数描述: 设置Wifi模块进入某种工作状态
p1 | 字符串类型,工作模式选择参数 |
---|---|
"FactoryReset" "SoftAp" "AriLink" "FactroyTest" "Binding" "reboot" |
应用示例:
xxxxxxxxxx
--设置WIFi模块进入AriLink配网模式
LIB_SetGizWifiMode("AriLink")
--设置WIFi模块进入SoftAp配网模式
LIB_SetGizWifiMode("SoftAp")
r1=LIB_GetGizWifiState()
函数描述: 获取当前WIFI模块的工作状态
r1 | 函数返回的状态值,具体定义如下 |
---|---|
0:unknow 1:Airlink 2:softap 3:station 4:connect router 5:disconnect 6:connect m2m 7:disconnect m2m |
应用示例:
xxxxxxxxxx
WifiState = LIB_GetGizWifiState()
print(string.format("Wifi state: %d", WifiState))
LIB_RC522Config(p1)
函数描述: 初始化RC522读卡模块,初始化后,后台会一直寻找有效IC卡的出现
p1 | RC522模块的RST引脚占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
应用示例:
xxxxxxxxxx
--初始化RC522读卡模块,占用core的spi接口以及D7接口
LIB_RC522Config("D7")
r1,r2,r3 = LIB_RC522CardFind()
函数描述: 查询是否发现有效的卡,并返回IC卡的类型字符串和4字节的UID 注意:一旦发现有效的卡后,在1秒内不管卡还在不在检测范围,调用LIB_RC522CardFind都会返回有效卡状态 1秒后如果卡确实不在检测范围后,LIB_RC522CardFind才会返回无卡状态。
r1 | 整数型,指示是否发现有效的卡 |
---|---|
0: 还未发现有效的卡 1: 已发现有效的卡 |
r2 | 字符串型,IC卡的类型字符串 |
---|---|
比如: "M1-S50","M1-S70","MF-UltraLight","MF-Pro","MF Desire" |
r3 | table型,包含4字节的UID |
---|---|
无 |
应用示例:
xxxxxxxxxx
--初始化RC522读卡模块并开始在后台一直寻找有效IC卡的出现
LIB_RC522Config()
--开始大循环
while(GC(1) == true)
do
--如果发现IC卡,就输出其卡类型以及卡的32位ID号
CardFoundFlag,Type,UID = LIB_RC522CardFind()
if CardFoundFlag == 1 then
print(string.format("Type:%s\r\nTag UID:%02x %02x %02x %02x",Type,UID[0],UID[1],UID[2],UID[3]))
end
end
r1 = LIB_RC522CardAuth(p1,p2,p3,p4)
函数描述: 验证密码p3是否和IC卡的扇区p2的密码匹配(在每次读写IC卡时都需要执行该操作)
p1 | 密码验证模式 |
---|---|
"KEYA": 验证A密钥 "KEYB": 验证B密钥 |
p2 | 指定需要验证密码的Sector区 |
---|---|
"Sector0","Sector1","Sector2","Sector3","Sector4","Sector5","Sector6","Sector7","Sector8", "Sector9","Sector10","Sector11","Sector12","Sector13","Sector14","Sector15" |
p3 | table类型 , IC卡的6字节密码 |
---|---|
table内的元素必须为字节型,元素个数必须为6个 |
p4 | table类型,IC卡的4字节UID |
---|---|
table内的元素必须为字节型,元素个数必须为4个 |
r1 | 整数型,指示对IC卡该扇区的密码认证是否成功 |
---|---|
1: 成功 0: 失败 |
应用示例:
xxxxxxxxxx
key = {0x01,0x02,0x03,0x04,0x05,0x06}
uid = {0xa5,0x37,0x8b,0x12}
//用key作为密钥A来验证,是否和ID号为uid的IC卡的扇区2的密码匹配
if LIB_RC522CardAuth("KEYA","Sector2",key,uid) == 1 then
print("KEYA authentication success\r\n")
end
r1,r2 = LIB_RC522CardRead(p1,p2)
函数描述: 读取IC卡p1扇区中的p2块的16个字节数据,执行该函数前需先执行LIB_RC522CardAuth()函数
p1 | 指定需要执行读操作的Sector(扇区)号 |
---|---|
"Sector0","Sector1","Sector2","Sector3","Sector4","Sector5","Sector6","Sector7","Sector8", "Sector9","Sector10","Sector11","Sector12","Sector13","Sector14","Sector15" |
p2 | 指定需要执行读操作的Block(块)号 |
---|---|
"Block0","Block1","Block2","Block3" |
r1 | 整数型,指示对IC卡该块的读操作是否成功 |
---|---|
1: 成功 0: 失败 |
r2 | table型,包含读到的16字节的块数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--读取Sector0扇区的Block2块
result,rd_data = LIB_RC522CardRead("Sector0", "Block2")
if result == 1 then --读操作成功
print(string.format("Read success, the data size is %d bytes\r\n", #rd_tab))
else
print("Read fail\r\n")
end
r1 = LIB_RC522CardWrite(p1,p2,p3)
函数描述: 向IC卡的p1扇区中的p2块写入16个字节数据,执行该函数前需先执行LIB_RC522CardAuth()函数
p1 | 指定需要执行写操作的Sector(扇区)号 |
---|---|
"Sector0","Sector1","Sector2","Sector3","Sector4","Sector5","Sector6","Sector7","Sector8", "Sector9","Sector10","Sector11","Sector12","Sector13","Sector14","Sector15" |
p2 | 指定需要执行写操作的Block(块)号 |
---|---|
"Block0","Block1","Block2","Block3" |
p3 | table类型 , 需要写入的16字节数据 |
---|---|
table内的元素必须为字节型,元素个数必须为16个 |
r1 | 整数型,指示对IC卡该块的写操作是否成功 |
---|---|
1: 成功 0: 失败 |
应用示例:
xxxxxxxxxx
wr_data = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f}
--向Sector0扇区的Block2块写入16字节的数据
result = LIB_RC522CardWrite("Sector0", "Block2", wr_data)
if result == 1 then --写操作成功
print("Write success\r\n")
else--写操作失败
print("Write fail\r\n")
end
LIB_IdCardReaderConfig(p1)
函数描述: 配置ID卡读卡器开始工作
p1 | 读卡器模块占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
应用示例:
xxxxxxxxxx
--设置ID卡读卡器模块占用TX0和RX0引脚
LIB_IdCardReaderConfig("UART0")
r1,r2,r3 = LIB_IdCardReaderGetContent()
函数描述: 查询是否读到ID卡,并输出ID卡的VID号和ID卡号
r1 | 整数型,指示是否读到ID卡 |
---|---|
0: 未读到ID卡 1: 已读到ID卡 |
r2 | 整数型,1字节(UINT8型)的VID号 |
---|---|
VID号是ID卡的厂商定制号或版本号 |
r3 | 整数型,4字节(UINT32型)的ID号 |
---|---|
该ID号即是我们在ID白卡或钥匙扣上看到的号码的十六进制表达形式 |
应用示例:
xxxxxxxxxx
--设置ID卡读卡器模块占用TX0和RX0引脚
LIB_IdCardReaderConfig("UART0")
--查询是否读到ID卡
while(true)
do
id_found,vid,id = LIB_IdCardReaderGetContent()
if id_found == 1 then
--将读取到的vid和id号以十进制形式打印输出
print(string.format("VID:%03d ID:%010d\r\n", vid, id))
end
end
LIB_R200ReaderConfig(p1,p2,p3,p4,p5)
函数描述: 配置R200 UHF读卡器开始工作
p1 | 读卡器模块TX和RX引脚占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | 读卡器模块EN引脚占用的core引脚配置,该引脚的作用是当R200模块长期工作死机(只是可能)后自动复位引脚 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 工作区域(国家) |
---|---|
"DEFAULT":默认CHINA2 "CHINA2":920~925Mhz "US":902.25~927.75Mhz "EUROPE":865~868Mhz "CHINA1":840~845Mhz |
p4 | 工作信道,整数型 |
---|---|
如果工作区域(p3)是China2区 (920.125~924.875MHz)信道值范围(0~19),共20个信道,间隔0.25M | |
如果工作区域(p3)是US区(902.25~927.75MHz)信道值范围(0~51),共52个信道,间隔0.5M | |
如果工作区域(p3)是Europe区(865.1~867.9MHz)信道值范围(0~14),共15个信道,间隔0.2M | |
如果工作区域(p3)是China1区 (840.125~844.875MHz)信道值范围(0~19),共20个信道,间隔0.25M |
p5 | 发射功率,整数型 ,可以通过降低发射功率来缩小读卡器扫描标签的距离 |
---|---|
单位:0.01dBm, 最大值2000, 即20dBm 。建议最低值不低于500 |
应用示例:
xxxxxxxxxx
--设置R200读卡器模块占用TX0和RX0引脚,EN引脚占用D5引脚,并开始工作
--工作国家区域:China2区 (920.125~924.875MHz)
--工作信道:0通道,即工作频率为920.125MHz
--发射功率:设置为最大的20.00dBm
LIB_R200ReaderConfig("UART0","D5","CHINA2",0,2000)
r1,r2 = LIB_R200GetCard()
函数描述: 查询R200读卡器是否扫描到标签卡,当扫描到时返回扫描到的数量,以及每张标签卡的12字节标签卡号(EPC),EPC= eletronic product code
r1 | 整数型,指示扫描到多少个标签卡号 |
---|---|
0: 未扫描到 大于1: 扫描到r1张标签卡号 |
r2 | table型,包含扫描到的r1张标签卡的12字节标签卡号 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置R200读卡器模块占用TX0和RX0引脚,EN引脚占用D5引脚,并开始扫描工作
--工作国家区域:China2区 (920.125~924.875MHz)
--工作信道:0通道,即工作频率为920.125MHz
--发射功率:设置为最大的20.00dBm
LIB_R200ReaderConfig("UART0","D5","CHINA2",0,2000)
while(true)
do
Cnt, R = LIB_R200GetCard()
if Cnt >= 1 then --打印Cnt张扫描到的标签卡号
n = 0
for 1, Cnt do
print(string.format("%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
R[1+n],R[2+n],R[3+n],R[4+n],R[5+n],R[6+n],R[7+n],R[8+n],R[9+n],R[10+n],R[11+n],R[12+n]))
n = n + 12
end
end
end
r1,r2 = LIB_R200GetRssiCard()
函数描述: 查询R200读卡器是否扫描到标签卡,当扫描到时返回扫描到的数量,以及每张标签卡的12字节标签卡号(EPC)和1个字节的RSSI信号强度
r1 | 整数型,指示扫描到多少个标签卡号 |
---|---|
0: 未扫描到 大于1: 扫描到r1张标签卡号 |
r2 | table型,包含扫描到的r1张标签卡的12字节标签卡号以及每张卡的RSSI强度 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置R200读卡器模块占用TX0和RX0引脚,EN引脚占用D5引脚,并开始扫描工作
--工作国家区域:China2区 (920.125~924.875MHz)
--工作信道:0通道,即工作频率为920.125MHz
--发射功率:设置为最大的20.00dBm
LIB_R200ReaderConfig("UART0","D5","CHINA2",0,2000)
while(true)
do
Cnt, R = LIB_R200GetRssiCard()
if Cnt >= 1 then --打印Cnt张扫描到的标签卡号,以及每张卡的Rssi信号强度
n = 0
for 1, Cnt do
print(string.format("%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x -> Rssi= %d dB",
R[1+n],R[2+n],R[3+n],R[4+n],R[5+n],R[6+n],R[7+n],R[8+n],R[9+n],R[10+n],R[11+n],R[12+n],R[13+n]))
n = n + 13
end
end
end
r1 = LIB_R200SetCard(p1,p2,p3,p4)
函数描述: 设置放在读卡器范围内的某个标签的密码和标签卡号,并返回结果代码 注意: 该函数是阻塞型的,所以调用该函数会比较耗时
p1 | 32bit整数类型,如0x12345678 |
---|---|
标签卡的旧密码,注意只有旧密码(p1)正确时,p2(新密码)和p3(新标签卡号)才能成功设置 |
p2 | 32bit整数类型,如0x12345678 |
---|---|
将要设置的标签卡新密码 |
p3 | 整数类型,卡片信号稳定度 |
---|---|
该值越大就越能避免写卡时误写了周围其他的卡,但写卡的过程会耗费更长时间,一般建议设为6 |
p4 | table类型 |
---|---|
table内有12个元素,为12个字节新的标签卡号 |
r1 | 整数类型 |
---|---|
返回的错误代码,0表示成功,大于0表示失败,需要看具体的失败代码 | |
1 | 读卡器无法定位到一张稳定的标签,因为标签不在通信范围内或者周围有其他标签干扰 |
2 | 关闭读卡器的扫描工作状态时出现问题 |
3 | 写密码select超时 |
4 | 写密码select失败 |
5 | 写密码超时 |
6 | 写密码超次数 |
7 | 写密码时,标签不在现场,或标签号不对 |
8 | 二次写密码时,标签密码错误 |
9 | 二次写密码未知错误 |
10 | 二次写密码超时 |
11 | 二次写密码超次数 |
12 | 备用 |
13 | 二次写密码select超时 |
14 | 二次写密码select失败 |
15 | Lock操作前select超时 |
16 | Lock操作前select失败 |
17 | Lock时超时 |
18 | Lock时超次数 |
19 | Lock时,标签不在现场,或标签号不对 |
20 | Lock时,用的标签密码不对 |
21 | 写标签卡号前select超时 |
22 | 写标签卡号前select失败 |
23 | 写标签卡号超时 |
24 | 写标签卡号超次数 |
25 | 写标签卡号时,标签不在现场,或标签号不对 |
26 | 写标签卡时,密码不正确 |
应用示例:
xxxxxxxxxx
--设置R200读卡器模块占用TX0和RX0引脚,EN引脚占用D5引脚,并开始工作
--工作国家区域:China2区 (920.125~924.875MHz)
--工作信道:0通道,即工作频率为920.125MHz
--发射功率:设置为最大的20.00dBm
LIB_R200ReaderConfig("UART0","D5","CHINA2",0,2000)
while(true)
do
card = {1,2,3,4,5,6,7,8,9,10,11,12}
if something_happen then --比如按下按键时,开始向标签中写入新的密码和卡号
--注意:新的标签密码默认都是0x00000000
err = LIB_R200SetCard(0x00000000, 0x22223333, 6, card)
print(string.format("error code = %d", err))
end
end
LIB_EthTcpConfig(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11)
函数描述: 配置以太网模块(w5500 spi接口)的cs和rst占用的端口,并以TCP Client方式和Server(服务端)通信
p1 | W5500模块的cs占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p2 | W5500模块的rst占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | table类型 自身mac地址 |
---|---|
table内的元素必须为字节型,元素个数必须等于6个 |
p4 | table类型 自身ip地址 |
---|---|
table内的元素必须为字节型,元素个数必须等于4个 |
p5 | table类型 子网掩码 |
---|---|
table内的元素必须为字节型,元素个数必须等于4个 |
p6 | table类型 网关ip地址 |
---|---|
table内的元素必须为字节型,元素个数必须等于4个 |
p7 | table类型 dns地址 |
---|---|
table内的元素必须为字节型,元素个数必须等于4个 |
p8 | table类型 server端ip地址 |
---|---|
table内的元素必须为字节型,元素个数必须等于4个 |
p9 | 整数型,server端的端口号 |
---|---|
0-65535 |
p10 | 整数型,client端的端口号 |
---|---|
0-65535 |
p11 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于20秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内即没收到Server端的心跳包响应也没收到Server端下发的任意数据,此时Core会认为Server已断联,Core会重新尝试连接Server |
注意1:心跳包是由开发者在Lua代码中以不大于p11的心跳时间间隔向Server发送一包数据,并且Server应返回心跳包响应数据。心跳包及响应的具体内容和长度由您和Server端开发人员商量。 注意2:当p11的值为0的时候,Core默认关闭心跳机制(即Core不会因为Server端长时间没有数据下发而重启以太网模块),但真正开发产品时还是需要您和Server端开发人员商量好心跳包的策略,这样就能保证以太网模块常年不掉线。
应用示例:
xxxxxxxxxx
mac = {0x00, 0x08, 0xdc,0x11, 0x11, 0x11} --自身mac地址
sip = {192, 168, 1, 123} --自身ip地址
subm = {255,255,255,0} --子网掩码
gw = {192, 168, 1, 1} --路由器地址
dns = {8,8,8,8} --dns地址
tip = {192, 168, 1, 123} --目标(server端)ip地址
s_port = 1234 --目标(server端)端口号
c_port = 54321 --本机(client端)端口号
heart_beat = 0 --心跳时间:0秒,即禁止心跳机制
--设置W5500以太网模块占用MOSI,MISO,CLK,D4,D5引脚,TCP Client模式
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_EthTcpConfig函数的p11参数详细介绍
LIB_EthTcpConfig("D4","D5",mac,sip,subm,gw,dns,tip,s_port,c_port,heart_beat)
r1,r2 = LIB_EthTcpRecv()
函数描述: 查询是否收到TCP server发来数据,如果收到数据则返回接收到的数据。注意server端下发的每个数据包不要大于256字节,且数据包时间间隔尽量不要小于100ms
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
mac = {0x00, 0x08, 0xdc,0x11, 0x11, 0x11} --自身mac地址
sip = {192, 168, 1, 123} --自身ip地址
subm = {255,255,255,0} --子网掩码
gw = {192, 168, 1, 1} --路由器地址
dns = {8,8,8,8} --dns地址
tip = {192, 168, 1, 123} --目标(server端)ip地址
s_port = 1234 --目标(server端)端口号
c_port = 54321 --本机(client端)端口号
heart_beat = 0 --心跳时间:0秒,即禁止心跳机制
--设置W5500以太网模块占用MOSI,MISO,CLK,D4,D5引脚,TCP Client模式
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_EthTcpConfig函数的p11参数详细介绍
LIB_EthTcpConfig("D4","D5",mac,sip,subm,gw,dns,tip,s_port,c_port,heart_beat)
while(true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,recv_tab = LIB_EthTcpRecv()
if recv_flag == 1 then
print(string.format("tcp receive %d bytes", #recv_tab))
end
end
LIB_EthTcpSend(p1)
函数描述: 发送p1数组中的数据,每包发送的数据量不要超过256字节,发送间隔时间也尽量大于100ms 注意:只有当TCP连接成功后,调用该函数才会发送,否则该函数会自动忽略对其的调用
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
应用示例:
xxxxxxxxxx
mac = {0x00, 0x08, 0xdc,0x11, 0x11, 0x11} --自身mac地址
sip = {192, 168, 1, 123} --自身ip地址
subm = {255,255,255,0} --子网掩码
gw = {192, 168, 1, 1} --路由器地址
dns = {8,8,8,8} --dns地址
tip = {192, 168, 1, 123} --目标(server端)ip地址
s_port = 1234 --目标(server端)端口号
c_port = 54321 --本机(client端)端口号
heart_beat = 30 --心跳时间:0秒,即禁止心跳机制
--设置W5500以太网模块占用MOSI,MISO,CLK,D4,D5引脚,TCP Client模式
--心跳包间隔时间30秒。关于心跳机制请在ApiDoc文档中查阅关于LIB_EthTcpConfig函数的p11参数详细介绍
LIB_EthTcpConfig("D4","D5",mac,sip,subm,gw,dns,tip,s_port,c_port,heart_beat)
table = {1,2,3,4,5}
while(true)
do
--每隔5秒发送一次心跳包数据
LIB_EthTcpSend(table)
LIB_DelayMs(5000)
end
LIB_EthUdpConfig(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11)
函数描述: 配置以太网模块(w5500 spi接口)的cs和rst占用的端口,UDP模式
p1 | W5500模块的cs占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p2 | W5500模块的rst占用的core引脚配置 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | table类型 自身mac地址 |
---|---|
table内的元素必须为字节型,元素个数必须等于6个 |
p4 | table类型 自身ip地址 |
---|---|
table内的元素必须为字节型,元素个数必须等于4个 |
p5 | table类型 子网掩码 |
---|---|
table内的元素必须为字节型,元素个数必须等于4个 |
p6 | table类型 网关ip地址 |
---|---|
table内的元素必须为字节型,元素个数必须等于4个 |
p7 | table类型 dns地址 |
---|---|
table内的元素必须为字节型,元素个数必须等于4个 |
p8 | table类型 目标端ip地址 |
---|---|
table内的元素必须为字节型,元素个数必须等于4个 |
p9 | 整数型,目标端的端口号 |
---|---|
0-65535 |
p10 | 整数型,本地端的端口号 |
---|---|
0-65535 |
p11 | 整数型,心跳包间隔时间 ,单位:秒,建议该值不要小于20秒 |
---|---|
当该值大于0时,如果Core在该间隔时间内即没收到对端的心跳包响应也没收到对端下发的任意数据,此时Core会认为对端已断联,Core会重新启动UDP |
注意1:心跳包是由开发者在Lua代码中以不大于p11的心跳时间间隔向UDP对端发送一包数据,并且对端应返回心跳包响应数据。心跳包及响应的具体内容和长度由您和对端开发人员商量。 注意2:当p11的值为0的时候,Core默认关闭心跳机制(即Core不会因为对端长时间没有数据下发而重启UDP),但真正开发产品时还是需要您和对端开发人员商量好心跳包的策略,这样就能保证以太网模块常年不掉线。
应用示例:
xxxxxxxxxx
mac = {0x00, 0x08, 0xdc,0x11, 0x11, 0x11} --自身mac地址
my_ip = {192, 168, 1, 123} --自身ip地址
subm = {255,255,255,0} --子网掩码
gw = {192, 168, 1, 1} --路由器地址
dns = {8,8,8,8} --dns地址
trgt_ip = {192, 168, 1, 123} --目标端ip地址
trgt_port = 5678 --目标端端口号
my_port = 54321 --本机端口号
heart_beat = 0 --心跳时间:0秒,即禁止心跳机制
--设置W5500以太网模块占用MOSI,MISO,CLK,D4,D5引脚,UDP模式
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_EthUdpConfig函数的p11参数详细介绍
LIB_EthUdpConfig("D4","D5",mac,my_ip,subm,gw,dns,trgt_ip,trgt_port,my_port,heart_beat)
r1,r2,r3,r4 = LIB_EthUdpRecv()
函数描述: 查询是否收到Udp对端发来数据,如果收到数据则返回接收到的ip地址、端口号以及数据。注意对端下发的每个数据包不要大于256字节,且数据包时间间隔尽量不要小于100ms
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,4个元素,UDP对端的IP地址 |
---|---|
无 |
r3 | 整数型,UDP对端的端口号 |
---|---|
无 |
r4 | table型,对端发来的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
mac = {0x00, 0x08, 0xdc,0x11, 0x11, 0x11} --自身mac地址
my_ip = {192, 168, 1, 123} --自身ip地址
subm = {255,255,255,0} --子网掩码
gw = {192, 168, 1, 1} --路由器地址
dns = {8,8,8,8} --dns地址
trgt_ip = {192, 168, 1, 123} --目标端ip地址
trgt_port = 5678 --目标端端口号
my_port = 54321 --本机端口号
heart_beat = 0 --心跳时间:0秒,即禁止心跳机制
--设置W5500以太网模块占用MOSI,MISO,CLK,D4,D5引脚,UDP模式
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_EthUdpConfig函数的p11参数详细介绍
LIB_EthUdpConfig("D4","D5",mac,my_ip,subm,gw,dns,trgt_ip,trgt_port,my_port,heart_beat)
while(true)
do
--查询是否收到数据,如果收到就print输出收到的字节数
recv_flag,ip,port,data = LIB_EthUdpRecv()
if recv_flag == 1 then
print(string.format("recv from %d.%d.%d.%d :%d", ip[1],ip[2],ip[3],ip[4],port))
print(string.format("received %d bytes", #data))
end
end
LIB_EthUdpSend(p1)
函数描述: 发送p1数组中的数据,每包发送的数据量不要超过256字节,发送间隔时间也尽量大于100ms
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
应用示例:
xxxxxxxxxx
mac = {0x00, 0x08, 0xdc,0x11, 0x11, 0x11} --自身mac地址
my_ip = {192, 168, 1, 123} --自身ip地址
subm = {255,255,255,0} --子网掩码
gw = {192, 168, 1, 1} --路由器地址
dns = {8,8,8,8} --dns地址
trgt_ip = {192, 168, 1, 123} --目标端ip地址
trgt_port = 5678 --目标端端口号
my_port = 54321 --本机端口号
heart_beat = 0 --心跳时间:0秒,即禁止心跳机制
--设置W5500以太网模块占用MOSI,MISO,CLK,D4,D5引脚,UDP模式
--心跳包间隔时间0秒(不使用心跳机制)。如果需要使用请在ApiDoc文档中查阅关于LIB_EthUdpConfig函数的p11参数详细介绍
LIB_EthUdpConfig("D4","D5",mac,my_ip,subm,gw,dns,trgt_ip,trgt_port,my_port,heart_beat)
table = {1,2,3,4,5}
while(true)
do
--每隔5秒发送一次心跳包数据
LIB_EthUdpSend(table)
LIB_DelayMs(5000)
end
r1 = LIB_MbRtuMasterSendTrans(p1~p4)
函数描述: 根据p1不同的modbus功能码以及p1之后的参数,生成符合modbus协议格式的hex数据流,并以table数组形式返回
p1 | 字符串类型 |
---|---|
p1可为如下八个Modbus功能码之一 "01","02","03","04","05","06","0F","10" |
p2 | 整数型 |
---|---|
需要通信的从机地址,1~255 |
p3和p4 | 数据类型不固定 |
---|---|
当p1="01"时,表示读线圈。p3=起始地址(0-0xFFFF),p4=个数(1-256) | |
当p1="02"时,表示读离散输入量。p3=起始地址(0-0xFFFF),p4=个数(1-256) | |
当p1="03"时,表示读保持寄存器。p3=起始地址(0-0xFFFF),p4=个数(1-100) | |
当p1="04"时,表示读输入寄存器。p3=起始地址(0-0xFFFF),p4=个数(1-100) | |
当p1="05"时,表示写单个线圈。p3=起始地址(0-0xFFFF),p4=线圈值(0或1) | |
当p1="06"时,表示写单个寄存器。p3=起始地址(0-0xFFFF),p4=16位寄存器值 | |
当p1="0F"时,表示写多个线圈。p3=起始地址(0-0xFFFF),p4=数组,数组中元素的个数等于要写入的线圈个数,0和1代表线圈值 ,注意:元素个数不能超过256个 | |
当p1="10"时,表示写多个寄存器。p3=起始地址(0-0xFFFF),p4=数组,数组中元素的个数等于要写入的寄存器个数,值即是要写入的寄存器的值 ,注意:元素个数不能超过123个 |
r1 | 数组类型 |
---|---|
返回的数组即为符合modbus协议格式的hex数据流数组 |
应用示例:
xxxxxxxxxx
--读线圈(设备地址=0x03,起始地址=0x0000,个数=3)
LIB_Uart0Send(LIB_MbRtuMasterSendTrans("01", 0x03, 0x0000, 3))
--读离散输入量(设备地址=0x03,起始地址=0x0000,个数=2)
LIB_Uart0Send(LIB_MbRtuMasterSendTrans("02", 0x03, 0x0000, 2))
--读保持寄存器(设备地址=0x03,起始地址=0x0000,个数=1)
LIB_Uart0Send(LIB_MbRtuMasterSendTrans("03", 0x03, 0x0000, 1))
--读输入寄存器(设备地址=0x03,起始地址=0x0000,个数=5)
LIB_Uart0Send(LIB_MbRtuMasterSendTrans("04", 0x03, 0x0000, 5))
--写单个线圈(设备地址=0x03,起始地址=0x0000,线圈值=0)
LIB_Uart0Send(LIB_MbRtuMasterSendTrans("05", 0x03, 0x0000, 0))
--写单个寄存器(设备地址=0x03,起始地址=0x0000,寄存器值=0x1234)
LIB_Uart0Send(LIB_MbRtuMasterSendTrans("06", 0x03, 0x0000, 0x1234))
--写多个线圈(设备地址=0x03,起始地址=0x0000)
tab = {1,0,1,1}--写入的四个线圈值分别为1,0,1,1
LIB_Uart0Send(LIB_MbRtuMasterSendTrans("0F", 0x03, 0x0000, tab))
--写多个寄存器(设备地址=0x03,起始地址=0x0000)
tab = {0x2222, 0x3333}--写入的两个寄存器值分别为0x2222,0x3333
LIB_Uart0Send(LIB_MbRtuMasterSendTrans("10", 0x03, 0x0000, tab))
r1,r2 = LIB_MbRtuMasterRecvTrans(p1,p2)
函数描述: 根据p1功能码的类型,将从机发来的应答结果hex数据流数组p2解析出结果
p1 | 字符串类型 |
---|---|
p1可为如下八个Modbus功能码之一 "01","02","03","04","05","06","0F","10" |
p2 | table型 |
---|---|
从机发来的应答数据(需要被解析的数据流数组) |
r1 | 整数型,表示结果 |
---|---|
r1大于0表示应答正确,小于等于零表示有问题。例如-1表示应答报文格式有问题,其他值为Modbus异常 |
r2 | table型 |
---|---|
r2仅在读取类型的功能码时才会有,根据读取的类容不同,返回的table包含的数据意义也不同,比如"01"时包含的是各个线圈的值,"03"时包含的是各个寄存器的值 |
应用示例:
xxxxxxxxxx
--例如我们通过recv_flag,recv_tab=LIB_Uart0Recv()获取到recv_tab数组中包含的从机发来的应答数据流
--解析从机发来的读线圈应答
if recv_flag == 1 then
result,content=LIB_MbRtuMasterRecvTrans("01",recv_tab)
if result > 0 then --打印content数组中的所有结果
for i, v in ipairs(content) do
print(i, v)
end
else
print("fail,re=%d",result)
end
end
--解析从机发来的读离散输入量应答
if recv_flag == 1 then
result,content=LIB_MbRtuMasterRecvTrans("02",recv_tab)
if result > 0 then --打印content数组中的所有结果
for i, v in ipairs(content) do
print(i, v)
end
else
print("fail,re=%d",result)
end
end
--解析从机发来的读保持寄存器应答
if recv_flag == 1 then
result,content=LIB_MbRtuMasterRecvTrans("03",recv_tab)
if result > 0 then --打印content数组中的所有结果
for i, v in ipairs(content) do
print(i, v)
end
else
print("fail,re=%d",result)
end
end
--解析从机发来的读输入寄存器应答
if recv_flag == 1 then
result,content=LIB_MbRtuMasterRecvTrans("04",recv_tab)
if result > 0 then --打印content数组中的所有结果
for i, v in ipairs(content) do
print(i, v)
end
else
print("fail,re=%d",result)
end
end
--解析从机发来的写单个线圈应答
if recv_flag == 1 then
result=LIB_MbRtuMasterRecvTrans("05",recv_tab)
if result > 0 then
print("write single coil ok")
else
print("fail")
end
end
--解析从机发来的写单个寄存器应答
if recv_flag == 1 then
result=LIB_MbRtuMasterRecvTrans("06",recv_tab)
if result > 0 then
print("write single register ok")
else
print("fail")
end
end
--解析从机发来的写多个线圈应答
if recv_flag == 1 then
result=LIB_MbRtuMasterRecvTrans("0F",recv_tab)
if result > 0 then
print("write multiple coil ok")
else
print("fail")
end
end
--解析从机发来的写多个寄存器应答
if recv_flag == 1 then
result=LIB_MbRtuMasterRecvTrans("10",recv_tab)
if result > 0 then
print("write multiple register ok")
else
print("fail")
end
end
LIB_Sht3xConfig(p1,p2,p3)
函数描述: 配置sht3x温湿度传感器以默认参数周期性工作(mps="10",repeatability="MEDIUM")
p1 | 传感器占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
p2 | mps参数,传感器每秒转换次数,mps的详细解析请参看sht3x的官方资料 |
---|---|
"0.5","1","2","4","10" 以上数据可以作为您在代码中读传感器的周期参考 |
p3 | repeatability参数,传感器精度等级,repeatability的详细解析请参看sht3x的官方资料 |
---|---|
"HIGH","MEDIUM","LOW" |
应用示例:
xxxxxxxxxx
--设置sht3x传感器占用SCL0和SDA0引脚,并启动传感器以每秒出2个数据的频率工作,repeatability="HIGH"时精度最高
LIB_Sht3xConfig("IIC0","2","HIGH")
r1,r2,r3 = LIB_Sht3xGetResult()
函数描述: 查询SHT30/SHT31温湿度传感器是否出数
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | number浮点型,温度 |
---|---|
无 |
r3 | number浮点型,湿度百分比 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置sht3x传感器占用SCL0和SDA0引脚,并启动传感器以每秒出10个数据的频率工作,repeatability="HIGH"时精度最高
LIB_Sht3xConfig("IIC0","10","HIGH")
--查询传感器是否出数
while(GC(1) == true)
do
LIB_DelayMs(500)
sht3x_flag,sht3x_temp,sht3x_humi = LIB_Sht3xGetResult()
if sht3x_flag == 1 then
print(string.format("temprature: %f\r\nhumidity: %f", sht3x_temp, sht3x_humi))
end
end
LIB_BMP280Config(p1)
函数描述: 配置BMP280气压计传感器开始工作,以每秒输出26.32组数据的频率工作。
p1 | 传感器占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
应用示例:
xxxxxxxxxx
--设置BMP280气压计传感器占用SCL0和SDA0引脚,并启动传感器以每秒输出26.32组数据的频率工作
LIB_BMP280Config("IIC0")
r1,r2,r3 = LIB_BMP280GetResult()
函数描述: 查询BMP280温度/气压传感器是否出数
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | number浮点型,温度,单位:度 |
---|---|
无 |
r3 | number浮点型,气压值,单位:帕(Pa) |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置BMP280气压计传感器占用SCL0和SDA0引脚,并启动传感器以每秒输出26.32组数据的频率工作
LIB_BMP280Config("IIC0")
--查询传感器是否出数
while(GC(1) == true)
do
LIB_DelayMs(40)
bmp280_flag,bmp280_temp,bmp280_pressure = LIB_BMP280GetResult()
if bmp280_flag == 1 then
print(string.format("temprature: %f\r\npressure: %f", bmp280_temp, bmp280_pressure))
end
end
LIB_BH1750Config(p1)
函数描述: 配置BH1750光照强度传感器开始工作,以每秒输出5组数据的频率工作。
p1 | 传感器占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
应用示例:
xxxxxxxxxx
--设置BH1750光照强度传感器占用SCL0和SDA0引脚,并启动传感器以每秒输出5组数据的频率工作
LIB_BH1750Config("IIC0")
r1,r2 = LIB_BH1750GetResult()
函数描述: 查询BH1750光照强度传感器是否出数
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | number浮点型,光照强度,单位:勒克斯(lx) |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置BH1750光照强度传感器占用SCL0和SDA0引脚,并启动传感器以每秒输出5组数据的频率工作
LIB_BH1750Config("IIC0")
--查询传感器是否出数
while(GC(1) == true)
do
LIB_DelayMs(200)
bh1750_flag,bh1750_illuminance = LIB_BH1750GetResult()
if bh1750_flag == 1 then
print(string.format("illuminance: %f\r\n", bh1750_illuminance))
end
end
LIB_IfrTempConfig(p1)
函数描述: 配置红外测温传感器开始工作,以每秒输出5组数据的频率工作。
p1 | 传感器占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
应用示例:
xxxxxxxxxx
--设置红外测温传感器占用SCL0和SDA0引脚,并启动传感器以每秒输出5组数据的频率工作
LIB_IfrTempConfig("IIC0")
r1~r5 = LIB_IfrTempGetResult()
函数描述: 查询红外测温传感器是否出数
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | number浮点型,环境温度 |
---|---|
无 |
r3 | number浮点型,输出电压,单位uV |
---|---|
无 |
r4 | number浮点型,物体表面温度 |
---|---|
无 |
r5 | number浮点型,人体温度 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设红外测温传感器占用SCL0和SDA0引脚,并启动传感器以每秒输出5组数据的频率工作
LIB_IfrTempConfig("IIC0")
--查询传感器是否出数
while(GC(1) == true)
do
LIB_DelayMs(200)
flag,AmbTemp,Vol,ObjTemp,BodyTemp = LIB_IfrTempGetResult()
if flag == 1 then
print(string.format("Amb:%f,Vol:%f,Obj:%f,Body:%f", AmbTemp,Vol,ObjTemp,BodyTemp))
end
end
LIB_SM9541Config(p1,P2,P3)
函数描述: 配置SM9541压力传感器开始工作,并启动传感器,每300毫秒输出一个数
p1 | 传感器占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
p2 | 浮点数,SM9541传感器的MinPressure 单位:cmH2O |
---|---|
该值请参考SM9541 DataSheet 中对应型号的Minimum pressure值 |
p3 | 浮点数,SM9541传感器的MaxPressure 单位:cmH2O |
---|---|
该值请参考SM9541 DataSheet 中对应型号的Maximum pressure值 |
应用示例:
xxxxxxxxxx
--设置SM9541压力传感器占用SCL0和SDA0引脚,并启动传感器,每300毫秒输出一个数
--本项目所用SM9541型号为SM9541-100C-D-C-3-S(范围: -100 ~ 100 cmH2O)
LIB_SM9541Config("IIC0", -100.0, 100.0)
r1,r2,r3 = LIB_SM9541GetResult()
函数描述: 查询SM9541压力传感器是否出数,大概每300ms出一个数,该数是由50个间隔6ms的点求平均值而得
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | number浮点型,压力,单位:cmH2O, 1cmH2O=0.098kPa |
---|---|
无 |
r3 | number浮点型,温度,单位:摄氏度 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--设置SM9541压力传感器占用SCL0和SDA0引脚,并启动传感器,每300毫秒输出一个数
--本项目所用SM9541型号为SM9541-100C-D-C-3-S(范围: -100 ~ 100 cmH2O)
LIB_SM9541Config("IIC0", -100.0, 100.0)
while(GC(1) == true)
do
LIB_DelayMs(100)
--查询传感器是否出数
flag,pressure,temperature = LIB_SM9541GetResult()
if flag == 1 then
print(string.format("pressure:%.4fcmH2O, temperature:%.1f\r\n", pressure,temperature))
end
end
LIB_MPU6050Config(p1)
函数描述: 配置MPU6050六轴传感器开始工作,以每秒输出10组欧拉角数据的频率工作。 注意: 模块上电自校正,需保持3秒以上静止状态,建议不要用手拿着模块。
p1 | 传感器占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
应用示例:
xxxxxxxxxx
--设置MPU6050六轴传感器占用TX0和RX0引脚,并启动传感器以每秒输出10组欧拉角数据的频率工作
LIB_MPU6050Config("UART0")
r1,r2,r3,r4 = LIB_MPU6050GetEulerAngle()
函数描述: 查询是否收MPU6050传感器模块输出的欧拉角(姿态角)
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | number型,Pitch 俯仰角 |
---|---|
单位:度 ,小数点后两位有效 |
r3 | number型,Yaw 航偏角 |
---|---|
单位:度 ,小数点后两位有效 |
r4 | number型,Roll 横滚角 |
---|---|
单位:度 ,小数点后两位有效 |
应用示例:
xxxxxxxxxx
--设置MPU6050六轴传感器占用TX0和RX0引脚,并启动传感器以每秒输出10组欧拉角数据的频率工作
LIB_MPU6050Config("UART0")
--查询是否收到欧拉角数据,如果收到就print输出
while(true)
do
recv_flag,pitch,yaw,roll = LIB_MPU6050GetEulerAngle()
if recv_flag == 1 then
print(string.format("pitch:%3.2f yaw:%3.2f roll:%3.2f\r\n", pitch,yaw,roll))
end
end
LIB_MPU6050Cali(p1)
函数描述: 让MPU6050六轴传感器开始校准
p1 | 校准模式 |
---|---|
"PITCH_ROLL": 开始俯仰横滚角校准,需要保持水平时候再开启 "YAW": 开启航偏角校准,航向任意角度清零 |
应用示例:
xxxxxxxxxx
--开启俯仰横滚角校准
LIB_MPU6050Cali("PITCH_ROLL")
LIB_TCS3472Config(p1,p2,p3)
函数描述: 配置TCS3472颜色传感器开始工作
p1 | 传感器占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
p2 | TCS3472传感器的Integration Time(可以理解为每次测量的采样时间),该时间越长转换的结果准确性越高 |
---|---|
"2.4ms","24ms","50ms","101ms","154ms","700ms" |
p3 | TCS3472传感器的Gain(可以理解传感器采样前端的放大器增益),该增益越大灵敏性越高(越适合弱色) |
---|---|
"GAIN_1X","GAIN_4X","GAIN_16X","GAIN_60X" |
应用示例:
xxxxxxxxxx
--配置TCS3472颜色传感器开始工作,采样时间为最长的700ms(准确度最高),采样放大器增益为1(无增益)
LIB_TCS3472Config("IIC0","700ms","GAIN_1X")
r1,r2,r3,r4,r5,r6 = LIB_TCS3472GetResult()
函数描述: 查询TCS3472颜色传感器是否出数
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | number浮点型,red值 |
---|---|
0.0-255.0 |
r3 | number浮点型,green值 |
---|---|
0.0-255.0 |
r4 | number浮点型,blue值 |
---|---|
0.0-255.0 |
r5 | 整数型,cct(相对色温) |
---|---|
0-65535 单位:K(开尔文), |
r6 | 整数型,光照强度 |
---|---|
0-65535 单位:lux(勒克斯) |
应用示例:
xxxxxxxxxx
--配置TCS3472颜色传感器开始工作,采样时间为最长的700ms(准确度最高),采样放大器增益为1(无增益)
LIB_TCS3472Config("IIC0","700ms","GAIN_1X")
--查询传感器是否出数
while(true)
do
LIB_DelayMs(10)
flag, r ,g, b, cct, lux = LIB_TCS3472GetResult()
if flag == 1 then
--打印r g b三色值以及色温(cct)和光照强度(lux)
print(string.format("r:%f, g:%f, b:%f, cct:%d, lux:%d", r, g, b, cct, lux))
end
end
LIB_ApdsConfig(p1,p2)
函数描述: 配置APDS9960传感器开始工作
p1 | 传感器占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
p2 | 传感器工作模式 |
---|---|
"PorximityAndLux": 靠近感应以及环境光强度测量 "Gesture": 手势检测 |
注意:"Gesture"模式时RC522 RFID读卡模块不能同时共存
应用示例:
xxxxxxxxxx
--配置APDS9960近距离感应&光照度传感器开始工作,占用core的IIC0引脚
LIB_ApdsConfig("IIC0", "PorximityAndLux")
r1,r2,r3 = LIB_ApdsGetPrxmAndLux()
函数描述: 查询APDS9960传感器是否出数
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | 整数型,靠近感应数据 |
---|---|
0-255 该值越大表示距离越近 |
r3 | 整数型,环境光强度 |
---|---|
0-65535 单位:lux(勒克斯) |
应用示例:
xxxxxxxxxx
--配置APDS9960近距离感应&光照度传感器开始工作,占用core的IIC0引脚
LIB_ApdsConfig("IIC0", "PorximityAndLux")
--查询传感器是否出数
while(true)
do
LIB_DelayMs(10)
flag, prxm, lux = LIB_ApdsGetPrxmAndLux()
if flag == 1 then
--打印靠近感应值和环境光强度(lux)
print(string.format("prmx:%d, lux:%d", prxm, lux))
end
end
r1,r2 = LIB_ApdsGetGesture()
函数描述: 查询APDS9960传感器是否检测到手势感应
r1 | 整数型,指示是否感应到手势动作 |
---|---|
0: 未感应到 1: 已感应到 |
r2 | 整数型,手势动作代号 |
---|---|
1-4 1:up 2:down 3:left 4:right |
应用示例:
xxxxxxxxxx
gest_str = {"up", "down", "left","right"}
--配置APDS9960手势感应传感器开始工作,占用core的IIC0引脚
LIB_ApdsConfig("IIC0", "Gesture")
--查询传感器是否感应到手势
while(true)
do
LIB_DelayMs(10)
flag, gest = LIB_ApdsGetGesture()
if flag == 1 then
--打印手势动作
print(string.format("Gesture:%s\r\n", gest_str[gest]))
end
end
LIB_HX711Config(p1,p2,p3)
函数描述: 配置HX711模块工作模式,以及占用的IO口 注意:Core只使用HX711的A通道,B通道不需要使用。
p1 | 工作模式 |
---|---|
"A_64" A通道64倍增益,对应的桥式电路差分输入电压范围为:-40mv ~ 40mv "A_128" A通道128倍增益,对应的桥式电路差分输入电压范围为:-20mv ~ 20mv |
p2 | 选择HX711时钟引脚SCK所占用的D端口号 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
p3 | 选择HX711数据引脚DT(DOUT)所占用的D端口号 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
应用示例:
xxxxxxxxxx
--配置HX711模块A通道增益为64,SCK引脚占用D6,DOUT引脚占用D7
LIB_HX711Config("A_64","D6","D7")
r1,r2 = LIB_HX711GetValue()
函数描述: 查询HX711是否出结果,查询频率请根据HX711 RATE引脚来调整 RATE=0时HX711一秒钟能够输出10个AD采样结果,RATE=1时HX711一秒钟能够输出70个AD采样结果
r1 | 整数型,指示HX711是否出结果 |
---|---|
0: 否 1: 是 |
r2 | 整数型,HX711的24位差分输入电压AD转换结果,结果带正负号 |
---|---|
单位:无,满量程为您给HX711提供的模拟电源电压 |
应用示例:
xxxxxxxxxx
--配置HX711模块A通道增益为64,SCK引脚占用D6,DOUT引脚占用D7
LIB_HX711Config("A_64","D6","D7")
--每0.1秒查询一次HX711是否出结果
while(true)
do
LIB_DelayMs(100)
flag, ad_value = LIB_HX711GetValue()
if flag == 1 then
--打印手势动作
print(string.format("ad_value:%d\r\n", ad_value))
end
end
LIB_QMC5883Config(p1,P2)
函数描述: 配置三轴磁场强度传感器开始工作,默认每秒输出100组数据
p1 | 传感器占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
p2 | 三轴磁场强度的测量方位 |
---|---|
"RNG_2G": -2G ~ +2G "RNG_8G": -8G ~ +8G |
应用示例:
xxxxxxxxxx
--设置QMC5883三轴磁场强度传感器占用SCL0和SDA0引脚,并设置三轴磁场的测量范围为-2G ~ +2G
LIB_QMC5883Config("IIC0", "RNG_2G")
r1,r2,r3,r4,r5 = LIB_QMC5883GetResult()
函数描述: 查询QMC5883三轴磁场强度传感器是否出数,并返回传感器的测量结果 注意:该函数的调用频率不能超过每秒100次,即调用时间间隔需大于等于10毫秒
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | 整数型,X轴磁场强度 |
---|---|
该值范围为-32768 ~ 32767,对应着您在LIB_QMC5883Config设置的-2G ~ 2G或-8G ~ 8G |
r3 | 整数型,Y轴磁场强度 |
---|---|
该值范围为-32768 ~ 32767,对应着您在LIB_QMC5883Config设置的-2G ~ 2G或-8G ~ 8G |
r4 | 整数型,Z轴磁场强度 |
---|---|
该值范围为-32768 ~ 32767,对应着您在LIB_QMC5883Config设置的-2G ~ 2G或-8G ~ 8G |
r5 | 浮点小型(NUMBER),方位角(azimuth),单位:度 |
---|---|
水平面上与正北方向的夹角 |
应用示例:
xxxxxxxxxx
--设置QMC5883三轴磁场强度传感器占用SCL0和SDA0引脚,并设置三轴磁场的测量范围为-2G ~ +2G
LIB_QMC5883Config("IIC0", "RNG_2G")
--每隔0.2秒查询传感器是否出数
while(true)
do
LIB_DelayMs(200)
flag, X, Y, Z, azimuth = LIB_QMC5883GetResult()
if flag == 1 then
print(string.format("X:%d,Y:%d,Z:%d,Azimuth:%f\r\n", X, Y, Z, azimuth))
end
end
LIB_ADXL345Config(p1)
函数描述: 配置ADXL345传感器开始工作,三轴加速度测量结果输出频率默认100Hz,测量范围默认+-16g
p1 | 传感器占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
应用示例:
xxxxxxxxxx
--配置ADXL345开始工作,占用IIc0接口,三轴加速度测量结果输出频率默认100Hz,测量范围默认+-16g
LIB_ADXL345Config("IIC0")
LIB_ADXL345AutoSleepConfig(p1,p2,p3,p4)
函数描述: 设置ADXL345传感器自动休眠及唤醒相关参数 注意: 该函数必须在LIB_ADXL345Config()之前调用,否则无效
p1 | 字符串类型,选择某个轴作为判断进入休眠和结束休眠的参考轴 |
---|---|
"X":选择X轴作为参考 "Y":选择Y轴作为参考 "Z":选择Z轴作为参考 |
p2 | 浮点数类型,当p1轴的加速度小于p2,并持续p3秒后,ADXL345会进入休眠状态 |
---|---|
单位: mg(1000mg = 1g) 范围为:62.5-15999.0mg,建议p2的大小为62.5的倍数 |
p3 | 整数类型,当p1轴的加速度小于p2,并持续p3秒后,ADXL345会进入休眠状态 |
---|---|
单位: 秒, 范围为:1-255秒 |
p4 | 浮点数类型,当p1轴的加速度大于p4时,ADXL345会自动唤醒,并在INT1引脚输出唤醒信号 |
---|---|
单位: mg(1000mg = 1g) 范围为:62.5-15999.0mg,建议p4的大小为62.5的倍数 |
p5 | 字符串类型 设置当ADXL345自动唤醒时,ADXL345的INT1引脚输出的唤醒信号 |
---|---|
"HIGH":高电平脉冲 “LOW”:低电平脉冲 |
应用示例:
xxxxxxxxxx
--配置ADXL345的休眠及唤醒参数:当X轴加速度低于1000.0mg并持续10秒后进入休眠,当X轴加速度
--大于2000.0mg时唤醒且INT1引脚输出高电平脉冲
LIB_ADXL345AutoSleepConfig("X", 1000.0, 10, 2000.0, "HIGH")
--配置ADXL345开始工作,占用IIc0接口,三轴加速度测量结果输出频率默认100Hz,测量范围默认+-16g
LIB_ADXL345Config("IIC0")
r1,r2,r3,r4 = LIB_ADXL345GetAccXYZ()
函数描述: 查询ADXL345三轴加速度传感器是否出数
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | 整数型,X轴加速度 |
---|---|
单位: mg (1000mg = 1g) |
r3 | 整数型,Y轴加速度 |
---|---|
单位: mg (1000mg = 1g) |
r4 | 整数型,Z轴加速度 |
---|---|
单位: mg (1000mg = 1g) |
应用示例:
xxxxxxxxxx
--配置ADXL345开始工作,占用IIc0接口,三轴加速度测量结果输出频率默认100Hz,测量范围默认+-16g
LIB_ADXL345Config("IIC0")
--查询传感器是否出数
while(true)
do
LIB_DelayMs(10)
flag, acc_x, acc_y, acc_z = LIB_ADXL345GetAccXYZ()
if flag == 1 then
--打印三轴加速度
print(string.format("acc_x:%d,acc_x:%d,acc_x:%d",acc_x,acc_y,acc_z))
end
end
LIB_VL53L0XConfig(p1,p2)
函数描述: 配置VL53L0X传感器开始工作
p1 | 传感器占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
p2 | 传感器工作模式 |
---|---|
"Default":默认模式 "HighAccuracy":高精度模式 "LongRange":长距离模式 "HighSpeed":高速模式 |
各种工作模式性能介绍 | 每次测量耗时(毫秒) | 测距范围(米) | 精度 | 应用场景 |
---|---|---|---|---|
"Default" | 30 | 1.2 | 3% ~ 12% | 通用场景 |
"HighAccuracy" | 200 | 1.2 | 3%以内 | 精确测量场景 |
"LongRange" | 33 | 2 | 3% ~ 12% | 远距离,但仅适合暗光场景 |
"HighSpeed" | 20 | 1.2 | 5%左右 | 要求测量速度快,但精度不追求太高的场景 |
应用示例:
xxxxxxxxxx
--配置VL53L0X激光传感器开始工作,占用core的IIC0引脚,以高精度模式工作
--高精度模式下,精度在3%以内,测量范围在1.2米以内
LIB_VL53L0XConfig("IIC0", "HighAccuracy")
r1,r2 = LIB_VL53L0XGetDistance()
函数描述: 查询VL53L0X传感器是否测量出距离
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | 整数型,传感器测量出来的距离 |
---|---|
单位:毫米 |
应用示例:
xxxxxxxxxx
--配置VL53L0X激光传感器开始工作,占用core的IIC0引脚,以高精度模式工作
--高精度模式下,精度在3%以内,测量范围在1.2米以内
LIB_VL53L0XConfig("IIC0", "HighAccuracy")
--每隔200ms查询一次传感器是否出数
while(true)
do
LIB_DelayMs(200)
flag, distance = LIB_VL53L0XGetDistance()
if flag == 1 then
--打印测量距离(mm)
print(string.format("distance:%d", distance))
end
end
LIB_US015Config(p1,p2)
函数描述: 配置超声波测距传感器开始工作 注意:US-015超声波模块固定占用Core的D4,D5引脚,D4-->Echo,D5-->Trig。
应用示例:
xxxxxxxxxx
--配置超声波传感器开始工作,固定占用Core的D4,D5引脚,每隔100ms左右可输出一个测量结果
LIB_US015Config()
r1,r2 = LIB_US015GetDistance()
函数描述: 查询超声波测距传感器是否测量出距离,如果障碍物在传感器量程之外,该函数将不会有输出或者返回值r2为99999无效值
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | 整数型,传感器测量出来的距离 |
---|---|
单位:毫米 |
应用示例:
xxxxxxxxxx
--配置超声波传感器开始工作,固定占用Core的D4,D5引脚,每隔100ms左右可输出一个测量结果
LIB_US015Config()
--开始大循环
while(true)
do
--每隔200ms查询一次传感器是否出数
LIB_DelayMs(200)
flag, distance = LIB_US015GetDistance()
if flag == 1 then
--打印测量距离(mm)
print(string.format("distance:%dmm", distance))
end
end
LIB_NEO6MConfig(p1)
函数描述: 配置GPS模块开始工作
p1 | GPS模块占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
应用示例:
xxxxxxxxxx
--配置GPS模块开始工作,占用TX0和RX0引脚
LIB_NEO6MConfig("UART0")
r1,r2,r3,r4,r5 = LIB_NEO6MGetGpsData()
函数描述: 查询是否读到GPS数据
r1 | 整数型,指示是否读到GPS数据 |
---|---|
0: 未读到 1: 已读到 |
r2 | 浮点小数型,经度(longtitude),单位:度 |
---|---|
正数表示东经,负数表示西经 |
r3 | 浮点小数型,纬度(latitude),单位:度 |
---|---|
正数表示北纬,负数表示南纬 |
r4 | 浮点小数型,海拔(altitude),单位:米 |
---|---|
无 |
r5 | 整数型,UTC时间 单位:秒 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--配置GPS模块开始工作,占用TX0和RX0引脚
LIB_NEO6MConfig("UART0")
--开始大循环
while(true)
do
--查询是否解析到GPS数据
flag,lo,la,al,utc = LIB_NEO6MGetGpsData()
if flag == 1 then
--将读取到的经度、纬度、海拔、UTC时间打印输出
print(string.format("longtitue:%.3f° latitue:%.3f° altitue:%.0fm UTC:%d", lo,la,al,utc))
end
end
LIB_HrAlgorithmConfig()
函数描述: 为PulseSensor心率脉搏传感器算法准备好运行环境
应用示例:
xxxxxxxxxx
--为PulseSensor心率脉搏传感器算法准备好运行环境
LIB_HrAlgorithmConfig()
r1,r2,r3 = LIB_HrGetBpmIbi(p1)
函数描述: 该函数向算法喂传感器原始数据的同时也查询算法是否输出有效心率值和脉搏区间
p1 | 整数型,喂给心率算法的传感器原始数据 |
---|---|
该原始数据为2ms间隔的心率传感器AD值 |
r1 | 整数型,指示算法是否检测到一个有效的BPM和IBI数据 |
---|---|
0: 未检测到 1: 已检测到 |
r2 | 整数型,BPM |
---|---|
每分钟的心跳数 |
r3 | 整数型,IBI 单位:毫秒 |
---|---|
相邻两次脉搏的间隔时间,心电图曲线中的(R-R间隔) |
应用示例:
xxxxxxxxxx
--为PulseSensor心率脉搏传感器算法准备好运行环境
LIB_HrAlgorithmConfig()
while(true)
do
--采集心率传感器的原始值
--此处省略采集原始值部分代码,请参看Core相关例程
--给传感器喂原始数据(rawdata),并查询是否解析到有效的心率数据
flag,BPM,IBI = LIB_HrGetBpmIbi(rawdata)
if flag == 1 then
--将解析到的BPM(每分钟心跳)、IBI(心率间隔)值打印输出
print(string.format("BPM:%d IBI:%d ", BPM, IBI))
end
end
LIB_CCS811Config(p1,p2)
函数描述: 配置CCS811气体传感器开始工作
p1 | 传感器占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
p2 | CCS811传感器产生测量结果的周期 |
---|---|
"1S","10S","60S","250MS" |
应用示例:
xxxxxxxxxx
--配置CCS811气体传感器开始工作,占用IIC0接口,每1秒出一组测量结果
LIB_CCS811Config("IIC0", "1S")
r1,r2,r3,r4,r5 = LIB_CCS811GetResult()
函数描述: 查询CCS811传感器是否出数
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | 整数型,Tvoc 单位:ppb |
---|---|
挥发性有机化合物气体 0ppb-1000ppb |
r3 | 整数型,eCO2 单位:ppm |
---|---|
等效二氧化碳 400ppm-5000ppm |
r4 | 整数型,rawdata中的i 单位:uA |
---|---|
current through the sensor, 流经传感器的电流,范围:1-63uA |
r5 | 整数型,rawdata中的u 单位:(1.65v/1023) |
---|---|
raw ADC reading of the voltage across the sensor, 范围:0-1023 |
应用示例:
xxxxxxxxxx
--配置CCS811气体传感器开始工作,占用IIC0接口,每1秒出一组测量结果
LIB_CCS811Config("IIC0", "1S")
--查询传感器是否出数
while(true)
do
flag, tvoc, eCO2, raw_i, raw_u = LIB_CCS811GetResult()
if flag == 1 then
--打印Tvoc和eCO2的值以及rawdata数据i和u
print(string.format("Tvoc:%d, eCO2:%d, i=%d, u=%d", tvoc,eCO2,raw_i,raw_u))
end
end
LIB_CCS811SetCompensate(p1,p2)
函数描述:如果您设计的系统有条件可以得到环境温度和湿度值时,可以对CCS811进行环境温度和湿度补偿。 注意:该函数不需要一直调用,可以视环境温湿度的变化情况每隔一段时间补偿一次。
p1 | NUMBER类型(浮点小数),温度 |
---|---|
单位:℃(度) |
p2 | 整数类型,湿度 |
---|---|
单位:% |
应用示例:
xxxxxxxxxx
--将当前的25.38度的温度和70%的湿度作为校准参数传入CCS811
LIB_CCS811EnvCompensate(25.38, 70)
LIB_TVOCConfig(p1,p2)
函数描述: 配置ENS160/SGP30 TVOC气体传感器开始工作
p1 | 传感器占用的core引脚配置 |
---|---|
"IIC0": SCL0,SDA0 "IIC1": SCL1,SDA1 |
p2 | ENS160/SGP30传感器产生测量结果的周期 |
---|---|
"1S","10S","60S" |
应用示例:
xxxxxxxxxx
--配置ENS160/SGP30气体传感器开始工作,占用IIC0接口,每1秒读出一组测量结果
LIB_TVOCConfig("IIC0", "1S")
r1~r8 = LIB_TVOCGetResult()
函数描述: 查询ENS160/SGP30传感器是否出数
r1 | 整数型,指示是否读取到传感器结果数据 |
---|---|
0: 还未读取到数据 1: 已读取到数据 |
r2 | 整数型,Tvoc 单位:ppb |
---|---|
挥发性有机化合物气体 0–65000ppb |
r3 | 整数型,eCO2 单位:ppm |
---|---|
等效二氧化碳 400–65000ppm |
r4 | 整数型,AQI ,无单位 |
---|---|
空气质量等级(德国标准,详情请参看ens160的datasheet),范围1~5,1表示空气质量最好 注意:SGP30传感器无此数据,返回0值 |
r5 | 整数型,ValidityFlag |
---|---|
0:NormalOperation 1:Warm-Up 2:Start-Up 3:InvalidOutput 详情请参看ENS160的datasheet 注意:SGP30传感器无此数据,返回0值 |
应用示例:
xxxxxxxxxx
--配置ENS160/SGP30气体传感器开始工作,占用IIC0接口,每1秒出一组测量结果
LIB_TVOCConfig("IIC0", "1S")
--查询传感器是否出数
while(GC(1) == true)
do
flag, tvoc, eCO2, AQI, ValidityFlag = LIB_TVOCGetResult()
if flag == 1 then
--打印Tvoc和eCO2的值
print(string.format("Tvoc:%d, eCO2:%d, AQI:%d, VFlag:%d", tvoc,eCO2,AQI,ValidityFlag))
end
end
LIB_TVOCEnvCompensate(p1,p2)
函数描述:如果您设计的系统有条件可以得到环境温度和湿度值时,可以对ENS160/SGP30进行环境温度和湿度补偿。 注意:该函数不需要一直调用,可以视环境温湿度的变化情况每隔一段时间补偿一次。
p1 | NUMBER类型(浮点小数),温度 |
---|---|
单位:℃(度) |
p2 | NUMBER类型(浮点小数),湿度 |
---|---|
单位:% |
应用示例:
xxxxxxxxxx
--将当前的25.38度的温度和70%的湿度作为校准参数传入ENS160/SGP30
LIB_TVOCEnvCompensate(25.38, 70.0)
LIB_ZPH04Config(p1)
函数描述: 配置PM2.5传感器开始工作
p1 | 读卡器模块占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
应用示例:
xxxxxxxxxx
--设置PM2.5传感器占用TX0和RX0引脚
LIB_ZPH04Config("UART0")
r1,r2 = LIB_ZPH04GetPM25()
函数描述: 查询PM2.5传感器是否出数据,并输出传感器值
r1 | 整数型,指示是否读传感器数据 |
---|---|
0: 未读到 1: 已读到 |
r2 | 浮点小数型,PM2.5值 |
---|---|
单位:ug/m^3 微克每立方米 |
应用示例:
xxxxxxxxxx
--设置传感器占用TX0和RX0引脚
LIB_ZPH04Config("UART0")
while(true)
do
--查询是否读到传感器值
flag, val = LIB_ZPH04GetPM25()
if flag == 1 then
--打印读到的PM2.5值,保留1位小数,单位:ug/m^3
print(string.format("PM2.5:%.1f", val))
end
end
LIB_ZE08KConfig(p1)
函数描述: 配置甲醛传感器开始工作
p1 | 读卡器模块占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
应用示例:
xxxxxxxxxx
--设置甲醛传感器占用TX0和RX0引脚
LIB_ZE08KConfig("UART0")
r1,r2 = LIB_ZE08KGetCH2O()
函数描述: 查询甲醛传感器是否出数据,并输出传感器值
r1 | 整数型,指示是否读传感器数据 |
---|---|
0: 未读到 1: 已读到 |
r2 | 整数型,甲醛值,单位:PPB |
---|---|
1000PPB=1PPM,1PPM=1mg/m^3(毫克每立方米) |
应用示例:
xxxxxxxxxx
--设置传感器占用TX0和RX0引脚
LIB_ZE08KConfig("UART0")
while(true)
do
--查询是否读到传感器值
flag, val = LIB_ZE08KGetCH2O()
if flag == 1 then
--打印读到甲醛值(单位PPB),1000PPB=1PPM,1PPM=1毫克每立方米
print(string.format("CH2O:%d PPB", val))
end
end
LIB_Z19CConfig(p1,p2)
函数描述: 配置Z19C二氧化碳传感器开始工作,以及开启开启自动校准
p1 | 传感器占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | 是否开启自动校准 |
---|---|
"AUTO_CALI_EN": 开启 "AUTO_CALI_DIS": 关闭 |
应用示例:
xxxxxxxxxx
--设置Z19C二氧化碳传感器占用TX0和RX0引脚,并启动传感器,关闭自动校准("AUTO_CALI_DIS")
--注意1:自动校准功能是指传感器在连续运行一段时间后,根据环境浓度智能判断零点并自行校准.校准周期
--为自上电运行起,每24小时,自动校准一次.自动校准的零点是400ppm
--注意2:自动校零功能适合用于办公环境,家庭环境.但不适用于农业大棚,养殖场,冷库等场所,在这类场
--所应关闭自动校零功能.关闭后请用户定期(至少半年)对传感器进行手动校零(给Hd引脚7秒以上低电平),手动
--校准零点前请确保传感器在 400ppm 浓度下稳定运行 20 分钟以上。
LIB_Z19CConfig("UART0","AUTO_CALI_DIS")
r1,r2 = LIB_Z19CGetCO2()
函数描述: 查询是否收到Z19C二氧化碳传感器模块的值
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到 1: 已收到 |
r2 | 整数型,单位:PPM |
---|---|
单位:度 ,小数点后两位有效 |
应用示例:
xxxxxxxxxx
--设置Z19C二氧化碳传感器占用TX0和RX0引脚,并启动传感器,关闭自动校准("AUTO_CALI_DIS")
--注意1:自动校准功能是指传感器在连续运行一段时间后,根据环境浓度智能判断零点并自行校准.校准周期
--为自上电运行起,每24小时,自动校准一次.自动校准的零点是400ppm
--注意2:自动校零功能适合用于办公环境,家庭环境.但不适用于农业大棚,养殖场,冷库等场所,在这类场
--所应关闭自动校零功能.关闭后请用户定期(至少半年)对传感器进行手动校零(给Hd引脚7秒以上低电平),手动
--校准零点前请确保传感器在 400ppm 浓度下稳定运行 20 分钟以上。
LIB_Z19CConfig("UART0","AUTO_CALI_DIS")
while(true)
do
--查询是否读到传感器值
flag,val = LIB_Z19CGetCO2()
if flag == 1 then
print(string.format("CO2:%d PPM", val))
end
end
LIB_UsbConfig(p1)
函数描述: 配置USB口的工作模式 注意: 如果你的项目中同时用到Ble蓝牙功能时,一定要先初始化Ble蓝牙之后,再调用本函数。
p1 | USB口工作模式选择参数 |
---|---|
"CDC": USB接口以USB转串口(cdc)方式和PC通信 "CDC_PD": 同CDC,但不支持Lua代码中的print打印至PC了 "KBD": 模拟成USB键盘 |
应用示例:
xxxxxxxxxx
--配置USB接口以USB转串口(cdc)方式工作,和电脑通信的串口波特率为115200,且在Lua代码中的
--print函数直接输出到电脑串口终端上
LIB_UsbConfig("CDC")
r1,r2 = LIB_UsbCdcRecv()
函数描述: 查询是否收到USB串口数据,如果收到数据则返回接收到的数据。注意pc每包发送的数据不要多于256字节,间隔不要小于100ms最好
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--配置USB口以串口(cdc)模式工作
LIB_UsbConfig("CDC")
--查询是否收到PC发来的串口数据,如果收到就print输出
while(true)
do
recv_flag,recv_tab = LIB_UsbCdcRecv()
if recv_flag == 1 then
print(string.format("receive %d bytes", #recv_tab))
end
end
LIB_UsbCdcSend(p1)
函数描述: 将table p1中的数据通过usb串口(cdc)发送出去
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于255个 |
应用示例:
xxxxxxxxxx
--配置USB口以串口(cdc)模式工作
LIB_UsbConfig("CDC")
table = {1,2,3,4,5}
while(true)
do
--每隔3秒向PC的串口终端发送一次数据
LIB_UsbCdcSend(table)
LIB_DelayMs(3000)
end
r1 = LIB_UsbCommPortOpenQuery()
函数描述: 查询USB线是否连上,且PC端已经打开了相应的串口端口
r1 | 整数型,指示是否建立连接 |
---|---|
0: 未连接 1: 已经连上 |
应用示例:
xxxxxxxxxx
--配置USB口以串口(cdc)模式工作
LIB_UsbConfig("CDC")
while(true)
do
--每隔3秒查询一次USB是否已和PC的串口端口建立连接
LIB_DelayMs(3000)
if LIB_UsbCommPortOpenQuery() == 1 then
print("Usb serial commm port connected")
end
end
LIB_UsbKbdSend(p1,p2)
函数描述: 模拟按键动作发送给电脑。注意调用该函数模拟每个按键的动作时都会阻塞LUA系统50毫秒左右
p1 | 按键动作的模拟类型 |
---|---|
"SINGLE": 单个按键 "COMBINE": 组合按键 |
p2 | table类型 |
---|---|
p1="SINGLE"时,table内的元素必须为正确的按键标识符字符串,且元素个数不能大于255个 p1="COMBINE"时,table内的元素必须为正确的按键标识符字符串,且元素个数不能大于6个 |
应用示例:
xxxxxxxxxx
--先配置USB口以USB键盘模式工作
LIB_UsbConfig("KBD")
--模拟组合按键WIN+R调出运行界面效果
combine_tab = {"GUI","R"}
LIB_UsbKbdSend("COMBINE", combine_tab)
--模拟多次敲击产生打字hello world效果
single_tab = {"H","E","L","L","O","SPACEBAR","W","O","R","L","D"}
LIB_UsbKbdSend("SINGLE", single_tab)
r1,r2 = LIB_UsbKbdCapsLockAndNumLockQuery()
函数描述: 查询CapsLock,NumLock是否打开
r1 | 整数型,CapsLock状态 |
---|---|
0: 关闭 1: 已打开 |
r2 | 整数型,NumLock状态 |
---|---|
0: 关闭 1: 已打开 |
应用示例:
xxxxxxxxxx
--配置USB口以串口(cdc)模式工作
CapsLock,NumLock = LIB_UsbKbdCapsLockAndNumLockQuery()
LIB_CH9329Config(p1)
函数描述: 配置CH9329模块占用的UART端口,以及要控制的电脑的屏幕分辨率
p1 | CH9329的UART占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
p2 | 整数类型,屏幕宽度(像素值) |
---|---|
该值为屏幕水平方向像素宽度,范围:0-65535 例如某个屏幕1920*800,那么它的宽度就应该是1920 |
p3 | 整数类型,屏幕高度(像素值) |
---|---|
该值为屏幕垂直方向像素高度,范围:0-65535 例如某个屏幕1920*800,那么它的高度就应该是800 |
应用示例:
xxxxxxxxxx
--设置CH9329模块占用TX0、RX0引脚,屏幕分辨率1920*800
LIB_CH9329Config("UART0",1920,800)
LIB_CH9329_MoveMouse(p1,p2,p3,p4,p5)
函数描述: 让鼠标光标移动至(p2,p3)的坐标位置上,并点击一下左键或者右键或者不点
p1 | 要发送的鼠标目标值的模式 |
---|---|
"ABSOLUTE": 绝对坐标模式 "RELATIVE": 相对坐标模式 | |
注意:Win和Mac系统用绝对坐标模式就可以了,安卓系统有的不支持绝对坐标,需要用相对坐标模式 | |
相对坐标模式的实现稍微复杂一些耗时也会更久,其实现过程为先强行让鼠标回到零点,然后再基于零点让鼠标移动到目标位置 |
p2 | 整数类型,鼠标X轴目标值 |
---|---|
该值为屏幕水平方向像素坐标值,屏幕最左边为0,范围:0-65535 |
p3 | 整数类型,鼠标Y轴目标值 |
---|---|
该值为屏幕垂直方向像素坐标值,屏幕最上边为0,范围:0-65535 |
p4 | 鼠标移动到目标位置后是否点击鼠标,以及左键点击还是右键点击 |
---|---|
"NONE","LEFT","RIGHT" |
p5 | 鼠标是单击还是双击 |
---|---|
"SINGLE","DOUBLE" |
注意:调用该函数会导致Lua程序阻塞:ABSOLUTE模式会阻塞200ms左右,RELATIVE模式会阻塞更长时间(取决于屏幕分辨率),编程时需要加以考虑。
应用示例:
xxxxxxxxxx
--设置CH9329模块占用TX0、RX0引脚,屏幕分辨率1920*800
LIB_CH9329Config("UART0",1920,800)
while(true)
do
--每隔1秒让鼠标移动到屏幕上绝对坐标为(100,100)的位置,并双击一下鼠标左键
LIB_CH9329_MoveMouse("ABSOLUTE", 100, 100,"LEFT","DOUBLE")
LIB_DelayMs(1000)
end
LIB_CH9329KbdSend(p1)
函数描述: 发送按键数据,最多可以同时发送8个功能键 + 6个普通键。
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须为7个 | |
table[1] | 表示是否按下左右Win、Shift、Alt、Ctrl这8个功能键,具体定义请看官网文档教程 |
table[2-7] | 表示6个除上面功能键以外的所有普通按键,需要同时按下几个就填几个,最多不超过6个,按键值具体编码请看官网文档教程 |
注意:调用该函数会导致Lua程序阻塞:阻塞100ms左右,
应用示例:
xxxxxxxxxx
--设置CH9329模块占用TX0、RX0引脚,屏幕分辨率1920*800
LIB_CH9329Config("UART0",1920,800)
--模拟按下A键动作
table = {0x00,0x04,0x00,0x00,0x00,0x00,0x00}
--或者模拟按下左Shift+A键动作
--table = {0x02,0x04,0x00,0x00,0x00,0x00,0x00}
while(true)
do
--每隔3秒发送一次键盘数据
LIB_CH9329KbdSend(table)
LIB_DelayMs(3000)
end
LIB_Uart0Config(p1)
函数描述: 配置Uart0串口开始工作,并按照参数p1的值设定波特率
p1 | 字符串类型,工作模式选择参数 |
---|---|
"BAUDRATE_1200" | |
"BAUDRATE_2400" | |
"BAUDRATE_4800" | |
"BAUDRATE_9600" | |
"BAUDRATE_14400" | |
"BAUDRATE_19200" | |
"BAUDRATE_28800" | |
"BAUDRATE_31250" | |
"BAUDRATE_38400" | |
"BAUDRATE_56000" | |
"BAUDRATE_57600" | |
"BAUDRATE_76800" | |
"BAUDRATE_115200" | |
"BAUDRATE_230400" | |
"BAUDRATE_250000" | |
"BAUDRATE_460800" | |
"BAUDRATE_921600" | |
"BAUDRATE_1000000" |
应用示例:
xxxxxxxxxx
--配置Uart0串口波特率为115200
LIB_Uart0Config("BAUDRATE_115200")
LIB_Uart0Rs485Config(p1,p2)
函数描述: 配置Uart0串口开始工作,并按参数p1的值设定波特率,并使用p2指定的IO引脚作为485收发方向自动控制引脚,这样当Uart Send时该引脚会自动变成低电平,平时则为高电平
p1 | 字符串类型,工作模式选择参数 |
---|---|
"BAUDRATE_1200" | |
"BAUDRATE_2400" | |
"BAUDRATE_4800" | |
"BAUDRATE_9600" | |
"BAUDRATE_14400" | |
"BAUDRATE_19200" | |
"BAUDRATE_28800" | |
"BAUDRATE_31250" | |
"BAUDRATE_38400" | |
"BAUDRATE_56000" | |
"BAUDRATE_57600" | |
"BAUDRATE_76800" | |
"BAUDRATE_115200" | |
"BAUDRATE_230400" | |
"BAUDRATE_250000" | |
"BAUDRATE_460800" | |
"BAUDRATE_921600" | |
"BAUDRATE_1000000" |
p2 | 选择需要配置为模拟RTS方向自动控制引脚的端口标识号 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8" "D9" "D10" "D11" |
p3(可选) | 校验方式选择(仅C2支持) |
---|---|
"NoneParity" "EvenParity" OddParity" |
p4(可选) | 停止位选择(仅C2支持) |
---|---|
"StopBit_1" "StopBit_1_5" "StopBit_2" |
应用示例:
xxxxxxxxxx
--配置Uart0串口波特率为115200, D7作为RTS方向自动控制引脚
LIB_Uart0Rs485Config("BAUDRATE_115200", "D7")
r1,r2 = LIB_Uart0Recv()
函数描述: 查询是否收到串口数据,如果收到数据则返回接收到的数据。注意每个数据包不要大于256字节,且数据包时间间隔尽量不要小于100ms
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--配置Uart0串口波特率为115200
LIB_Uart0Config("BAUDRATE_115200")
--查询是否收到数据,如果收到就print输出
while(GC(1) == true)
do
recv_flag,recv_tab = LIB_Uart0Recv()
if recv_flag == 1 then
print(string.format("receive %d bytes", #recv_tab))
end
end
LIB_Uart0Send(p1)
函数描述: 发送table p1中的数据,每包发送的数据量不要超过255字节,包之间的发送间隔时间也尽量大于100ms
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
应用示例:
xxxxxxxxxx
--配置Uart0串口波特率为115200
LIB_Uart0Config("BAUDRATE_115200")
table = {1,2,3,4,5}
while(true)
do
--每隔3秒发送一次数据
LIB_Uart0Send(table)
LIB_DelayMs(3000)
end
LIB_Uart0BlockSend(p1)
函数描述: 阻塞发送table p1中的数据,每包发送的数据量不要超过255字节,包之间的发送间隔时间也尽量大于10ms
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
应用示例:
xxxxxxxxxx
--配置Uart0串口波特率为115200
LIB_Uart0Config("BAUDRATE_115200")
table = {1,2,3,4,5}
while(true)
do
--每隔3秒发送一次数据
LIB_Uart0BlockSend(table)
LIB_DelayMs(3000)
end
LIB_Uart1Config(p1)
函数描述: 配置Uart1串口开始工作,并按照参数p1的值设定波特率
p1 | 字符串类型,工作模式选择参数 |
---|---|
"BAUDRATE_1200" | |
"BAUDRATE_2400" | |
"BAUDRATE_4800" | |
"BAUDRATE_9600" | |
"BAUDRATE_14400" | |
"BAUDRATE_19200" | |
"BAUDRATE_28800" | |
"BAUDRATE_31250" | |
"BAUDRATE_38400" | |
"BAUDRATE_56000" | |
"BAUDRATE_57600" | |
"BAUDRATE_76800" | |
"BAUDRATE_115200" | |
"BAUDRATE_230400" | |
"BAUDRATE_250000" | |
"BAUDRATE_460800" | |
"BAUDRATE_921600" | |
"BAUDRATE_1000000" |
应用示例:
xxxxxxxxxx
--配置Uart1串口波特率为115200
LIB_Uart1Config("BAUDRATE_115200")
LIB_Uart1Rs485Config(p1,p2)
函数描述: 配置Uart1串口开始工作,并按参数p1的值设定波特率,并使用p2指定的IO引脚作为485收发方向自动控制引脚,这样当调用Uart Send时该引脚会自动变成低电平,平时则为高电平
p1 | 字符串类型,工作模式选择参数 |
---|---|
"BAUDRATE_1200" | |
"BAUDRATE_2400" | |
"BAUDRATE_4800" | |
"BAUDRATE_9600" | |
"BAUDRATE_14400" | |
"BAUDRATE_19200" | |
"BAUDRATE_28800" | |
"BAUDRATE_31250" | |
"BAUDRATE_38400" | |
"BAUDRATE_56000" | |
"BAUDRATE_57600" | |
"BAUDRATE_76800" | |
"BAUDRATE_115200" | |
"BAUDRATE_230400" | |
"BAUDRATE_250000" | |
"BAUDRATE_460800" | |
"BAUDRATE_921600" | |
"BAUDRATE_1000000" |
p2 | 选择需要配置为模拟RTS方向自动控制引脚的端口标识号 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8" "D9" "D10" "D11" |
p3(可选) | 校验方式选择(仅C2支持) |
---|---|
"NoneParity" "EvenParity" OddParity" |
p4(可选) | 停止位选择(仅C2支持) |
---|---|
"StopBit_1" "StopBit_1_5" "StopBit_2" |
应用示例:
xxxxxxxxxx
--配置Uart1串口波特率为115200, D7作为RTS方向自动控制引脚
LIB_Uart1Rs485Config("BAUDRATE_115200", "D7")
r1,r2 = LIB_Uart1Recv()
函数描述: 查询是否收到串口数据,如果收到数据则返回接收到的数据。注意每个数据包不要大于256字节,且数据包时间间隔尽量不要小于100ms
r1 | 整数型,指示是否收到数据 |
---|---|
0: 未收到数据 1: 收到数据 |
r2 | table型,包含接收到的数据 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--配置Uart1串口波特率为115200
LIB_Uart1Config("BAUDRATE_115200")
--查询是否收到数据,如果收到就print输出
while(GC(1) == true)
do
recv_flag,recv_tab = LIB_Uart1Recv()
if recv_flag == 1 then
print(string.format("receive %d bytes", #recv_tab))
end
end
LIB_Uart1Send(p1)
函数描述: 发送table p1中的数据,每包发送的数据量不要超过255字节,发送间隔时间也尽量大于100ms
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
应用示例:
xxxxxxxxxx
--配置Uart1串口波特率为115200
LIB_Uart1Config("BAUDRATE_115200")
table = {1,2,3,4,5}
while(true)
do
--每隔3秒发送一次数据
LIB_Uart1Send(table)
LIB_DelayMs(3000)
end
LIB_Uart1BlockSend(p1)
函数描述: 阻塞发送table p1中的数据,每包发送的数据量不要超过255字节,包之间的发送间隔时间也尽量大于10ms
p1 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
应用示例:
xxxxxxxxxx
--配置Uart1串口波特率为115200
LIB_Uart1Config("BAUDRATE_115200")
table = {1,2,3,4,5}
while(true)
do
--每隔3秒发送一次数据
LIB_Uart1BlockSend(table)
LIB_DelayMs(3000)
end
LIB_GpioInputConfig(p1,p2)
函数描述: 将GPIO口设置为输入
p1 | 选择需要配置为输入端口的端口标识号 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8" "D9" "D10" "D11" |
p2 | 输入模式配置 |
---|---|
"NOPULL": 既不上拉也不下拉 "PULLDOWN": 下拉输入 "PULLUP": 上拉输入 |
应用示例:
xxxxxxxxxx
--设置D0口为上拉输入
LIB_GpioInputConfig("D0","PULLUP")
LIB_GpioOutputConfig(p1,p2)
函数描述: 将GPIO口设置为输出
p1 | 选择需要配置为输出端口的端口标识号 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8" "D9" "D10" "D11" |
p2 | 输出模式配置 |
---|---|
"STANDARD": 标准输出 "OPENDRAIN": 开漏输出 |
应用示例:
xxxxxxxxxx
--设置D0口为开漏输出
LIB_GpioOutputConfig("D0","OPENDRAIN")
r1 = LIB_GpioRead(p1)
函数描述: 读取端口电平状态
p1 | 选择需要读取的端口标识号 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8" "D9" "D10" "D11" |
r1 | 整数型,指示端口读取到的电平高低 |
---|---|
0: 检测到低电平 1: 检测到高电平 |
应用示例:
xxxxxxxxxx
--设置D0口为上拉输入
LIB_GpioInputConfig("D0","PULLUP")
--一直检测D0的值
while(true)
do
gpio_value = LIB_GpioRead("D0")
if gpio_value == 0 then
--do something
end
end
LIB_GpioWrite(p1, p2)
函数描述: 控制端口的输出电平值
p1 | 选择需要控制的端口标识号 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8" "D9" "D10" "D11" |
P2 | 整数型,需要输出的电平值 |
---|---|
0: 低电平 1: 高电平 |
应用示例:
xxxxxxxxxx
--设置D0口为普通输出
LIB_GpioOutputConfig("D0","STANDARD")
--输出周期为1秒的方波
while(true)
do
--D0口输出高电平
LIB_GpioWrite("D0",1)
--延时500ms
LIB_DelayMs(500)
--D0口输出低电平
LIB_GpioWrite("D0",0)
--延时500ms
LIB_DelayMs(500)
end
LIB_GpioToggle(p1)
函数描述: 控制端口输出翻转
p1 | 选择需要控制的端口标识号 |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8" "D9" "D10" "D11" |
应用示例:
xxxxxxxxxx
--设置D0口为普通输出
LIB_GpioOutputConfig("D0","STANDARD")
while(true)
do
--D0口输出翻转
LIB_GpioToggle("D0")
--延时500ms
LIB_DelayMs(500)
end
LIB_10msTimerConfig(p1)
函数描述: 配置是否使能10ms定时器
p1 | 字符串类型,工作模式选择参数 |
---|---|
"DISABLE": 禁止10ms timer | |
"ENABLE": 使能10ms timer |
应用示例:
xxxxxxxxxx
--使能10毫秒定时器开始工作
LIB_10msTimerConfig("ENABLE")
LIB_10msTimerCallback()
函数描述: 如果执行了LIB_10msTimerConfig("ENABLE")后,该函数每10毫秒会被系统自动调用,用户只需定义并填充该函数的具体功能即可
应用示例:
xxxxxxxxxx
--首先定义函数
function LIB_10msTimerCallback()
--注意: 在该函数内不要做阻塞性的工作,不然会导致10ms的调用周期不准确
--do something
end
--然后使能定时器
LIB_10msTimerConfig("ENABLE")
while(true)
do
--do something
end
LIB_IIC0Config(p1)
函数描述: 配置IIC0以master模式开始工作,IIC0使用Core的scl0和sda0引脚
p1 | 字符串类型,IIC通信速率选择 |
---|---|
"100K":100Khz "250K":250Khz "400K":400Khz |
应用示例:
xxxxxxxxxx
--使能IIC0以400Khz的频率开始工作
LIB_IIC0Config("400K")
r1 = LIB_IIC0Write(p1,p2)
函数描述: 向设备地址为p1的slave设备发送p2中的数据,该函数为阻塞型函数,如果连续失败10次后IIC0将被Core放弃。
p1 | 整数类型 |
---|---|
iic slave设备地址 |
p2 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
r1 | 整数型 |
---|---|
1: 表示通信成功 0: 表示通信失败,失败原因可能是地址不对,器件不存在,或发送数据有误等 |
应用示例:
xxxxxxxxxx
--使能IIC0以400Khz的频率开始工作
LIB_IIC0Config("400K")
--向地址为0x32的从设备写5个数据
tab = {1,2,3,4,5}
result = LIB_IIC0Write(0x32, tab)
if result == 1 then
print("write success")
else
print("write fail")
end
r1,r2 = LIB_IIC0Read(p1,p2)
函数描述: 从设备地址为p1的从设备读取数据,该函数为阻塞函数
p1 | 整数类型 |
---|---|
iic slave设备地址 |
p2 | 整数类型 |
---|---|
需要读取的字节数,最多256字节 |
r1 | 整数型 |
---|---|
1: 表示通信成功 0: 表示未能读取到数据,也可能是因为通信失败:地址不对,器件不存在,或发送数据有误等 |
r2 | table类型 |
---|---|
table内的元素为字节型,读取的数据即存储在table中 |
应用示例:
xxxxxxxxxx
--使能IIC0以400Khz的频率开始工作
LIB_IIC0Config("400K")
--从设备地址为0x11的slave设备读取10个字节
result,tab = LIB_IIC0Read(0x11,10)
if result == 1 then
print("read success,the data you read is in tab")
else
print("read fail")
end
LIB_IIC1Config(p1)
函数描述: 配置IIC1以master模式开始工作,IIC1使用Core的scl1和sda1引脚
p1 | 字符串类型,IIC通信速率选择 |
---|---|
"100K":100Khz "250K":250Khz "400K":400Khz |
应用示例:
xxxxxxxxxx
--使能IIC1以400Khz的频率开始工作
LIB_IIC1Config("400K")
r1 = LIB_IIC1Write(p1,p2)
函数描述: 向设备地址为p1的slave设备发送p2中的数据,该函数为阻塞型函数,如果连续失败10次后IIC1将被Core放弃。
p1 | 整数类型 |
---|---|
iic slave设备地址 |
p2 | table类型 |
---|---|
table内的元素必须为字节型,元素个数必须小于256个 |
r1 | 整数型 |
---|---|
1: 表示通信成功 0: 表示通信失败,失败原因可能是地址不对,器件不存在,或发送数据有误等 |
应用示例:
xxxxxxxxxx
--使能IIC1以400Khz的频率开始工作
LIB_IIC1Config("400K")
--向地址为0x32的从设备写5个数据
tab = {1,2,3,4,5}
result = LIB_IIC1Write(0x32, tab)
if result == 1 then
print("write success")
else
print("write fail")
end
r1,r2 = LIB_IIC1Read(p1,p2)
函数描述: 从设备地址为p1的从设备读取数据,该函数为阻塞函数
p1 | 整数类型 |
---|---|
iic slave设备地址 |
p2 | 整数类型 |
---|---|
需要读取的字节数,最多256字节 |
r1 | 整数型 |
---|---|
1: 表示通信成功 0: 表示未能读取到数据,也可能是因为通信失败:地址不对,器件不存在,或发送数据有误等 |
r2 | table类型 |
---|---|
table内的元素为字节型,读取的数据即存储在table中 |
应用示例:
xxxxxxxxxx
--使能IIC1以400Khz的频率开始工作
LIB_IIC1Config("400K")
--从设备地址为0x11的slave设备读取10个字节
result,tab = LIB_IIC1Read(0x11,10)
if result == 1 then
print("read success,the data you read is in tab")
else
print("read fail")
end
LIB_SpiMasterConfig(p1,p2,p3)
函数描述: 配置Core的SPI接口以master模式开始工作,SPI使用Core的CLK,MOSI,MISO,CS引脚 注意:该函数只能调用一次
p1 | 字符串类型,SPI时钟速率选择 |
---|---|
"125K","250K","500K","1M","2M","4M","8M" |
p2 | 字符串类型,SPI通信模式选择,一般情况下Mode0和Mode3比较常用 |
---|---|
"Mode0","Mode1","Mode2","Mode3" | |
"Mode0" | CPOL=0 CPHA=0, SCK active high, Data sampled on the rising edge and shifted out on the falling edge |
"Mode1" | CPOL=0 CPHA=1, SCK active high, Data sampled on the falling edge and shifted out on the rising edge |
"Mode2" | CPOL=1 CPHA=0, SCK active low, Data sampled on the falling edge and shifted out on the rising edge |
"Mode3" | CPOL=1 CPHA=1, SCK active low, Data sampled on the rising edge and shifted out on the falling edge |
p3 | 字符串类型,发送数据高低位顺序选择,一般情况下都是先发送一个字节的最高位"MSB_First" |
---|---|
"MSB_First","LSB_First" |
应用示例:
xxxxxxxxxx
--使能SPI以master模式工作在模式0,时钟为4Mhz的频率,MSB_First:每次先发送字节里的最高位
LIB_SpiMasterConfig("4M","Mode0","MSB_First")
... LIB_SpiMstTransmit(p1, ...)
函数描述: SPI主机开始发送和接收数据,需要注意的是每次收发的数据个数不能超过128个字节。
p1 | 字符串类型,传输模式 |
---|---|
"TxAndRx","TxThenRx","Tx","Rx" | |
"TxAndRx" | 全双工模式,发送和接收同时进行,即SPI主机发送出去多少字节,同时也会收到多少字节 |
"TxThenRx" | 单双工模式,SPI主机先发送数据,发送完后紧接着又开始接收数据 |
"Tx" | 单双工模式,SPI主机只发送数据 |
"Rx" | 单双工模式,SPI主机只接收数据 |
注意:不同传输模式下函数LIB_SpiMstTransmit()的输入参数和返回值不一样,下面的例子会介绍不同模式下函数的调用方法
TxAndRx 应用示例:
xxxxxxxxxx
TxData = {1,2,3}
RxLen = 3
--全双模式,SPI主机发送3个数据同时接收3个数据
RxData = LIB_SpiMstTransmit("TxAndRx",TxData,RxLen)
print(string.format("Spi master had recv %d bytes data,Data[1]=%d,Data[2]=%d,Data[3]=%d", #RxData,RxData[1],RxData[2],RxData[3]))
TxThenRx 应用示例:
xxxxxxxxxx
TxData = {1,2,3}
RxLen = 3
--半双模式,SPI主机发送3个数据完成后,再紧接着接收3个数据
RxData = LIB_SpiMstTransmit("TxThenRx",TxData,RxLen)
print(string.format("Spi master had recv %d bytes data,Data[1]=%d,Data[2]=%d,Data[3]=%d", #RxData,RxData[1],RxData[2],RxData[3]))
Tx 应用示例:
xxxxxxxxxx
TxData = {1,2,3}
--半双模式,SPI主机仅发送3个数据
LIB_SpiMstTransmit("Tx",TxData)
Rx 应用示例:
xxxxxxxxxx
RxLen = 3
--半双模式,SPI主机仅接收3个数据
RxData = LIB_SpiMstTransmit("Rx",RxLen)
print(string.format("Spi master had recv %d bytes data,Data[1]=%d,Data[2]=%d,Data[3]=%d", #RxData,RxData[1],RxData[2],RxData[3]))
LIB_PwmConfig1(p1,p2)
函数描述: 将D0口配置为PWM功能,注意:C1和C2支持的周期/频率范围不同
p1 | 整数类型,Pwm波形的周期 |
---|---|
C1:1-32767微秒 C2:100-32767微秒 |
p2 | 整数类型,Pwm波形的极性 |
---|---|
0: 负极性,即有效占空比期间输出低电平 1 :正极性,即有效占空比期间输出高电平 |
应用示例:
xxxxxxxxxx
--配置D0口为PWM功能,周期10ms,高电平为有效极性
LIB_PwmConfig1(10000,1)
LIB_PwmUpdate1(p1)
函数描述: 调整D0口输出的PWM波形占空比值
p1 | 整数类型,脉冲宽度 |
---|---|
0-32767微秒 |
应用示例:
xxxxxxxxxx
--配置D0口为PWM功能,周期10ms,高电平为有效极性
LIB_PwmConfig1(10000,1)
--更新D0口的PWM输出占空比为50%
LIB_PwmUpdate1(5000)
LIB_PwmSetPrd1(p1,p2)
函数描述: 调整D0口输出的PWM波形的周期(频率)以及占空比值, 注意:C1和C2支持的周期/频率范围不同 注意:该函数不适合频繁调用,因为该函数会有几us时间的延时,并且该函数会在当前PWM周期结束时刻才产生效果
p1 | 整数类型,Pwm波形的周期 |
---|---|
C1:1-32767微秒 C2:100-32767微秒 |
p2 | 整数类型,脉冲宽度 |
---|---|
0-32767微秒 |
应用示例:
xxxxxxxxxx
--调整PWM功能输出的波形为周期10ms(100Hz),占空比值为5ms
LIB_PwmSetPrd1(10000,5000)
LIB_PwmConfig3(p1,p2)
函数描述: 将D0, D1, D2口配置为PWM功能, 注意:C1和C2支持的周期/频率范围不同
p1 | 整数类型,Pwm波形的周期 |
---|---|
C1:1-32767微秒 C2:100-32767微秒 |
p2 | 整数类型,Pwm波形的极性 |
---|---|
0: 负极性,即有效占空比期间输出低电平 1 :正极性,即有效占空比期间输出高电平 |
应用示例:
xxxxxxxxxx
--配置D0 D1 D2口为PWM功能,周期10ms,高电平为有效极性
LIB_PwmConfig3(10000,1)
LIB_PwmUpdate3(p1,p2,p3)
函数描述: 调整D0 D1 D2口输出的PWM波形占空比值
p1 | 整数类型,DO口脉冲宽度 |
---|---|
0-32767微秒 |
p2 | 整数类型,D1口脉冲宽度 |
---|---|
0-32767微秒 |
p3 | 整数类型,D2口脉冲宽度 |
---|---|
0-32767微秒 |
应用示例:
xxxxxxxxxx
--配置D0 D1 D2口为PWM功能,周期10ms,高电平为有效极性
LIB_PwmConfig3(10000,1)
--更新D0口的PWM输出占空比为50%
--更新D1口的PWM输出占空比为25%
--更新D2口的PWM输出占空比为100%
LIB_PwmUpdate3(5000,2500,10000)
LIB_PwmSetPrd3(p1,p2,p3,p4)
函数描述: 调整D0 D1 D2口输出的PWM波形的周期(频率)以及占空比值, 注意:C1和C2支持的周期/频率范围不同 注意:该函数不适合频繁调用,因为该函数会有几us时间的延时,并且该函数会在当前PWM周期结束时刻才产生效果
p1 | 整数类型,D0 D1 D2口Pwm波形的周期 |
---|---|
C1:1-32767微秒 C2:100-32767微秒 |
p2 | 整数类型,D0口的脉冲宽度 |
---|---|
0-32767微秒 |
p3 | 整数类型,D1口的脉冲宽度 |
---|---|
0-32767微秒 |
p4 | 整数类型,D2口的脉冲宽度 |
---|---|
0-32767微秒 |
应用示例:
xxxxxxxxxx
--调整PWM功能输出的波形为周期10ms(100Hz),D0,D1,D2的占空比值分别5ms,2ms,1ms
LIB_PwmSetPrd3(10000,5000,2000,1000)
LIB_PwmConfig8(p1,p2)
函数描述: 将Core的D0~D7这8个IO口配置为PWM输出功能, 注意:C1和C2支持的周期/频率范围不同
p1 | 整数类型,Pwm波形的周期 |
---|---|
C1:1-32767微秒 C2:100-32767微秒 |
p2 | 整数类型,Pwm波形的极性 |
---|---|
0: 负极性,即有效占空比期间输出低电平 1 :正极性,即有效占空比期间输出高电平 |
应用示例:
xxxxxxxxxx
--配置D0 D1 D2 D3 D4 D5 D6 D7口为PWM功能,周期10ms,高电平为有效极性
LIB_PwmConfig8(10000,1)
LIB_PwmUpdate8(p1~p8)
函数描述: 调整D0~D7口输出的PWM波形占空比值
p1 | 整数类型,DO口脉冲宽度 |
---|---|
0-32767微秒 |
p2 | 整数类型,D1口脉冲宽度 |
---|---|
0-32767微秒 |
p3 | 整数类型,D2口脉冲宽度 |
---|---|
0-32767微秒 |
p4 | 整数类型,D3口脉冲宽度 |
---|---|
0-32767微秒 |
p5 | 整数类型,D4口脉冲宽度 |
---|---|
0-32767微秒 |
p6 | 整数类型,D5口脉冲宽度 |
---|---|
0-32767微秒 |
p7 | 整数类型,D6口脉冲宽度 |
---|---|
0-32767微秒 |
p8 | 整数类型,D7口脉冲宽度 |
---|---|
0-32767微秒 |
应用示例:
xxxxxxxxxx
--配置D0~D7这8个IO口为PWM功能,周期10ms,高电平为有效极性
LIB_PwmConfig8(10000,1)
--更新D0口的PWM输出占空比为50%
--更新D1口的PWM输出占空比为25%
--更新D2口的PWM输出占空比为100%
--更新D0口的PWM输出占空比为10%
--更新D1口的PWM输出占空比为20%
--更新D2口的PWM输出占空比为30%
--更新D0口的PWM输出占空比为40%
--更新D1口的PWM输出占空比为50%
LIB_PwmUpdate8(5000,2500,10000,1000,2000,3000,4000,5000)
LIB_PwmSetPrd8(p1,p2~p9)
函数描述: 调整D0~D7这8个IO口输出的PWM波形的周期(频率)以及占空比值, 注意:C1和C2支持的周期/频率范围不同 注意:该函数不适合频繁调用,因为该函数会有几us时间的延时,并且该函数会在当前PWM周期结束时刻才产生效果
p1 | 整数类型,D0~D7口Pwm波形的周期 |
---|---|
C1:1-32767微秒 C2:100-32767微秒 |
p2 | 整数类型,D0口的脉冲宽度 |
---|---|
0-32767微秒 |
p3 | 整数类型,D1口的脉冲宽度 |
---|---|
0-32767微秒 |
p4 | 整数类型,D2口的脉冲宽度 |
---|---|
0-32767微秒 |
p5 | 整数类型,D3口的脉冲宽度 |
---|---|
0-32767微秒 |
p6 | 整数类型,D4口的脉冲宽度 |
---|---|
0-32767微秒 |
p7 | 整数类型,D5口的脉冲宽度 |
---|---|
0-32767微秒 |
p8 | 整数类型,D6口的脉冲宽度 |
---|---|
0-32767微秒 |
p9 | 整数类型,D7口的脉冲宽度 |
---|---|
0-32767微秒 |
应用示例:
xxxxxxxxxx
--调整PWM功能输出的波形为周期10ms(100Hz),D0~D7的占空比值分别1ms,2ms,3ms,4ms,5ms,6ms,7ms,8ms
LIB_PwmSetPrd8(10000,1000,2000,3000,4000,5000,6000,7000,8000)
LIB_ADConfig(p1,p2)
函数描述: 同时让4个通道(A0-A3)开始AD采集工作。AD工作模式为单端输入,12-bit工作模式,4096对应最大电压3.6v
p1 | 整数类型,每个通道缓存大小,即缓存需要存放多少个采集点才会满 |
---|---|
该参数须大于1,且最大值不能超过64 |
p2 | 整数类型,采集时间间隔,单位:微秒(us) |
---|---|
最小值不能小于200us,建议该值大于1000以上,太低了会增加CPU负荷 |
注意1: A0-A3引脚的输入电压均不能超过mcu的VDD 3.3V 注意2: 配置了AD功能就不能再用比较器功能了(只针对C1,因为C2没有比较器功能) 注意3: 当参数p2采集时间间隔大于1000us时,时间精度降为1ms(只针对C2) 注意4: p1 * p2 的结果须大于20ms,且该乘积应尽量为20ms的整数倍(只针对C2) 注意5: C1最高能测3.6v以内的输入电压,而C2最高只能测2.6v左右的输入电压
应用示例:
xxxxxxxxxx
--配置A0-A3这四个通道同时开始工作,每个通道采集满50个点时缓存满,每个点的采集时间间隔为1000us
LIB_ADConfig(50,1000)
LIB_ADStop()
函数描述: 停止AD工作,再次开启AD需要重新调用LIB_ADRestart()函数
应用示例:
xxxxxxxxxx
--停机AD工作
LIB_ADStop()
LIB_ADRestart()
函数描述: 停止AD工作,再次开启AD需要重新调用LIB_ADRestart()函数
应用示例:
xxxxxxxxxx
--恢复AD工作
LIB_ADRestart()
r1,r2 = LIB_ADCheckBufFull(p1)
函数描述: 查询某个AD通道缓存是否已满,如果满了就在表中返回缓存中的数据
p1 | 字符串型,需要查询的通道标识 |
---|---|
"A0","A1","A2","A3" |
r1 | 整数型,指示通道An的缓存buf是否已满,如果满了r2就会包含缓存中的所有AD采样数据 |
---|---|
0: 未满 1: 已满 |
r2 | table型,返回已满缓存中的数据,数据个数取决于你用LIB_ADConfig时设置的大小 |
---|---|
无 |
应用示例:
xxxxxxxxxx
--配置A0-A3这四个通道同时开始工作,每个通道采集满50个点时缓存满,每个点的采集时间间隔为1000us
LIB_ADConfig(50,1000)
--分别查询A0和A1通道的缓存是否已满,如果满了就取出数据并做相关处理,此处我们可以不管A2和A3
while(true)
do
A0_full_flag, A0_tab = LIB_ADCheckBufFull("A0")
if A0_full_flag == 1 then
print(string.format("A0 get %d sample datas\r\n", #A0_tab))
--do something with A0_tab
end
A1_full_flag, A1_tab = LIB_ADCheckBufFull("A1")
if A1_full_flag == 1 then
print(string.format("A1 get %d sample datas\r\n", #A1_tab))
--do something with A1_tab
end
end
LIB_CompConfig(p1,p2)
函数描述: 配置电压比较器开始工作,比较器的输入引脚为Core的A0引脚,注意:当配置电压比较器后就无法使用AD功能 另外电压比较器默认带迟滞功能,hysteresis=50mv
p1 | 字符串类型,比较器的参考电压1/16Vdd - 15/16Vdd,其中Vdd为Core的电源3.3v |
---|---|
"0.125Vdd" | |
"0.25Vdd" | |
"0.375Vdd" | |
"0.5Vdd" | |
"0.625Vdd" | |
"0.75Vdd" | |
"0.875Vdd" | |
"0.0625Vdd" | |
"0.1875Vdd" | |
"0.3125Vdd" | |
"0.4375Vdd" | |
"0.5625Vdd" | |
"0.6875Vdd" | |
"0.8125Vdd" | |
"0.9375Vdd" |
p2 | 字符串类型,比较器工作模式选择参数 |
---|---|
"UpAndDown" : 当A0引脚的输入电压超过或低于参考电压时,都会触发回调函数LIB_CompCallBack()的调用 | |
"Up" : 当A0引脚的输入电压超过参考电压时,触发回调函数LIB_CompCallBack()的调用 | |
"Down" : 当A0引脚的输入电压低于参考电压时,触发回调函数LIB_CompCallBack()的调用 |
应用示例:
xxxxxxxxxx
--配置电压比较器开始工作,参考电压=0.5Vdd,工作模式为Down
--即当A0引脚上电压降低到小于0.5Vdd时,Lua应用层会立即自动调用用户定义的LIB_CompCallBack()回调函数
LIB_CompConfig("0.5Vdd", "Down")
LIB_CompCtrl(p1)
函数描述: 调用LIB_CompConfig配置比较器开始工作后,可以用LIB_CompCtrl函数随时打开或关闭比较器
p1 | 字符串类型 |
---|---|
"CLOSE":打开比较器 "OPEN":关闭比较器 |
应用示例:
xxxxxxxxxx
--配置比较器,该函数执行完后比较器会立即开始工作
LIB_CompConfig("0.5Vdd", "Down")
--但此时让比较器立即停止工作
LIB_CompCtrl("CLOSE")
LIB_CompCallBack()
函数描述: 如果执行了LIB_CompConfig()让电压比较器开始工作后,每当Core的A0引脚上电压变化满足条件时,该函数会自动被调用
应用示例:
xxxxxxxxxx
--首先定义函数,该函数在比较器输入电压低于0.5Vdd时会自动被调用
function LIB_CompCallBack()
--注意: 在该函数内不要做阻塞性的工作
--do something
end
--配置电压比较器开始工作
LIB_CompConfig("0.5Vdd", "Down")
while(true)
do
--do something
end
LIB_PulseWidthMeasureConfig(p1,p2)
函数描述: 配置测量脉宽时的参数,测量的时间精度能够达到1us。Core中用于测量的引脚固定为D4引脚 注意:在C2中被测量波形的最大脉宽不能超过32ms,且C2不能测量连续波形(脉冲个数不能超过256个),否则将无法测量
p1 | 字符串类型,用于配置测量引脚D4是否使能内部上拉或下拉电阻 |
---|---|
"NoPull" "PullDown" "PullUp" |
p2 | 字符串类型,用于配置触发测量的条件 |
---|---|
"Fall":下降沿触发 "Rise":上升沿触发 |
p3 | 整数类型,滤波参数,测量的波形中脉宽小于该值的将被忽略 |
---|---|
单位:us |
应用示例:
xxxxxxxxxx
--配置测量脉宽的D4引脚内部上拉,触发条件为下降沿,滤掉脉宽小于1000us的波形
LIB_PulseWidthMeasureConfig("PullUp","Fall",1000)
LIB_PulseWidthMeasureStart(p1,p2)
函数描述: 配置测量脉宽时的参数,测量的时间精度能够达到1us。Core中用于测量的引脚固定为D4引脚
p1 | 整数类型,想要测量的高低电平脉宽数量 |
---|---|
由于系统缓存有限,要测量的脉宽数量最多不能超过256个,如果大于256,按256个算 |
p2 | 整数类型,超时时间 |
---|---|
单位:毫秒 |
应用示例:
xxxxxxxxxx
--开始脉宽测量,希望在10秒内测到150个高低电平的脉宽
LIB_PulseWidthMeasureStart(150,10000)
r1,r2 = LIB_PulseWidthMeasureFinishCheck()
函数描述: 查询脉宽测量工作是否结束,如果结束就可以从返回的table表中取出每个高低电平的脉宽(单位:us)
r1 | 整数型,指示测量工作是否结束 |
---|---|
0: 测量中 1: 测量结束(结束原因可能是已完成预定的高低电平数量,也可能是超时) |
r2 | table型,包含测量到的数据 ,正数表示该脉宽是高电平,负数表示该脉宽是低电平,单位:us |
---|---|
table的元素个数反映了实际测量到的高低电平数量,当数量少于预设的值时说明测量是因超时结束的 |
应用示例:
xxxxxxxxxx
--配置测量脉宽的D4引脚内部上拉,触发条件为下降沿,滤掉脉宽小于1000us的波形
LIB_PulseWidthMeasureConfig("PullUp","Fall",1000)
--开始脉宽测量,希望在10秒内测到150个高低电平的脉宽
LIB_PulseWidthMeasureStart(150,10000)
while(true)
do
--查询测量工作是否结束
finish_flag, data_tab = LIB_PulseWidthMeasureFinishCheck()
if finish_flag == 1 then
print(string.format("Job over, had measured %d segments\r\n", #data_tab))
end
end
LIB_PulseCountMeasureConfig(p1,p2)
函数描述: 配置脉冲计数工作时的参数,配置完成后以p3设定的周期计量并更新每个周期所测的脉冲数量 注意:在C2中被测量波形的最大脉宽不能超过32ms,且C2不能测量连续波形(脉冲个数不能超过256个),否则将无法测量
p1 | 字符串类型,用于配置测量引脚D4是否使能内部上拉或下拉电阻 |
---|---|
"NoPull" "PullDown" "PullUp" |
p2 | 字符串类型,用于配置计数的脉冲类型 |
---|---|
"Fall": 下降沿触发 "Rise":上升沿触发 "RiseAndFall": 上升沿和下降沿 |
p3 | 整数类型,计数周期 |
---|---|
单位:ms,范围可从(1-0x7FFFFFFF)毫秒 |
应用示例:
xxxxxxxxxx
--配置计量脉冲的D4引脚内部上拉,触发条件为下降沿,计数周期为1000ms
LIB_PulseCountMeasureConfig("PullUp","Fall",1000)
r1,r2 = LIB_PulseCountMeasureFinishCheck()
函数描述: 查询本周期的脉冲计数的工作是否出结果
r1 | 整数型,本周期计数工作是否完成 |
---|---|
0: 正在计数中 1: 计数结束 |
r2 | 整数型,本周期的计数结果 |
---|---|
单位: 个 |
应用示例:
xxxxxxxxxx
--配置计量脉冲的D4引脚内部上拉,触发条件为下降沿,计数周期为1000ms
LIB_PulseCountMeasureConfig("PullUp","Fall",1000)
while(true)
do
--查询计数结果,该函数需要保证每1000ms至少调用一次,不然你会错过这个周期的计数结果
finish_flag, data = LIB_PulseCountMeasureFinishCheck()
if finish_flag == 1 then
print(string.format("Job over, had count %d pulse in 1000ms\r\n", data))
end
end
r1 = LIB_WaveFormConfig(p1,p2,p3,p4,p5,p6,p7)
函数描述: 配置自定义脉宽波形序列发生器,D3引脚固定作为波形输出引脚 注意:仅C2支持该功能
p1 | 整数类型,clk_div分频系数,范围1-255,被分频的主频为80Mhz |
---|---|
分频后的频率即为波形的最小分辨率,例如clk_div=80时,频率=80Mhz/80=1Mhz |
p2 | 整数类型,idle_level |
---|---|
没输出波形时(空闲时)的默认电平,1为高电平,0为低电平,如果载波使能。一般设为0 |
p3 | 整数类型,reverse |
---|---|
输出电平是否反向,1使能反向,0禁止反向 |
p4 | 整数类型,carrier_en |
---|---|
是否使能载波,carrier_en=1时使能载波,0时禁止 |
p5 | 整数类型,carrier_duty_percent |
---|---|
载波的占空比(1%~100%) |
p6 | 整数类型,carrier_freq_hz |
---|---|
载波的频率(单位Hz) |
p7 | 整数类型,carrier_level |
---|---|
载波的有效电平,1为高电平,0为低电平,一般设为1 |
示例1(无载波情形):
xxxxxxxxxx
--将80M主频经过分频80后为1Mhz,即分辨率为1us。
--默认(空闲时)输出低电平,禁止输出反向功能,禁止载波功能
LIB_WaveFormConfig(80, 0, 0, 0, 0, 0, 0)
示例2(有载波情形):
xxxxxxxxxx
--将80M主频经过分频80后为1Mhz,即分辨率为1us。
--默认(空闲时)输出低电平,禁止输出反向功能,使能载波功能
--载波占空比为50%,载波频率10KHz,载波有效电平为高电平
LIB_WaveFormConfig(80, 0, 0, 1, 50, 10000, 1)
LIB_WaveFormSend(p1,p2)
函数描述: 发送参数p1 table中定义的波形,波形中每个脉冲的宽度由table中的值以及分辨率决定 注意:table中的每个值正数不能超过32767,负数不能低于-32768
p1 | table类型 |
---|---|
table内的元素必须为整数型,元素个数不能超过512个,即一次最多发送512个脉冲 |
p2 | 整数类型,设置是否阻塞发送,如果阻塞发送那么该函数会一直卡住直到所有波形发送完成才会返回 |
---|---|
1:阻塞发送,0:非阻塞发送 |
应用示例:
xxxxxxxxxx
--将80M主频经过分频80后为1Mhz,即分辨率为1us。
--默认(空闲时)输出低电平,禁止输出反向功能,禁止载波功能
LIB_WaveFormConfig(80, 0, 0, 0, 0, 0, 0)
--定义
tab = {100,-100,500,-500,1000}
while(GC(1) == true)
do
--每隔1秒发送一串包含五个高低电平的波形(阻塞式发送)
--五个电平脉宽分别为100us,100us,500us,500us,1000us
LIB_WaveFormSend(tab, 1)
LIB_DelayMs(1000)
end
r1 = LIB_FlashGetNumber(p1)
函数描述: Core为用户提供64个Number存储区域,每个Number区域可以让用户存1个4字节的int型数据, 本函数通过p1参数来获取指定的Number区的值。
p1 | 字符串类型,Number区索引 |
---|---|
"0","1","2","3","4","5","6","7","8","9", "10","11","12","13","14","15","16","17","18","19", "20","21","22","23","24","25","26","27","28","29", "30","31","32","33","34","35","36","37","38","39", "40","41","42","43","44","45","46","47","48","49", "50","51","52","53","54","55","56","57","58","59", "60","61","62","63" |
r1 | 整数型 |
---|---|
返回指定Number区的int值 |
应用示例:
xxxxxxxxxx
--读取Number6的值
value = LIB_FlashGetNumber("6")
print(string.format("Number6 = %d\r\n", value))
LIB_FlashWriteNumber(p1,p2)
函数描述: Core为用户提供64个Number存储区域,每个Number区域可以让用户存1个4字节的int型数据, 本函数实现了向p1参数所指定的Number区写入int型值p2。 注意:调用该函数会造成大概100毫秒的阻塞
p1 | 字符串类型,Number区索引 |
---|---|
"0","1","2","3","4","5","6","7","8","9", "10","11","12","13","14","15","16","17","18","19", "20","21","22","23","24","25","26","27","28","29", "30","31","32","33","34","35","36","37","38","39", "40","41","42","43","44","45","46","47","48","49", "50","51","52","53","54","55","56","57","58","59", "60","61","62","63" |
p2 | 整数型 |
---|---|
需要写入的int型数据 |
应用示例:
xxxxxxxxxx
--向Number6区域写入值-100
LIB_FlashWriteNumber("6",-100)
r1 = LIB_FlashGetString(p1)
函数描述: Core为用户提供4个String存储区域,每个String区域可以让用户存1个长度在64字节范围内的字符串, 本函数通过p1参数来获取指定的String区的字符串。
p1 | 字符串类型,String区索引 |
---|---|
"0":String0 "1":String1 "2":String2 "3":String3 |
r1 | 字符串型 |
---|---|
返回指定String区的字符串 |
应用示例:
xxxxxxxxxx
--读取String0的字符串
str = LIB_FlashGetString("0")
print(string.format("String0 = %s\r\n", str))
LIB_FlashWriteString(p1,p2)
函数描述: Core为用户提供4个String存储区域,每个String区域可以让用户存1个长度在64字节范围内的字符串, 本函数实现了向p1参数所指定的String区写入字符串。 注意:调用该函数会造成大概100毫秒的阻塞
p1 | 字符串类型,String区索引 |
---|---|
"0":String0 "1":String1 "2":String2 "3":String3 |
p2 | 字符串类型 |
---|---|
需要写入String区的字符串 |
应用示例:
xxxxxxxxxx
--向String0区域写入字符串"www.shineblink.com"
str = "www.shineblink.com"
LIB_FlashWriteString("0",str)
LIB_WatchDogConfig(p1)
函数描述: 配置看们狗按指定的溢出时间开始工作 当溢出时间到达之时,Lua代码仍然没有执行LIB_WatchDogFeed()喂狗操作,Core会自动系统重启
p1 | 字符串类型,用于配置看门狗的溢出时间 |
---|---|
"0.1S","1S","10S","30S","120S" |
应用示例:
xxxxxxxxxx
--配置开始工作,溢出时间为10秒
LIB_WatchDogConfig("10S")
LIB_WatchDogFeed()
函数描述: 喂狗
应用示例:
xxxxxxxxxx
--喂狗,可以在Lua代码任意位置执行
LIB_WatchDogFeed()
r1,r2,r3,r4 = LIB_GetC2KeyDbgInfo()
函数描述: 调用该函数后,会返回各种关键调试信息,用于协助诊断一些关键问题
r1 | 字符串型,芯片重启原因 |
---|---|
r2 | 字符串型,芯片crash位置信息 |
r3 | 整数型,芯片底层剩余heap空间,单位byte |
r4 | 整数型,芯片WiFi是否连上Ap ,1表示连上,0表示未连上 |
应用示例:
xxxxxxxxxx
--在代码的某处获取关键调试信息
Rst,Crash,HeapSpace,ApCon=LIB_GetC2KeyDbgInfo()
--例如输出"rst=PwrO, crash=None, space=12506, ap=1"
print(string.format("rst=%s, crash=%s, space=%d, ap=%d", Rst,Crash,HeapSpace,Apcon))--打印输出
LIB_FacConfig(p1)
函数描述: 配置Core具备Fac产测功能(注意:仅C2支持该功能)
p1 | 通讯串口占用的core引脚配置 |
---|---|
"UART0": TX0,RX0 "UART1": TX1,RX1 |
应用示例:
xxxxxxxxxx
--使用UART0口作为Fac产测功能的通信串口
LIB_FacConfig("UART0")
r1,r2 = LIB_FacSendFile(p1)
函数描述: 调用该函数后,会将TF卡中SRC文件夹下的p1命名的文件下发(SRC文件夹不存在时请手工创建一个) 注意:该函数是一个严重阻塞的函数,阻塞的的时间由整个文件传输的时间决定
p1 | 字符串类型 |
---|---|
需要传输的文件名字,注意:该文件必须放在虚拟TF卡的根级目录中的"SRC/"文件夹下,且文件大小不能超过70KB |
p2(可选) | 被发送文件的Core外部看门狗引脚设置,当该参数设置之后,对应的看门狗引脚会在下载大文件时不停的翻转电平,以防止外部的看门狗芯片复位Core |
---|---|
"D0" "D1" "D2" "D3" "D4" "D5" "D6" "D7" "D8",已被Core的LED1占用 "D9",已被Core的LED2占用 "D10",已被Core的BTN1占用 "D11",已被Core的BTN2占用 |
r1 | 整数型,指示是否成功发送 |
---|---|
0: 失败 1: 成功 |
r2 | 字符串类型 |
---|---|
包含传输失败的信息,用于调试 |
应用示例:
xxxxxxxxxx
--本示例代码假定对方此时已进入Fac模式(上电时Fac引脚为高电平)
--使用UART0口作为Fac产测功能的通信串口
LIB_FacConfig("UART0")
--设置按键"BTN1"(占用D10口)以低电平有效的方式检测按键动作
LIB_ButtonConfig("BTN1","D10","L")
while(GC(1) == true)
do
--轮询按键事件
key_value = LIB_ButtonQuery("BTN1")
--如果按键1短按过,就开始将TF卡上SRC文件夹中的main.lua文件下传
if key_value == 1 then
result,info = LIB_FacSendFile("main.lua")
if result == 0 then
print(string.format("Fail:%s", info))
else
print(string.format("Ok:%s", info))
end
end
end
r1,r2 = LIB_FacGetUidStr()
函数描述: 调用该函数后,会将从对端获取一个类似"090807060504030201"的芯片唯一序列号(UID) 注意: 该函数具有阻塞性,阻塞时间取决于对端应答的时间
r1 | 整数型,指示是否成功发送 |
---|---|
0: 失败 1: 成功 |
r2 | 字符串类型 |
---|---|
r1=1时包含UID,r1=0时包含错误信息 |
应用示例:
xxxxxxxxxx
--本示例代码假定对方此时已进入Fac模式(上电时Fac引脚为高电平)
--使用UART0口作为Fac产测功能的通信串口
LIB_FacConfig("UART0")
--设置按键"BTN1"(占用D10口)以低电平有效的方式检测按键动作
LIB_ButtonConfig("BTN1","D10","L")
while(GC(1) == true)
do
--轮询按键事件
key_value = LIB_ButtonQuery("BTN1")
--如果按键1短按过,就开始获取对端的唯一序列号
if key_value == 1 then
result,info = LIB_FacGetUidStr()
if result == 0 then
print(string.format("Fail:%s", info))
else
print(string.format("OK:%s", info))--打印uid
end
end
end
r1,r2 = LIB_FacWriteFlashString()
函数描述: 调用该函数后,会将一个不超过64字节的字符串写入对端的Flash String0~3 这四个区域中的其中一个。该函数可以给用户提供出厂预写一些定制信息,比如产品序列号,之后用户通过LIB_FlashGetString函数即可获取该字符串信息 注意: 该函数具有阻塞性,阻塞时间取决于对端应答的时间
p1 | 字符串类型,String区索引 |
---|---|
"0":String0 "1":String1 "2":String2 "3":String3 |
p2 | 字符串类型 |
---|---|
需要写入String区的字符串 |
r1 | 整数型,指示是否成功发送 |
---|---|
0: 失败 1: 成功 |
r2 | 字符串类型 |
---|---|
根据r1的值,返回相信的结果信息,例如r1=1时返回"Success" |
应用示例:
xxxxxxxxxx
--本示例代码假定对方此时已进入Fac模式(上电时Fac引脚为高电平)
--使用UART0口作为Fac产测功能的通信串口
LIB_FacConfig("UART0")
--设置按键"BTN1"(占用D10口)以低电平有效的方式检测按键动作
LIB_ButtonConfig("BTN1","D10","L")
while(GC(1) == true)
do
--轮询按键事件
key_value = LIB_ButtonQuery("BTN1")
--如果按键1短按过,就开始向对端的String0 Flash区域写入"Hello World 123"
if key_value == 1 then
result,info = LIB_FacWriteFlashString("0", "Hello World 123")
if result == 0 then
print(string.format("Fail:%s", info))
else
print(string.format("OK:%s", info))--打印"Success"信息
end
end
end
r1 = GC(p1)
函数描述: 执行Lua的垃圾回收功能,及时为系统heap释放空间
p1 | 整数型,表示每调用多少次GC()才执行一次垃圾回收 |
---|---|
一般设置成1,即每次调用GC()都执行一次垃圾回收 如果为了给CPU减负,该值可以设置的大一些 |
r1 | boolean类型,总是返回true |
---|---|
无 |
注意: 也可以不用这个函数,用Lua自带的垃圾回收函数collectgarbage("collect")也可以。
应用示例:
xxxxxxxxxx
--在大循环中,每循环一次,执行一次垃圾回收
while(GC(1) == true)
do
--do something
end
LIB_LuaHeapStatistics()
函数描述: 打印输出Lua heap使用情况,打印结果可以在log.txt或usb串口终端看到
应用示例:
xxxxxxxxxx
LIB_LuaHeapStatistics()
--[[
打印出结果类似于下面的样例,Block表示heap中的各个区块大小,Total表示每个区块一共有多少个,Used表示被用了多少个。
Heap Use Statistics(HeapSize= 54048 bytes):
Block 16B 32B 64B 256B 2048B 4096B 4352B
Total 50 400 60 30 10 1 1
Used 3 216 14 7 9 1 0
]]
LIB_SystemLogEnable()
函数描述: 使能系统日志,系统日志不仅可以存在sd卡上,也可以通过usb串口print出来,取决于用户设置,该功能用户不需用。
应用示例:
xxxxxxxxxx
--在代码一开始处增加如下代码
LIB_SystemLogEnable()
LIB_SystemReset()
函数描述: 调用该函数后,系统会立刻重启。
应用示例:
xxxxxxxxxx
--在代码的某处执行重启操作
LIB_SystemReset()
LIB_GetSysUniID()
函数描述: 调用该函数后,会返回一个属于本机的9字节唯一ID号,例如"0102030405A6B7C8D9"
应用示例:
xxxxxxxxxx
--在代码的某处获取唯一ID号
ID_Str=LIB_GetSysUniID()
print(ID_Str)--打印输出
r1,r2,r3,r4,r5,r6,r7 = LIB_GetDateTime()
函数描述: 获取系统年月日,时分秒以及毫秒
r1 | 整数型,年 |
---|---|
r2 | 整数型,月 |
r3 | 整数型,日 |
r4 | 整数型,时 |
r5 | 整数型,分 |
r6 | 整数型,秒 |
r7 | 整数型,毫秒 |
应用示例:
xxxxxxxxxx
y,mo,d,h,mi,s,ms = LIB_GetDateTime()
print(string.format("date=%02d-%02d-%02d time=%02d:%02d:%02d.%03d",y,mo,d,h,mi,s,ms))
LIB_SetUtcTime(p1)
函数描述: 将UTC时间设置为系统时间
p1 | 整数类型,UTC时间 |
---|---|
单位:秒 |
应用示例:
xxxxxxxxxx
--将2020/5/20 14:38:35的时间戳1589956715设置为系统时间
LIB_SetUtcTime(1589956715)
LIB_DelayMs(p1)
函数描述: 毫秒级延时
p1 | 整数类型,延时参数 |
---|---|
0-999999999毫秒 |
应用示例:
xxxxxxxxxx
--延时1000毫秒
LIB_DelayMs(1000)
r1 = LIB_StrToTab(p1)
函数描述: 将字符串转换成table类型返回
p1 | 字符串类型 |
---|---|
注意: 字符串长度不能超过256字节,否则会截断字符串 |
r1 | table类型 |
---|---|
无 |
应用示例:
xxxxxxxxxx
table = LIB_StrToTab("hello world\r\n")
r1 = LIB_TabToStr(p1)
函数描述: 将table中的每个字符合并转换成字符串返回
p1 | table类型 |
---|---|
注意: table中的每个元素必须是0-255的ascii码值(否则会造成无法预料结果),且table中的元素个数不能大于256 |
r1 | 字符串类型 |
---|---|
注意: 返回的字符串长度不会超过256字节 |
应用示例:
xxxxxxxxxx
--打印"hello"
tab = {0x68,0x65,0x6c,0x6c,0x6f}
str = LIB_TabToStr(tab)
print(str)
r1 = LIB_HexStrToHexTab(p1)
函数描述: 将HEX形式的字符串转换成table类型数组返回 例如将"001122AABBCC"转换成table={0x00,0x11,0x22,0xAA,0xBB,0xCC}
p1 | 字符串类型 |
---|---|
注意1: 字符串长度不能超过256字节,否则会截断字符串 | |
注意2: 字符串长度必须是偶数 | |
注意3: 字符串中的每个字符必须是'0'-'9','A'-'F','a'-'f' |
r1 | table类型 |
---|---|
table中的每个元素值为0x00~0xff |
应用示例:
xxxxxxxxxx
table = LIB_HexStrToHexTab("010203FF1A")
--输出的结果应该为table = {0x01,0x02,0x03,0xff,0x1a}
r1 = LIB_HexTabToHexStr(p1)
函数描述: 将table中的每个8位HEX值合并转换成HEX字符串返回 例如将table={0x00,0x11,0x22,0xAA,0xBB,0xCC}转换成"001122AABBCC"
p1 | table类型 |
---|---|
注意: table中的每个元素的值必须是0-255,且table中的元素个数不能大于128 |
r1 | 字符串类型 |
---|---|
注意: 返回的字符串长度不会超过255 |
应用示例:
xxxxxxxxxx
tab = {0x68,0x65,0x6c,0x6c,0x6f}
str = LIB_HexTabToHexStr(tab)
print(str) --打印结果为"68656C6C6C"
r1 = LIB_Sum8Calculate(p1)
函数描述: 计算p1中所有元素(字节型元素)的8位(Byte型)和校验,并在r1中返回Byte型结果
p1 | table类型 |
---|---|
注意: table中的每个元素必须是0-255的值,且table中的元素个数不能大于256 |
r1 | 整型数(Byte) |
---|---|
返回的值不会大于0xFF |
应用示例:
xxxxxxxxxx
Data = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09}
sum8 = LIB_Sum8Calculate(Data)
print(string.format("sum8=0x%02X, sum8))
--以上print打印结果分别为:sum8=0x2D
--可以通过在线网络工具https://www.lammertbies.nl/comm/info/crc-calculation来验证上面的结果
r1 = LIB_CrcCalculate(p1,p2)
函数描述: 根据p1指定的算法模式计算长度为p3字节数的表p2内数据的CRC,并将结果通过r1返回 该库函数中的CRC8,16,32算法从www.libcrc.org中移植
p1 | 字符串类型,传输模式,"CRC8","CRC16","CRC_MODBUS","CRC32" |
---|---|
CRC8 | crc_start_value=0x00 |
CRC16 | crc_start_value=0x0000, crc_polynomial=0xA001 |
CRC16_MODBUS | crc_start_value=0xFFFF, crc_polynomial=0xA001 |
CRC32 | crc_start_value=0xFFFFFFFF, crc_polynomial=0xEDB88320 |
p2 | table类型,待校验的数据 |
---|---|
注意: table中的每个元素必须是0-255的值,且table中的元素个数不能大于256 |
r1 | 整型数,算法返回的结果 |
---|---|
注意: CRC8返回的是8bit数值,CRC16和CRC16_MODBUS返回的是16bit数值,CRC32返回的是32bit数值 |
应用示例:
xxxxxxxxxx
Data = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09}
crc8 = LIB_CrcCalculate("CRC8", Data)
crc16 = LIB_CrcCalculate("CRC16", Data)
crc16_mb = LIB_CrcCalculate("CRC16_MODBUS", Data)
crc32 = LIB_CrcCalculate("CRC32", Data)
print(string.format("crc8=0x%02X,crc16=0x%04X,crc16_mb=0x%04X,crc32=0x%08X", crc8,crc16,crc16_mb,crc32))
--以上print打印结果分别为:crc8=0xD9,crc16=0x4204,crc16_mb=0xB20E,crc32=0x40EFAB9E
--可以通过在线网络工具https://www.lammertbies.nl/comm/info/crc-calculation来验证上面的结果
LIB_LuaOtaStart(p1,p2)
函数描述: 准备开始OTA,并记录即将下载的文件的CRC32值以及文件的大小, 该函数执行之后会自动删掉TF卡上之前的download.lua文件删掉(如果存在的话),
p1 | 整数类型,32位整数 |
---|---|
即将下载的文件的CRC32值 | |
p2 | 整数类型,32位整数 |
:--- | :--- |
即将下载的文件的的大小,单位:字节 |
应用示例:
xxxxxxxxxx
--即将下载的文件的CRC32值为0x65AC7721,大小为8200字节
LIB_LuaOtaStart(0x65AC7721, 8200)
LIB_LuaOtaWrite(p1)
函数描述: 将p1中的每个字符元素写入临时文件download.lua中 注意1: 执行LIB_LuaOtaWrite函数前,必须调用过LIB_LuaOtaStart函数,并且p1的元素个数不能超过256 注意2: 不要连续调用该函数,中间最好留50ms以上的时间留给系统向TF卡写入数据
p1 | table类型 |
---|---|
table中的每个元素必须是asscii字符 |
应用示例:
xxxxxxxxxx
--"hello"
tab = {0x68,0x65,0x6c,0x6c,0x6f}
--即将下载的文件的CRC32值为0x65AC7721,大小为8200字节
LIB_LuaOtaStart(0x65AC7721, 8200)
--向TF卡上的download.lua文件中写入"hello"
LIB_LuaOtaWrite(tab)
r1,r2 = LIB_LuaOtaEnd(p1)
函数描述: 调用该函数后,如果下载的文件大小(size)和CRC32校验结果都没问题,会自动将download.lua名字改为p1,然后返回该函数的执行结果 注意:即使该函数返回"Success"结果后,系统也不会实际进行Lua代码的更新,需要用户后续调用LIB_SystemReset()函数重启系统后才会真正的更新
p1 | 字符串类型 |
---|---|
注意:p1必须是"main.lua"或者"main_rea.lua",不然无法真正更新lua代码 |
r1 | 整数类型 |
---|---|
0表示:"Success" | |
1表示:Error, OTA not yet start | |
2表示:"Error size" | |
3表示:"Error crc32" | |
4表示:"Error read dowmload.lua fail" |
r2 | 字符串类型 |
---|---|
返回Ota下载文件的结果,只会有如下五种结果(注意:下面的size和crc32数据是举例的假数据): | |
"Success" | |
"Error, OTA not yet start" | |
"Error size, Size should be 3500 bytes, but now is 2000 bytes" | |
"Error crc32, Crc32 should be Oxab123456, but now is 0x12345678" | |
"Error read dowmload.lua fail" |
应用示例:
xxxxxxxxxx
ret_code, ret_string = LIB_LuaOtaEnd("main.lua")
if ret_code == 0 then --表明OTA下载的文件没有问题,可以开始更新Lua代码了
LIB_SystemReset() --重启系统触发更新
else
print(ret_string) --打印OTA错误原因
end
r1.. = LIB_BC(p1..)
函数描述: 在硬件开发中经常遇到寄存器或者通信数据是字节流形式,对于Lua语言来说不太友好, BC(Byte Convert)函数可用来将字节数据转换成Lua数据类型(NUMBER和INT),或者将Lua数据类型转换成字节数据。 注意:由于处理器是小端模式,以下所有操作都是基于小端模式,所以LIB_BC函数不管是返回值还是参数都按从左到右对应从高到低。
p1 | 字符串类型:操作指令 |
---|---|
注意:下面的WORD=32bit数据,HALF_WORD=16bit数据,BYTE=8bit数据 | |
"BYTE16_F64" | 四个HALF_WORD型转换成NUMBER浮点数(double) |
"BYTE16_F32" | 两个HALF_WORD型转换成NUMBER浮点数(float) |
"F32_BYTE16" | NUMBER浮点数转换成两个HALF_WORD型 |
"BYTE16_I32" | 两个HALF_WORD型转换成INT整数 |
"I32_BYTE16" | INT整数转换成两个HALF_WORD型 |
"BYTE16_I16" | 一个HALF_WORD型转换成INT整数 |
"I16_BYTE16" | INT整数转换成一个HALF_WORD型 |
"BYTE8_F32" | 四个BYTE型转换成NUMBER浮点数 |
"F32_BYTE8" | NUMBER浮点数转换成四个BYTE型 |
"BYTE8_I32" | 四个BYTE型转换成INT整数 |
"I32_BYTE8" | INT整数转换成四个BYTE型 |
"BYTE8_I16" | 两个BYTE型转换成INT整数 |
"I16_BYTE8" | INT整数转换成两个BYTE型 |
"BYTE8_I8" | 一个BYTE型转换成INT整数 |
"I8_BYTE8" | INT整数转换成一个BYTE型 |
"BYTE16_SWAP" | 将HALF_WORD中包含的两个BYTE相互交换 |
pn | 类型待定 |
---|---|
pn参数的个数由p1决定 |
rn | 类型待定 |
---|---|
返回数据rn的个数由p1决定 |
应用示例:
xxxxxxxxxx
--以下15个例子分别展示了BC函数的15种用法,其中:
--浮点数转换二进制验证工具可用:https://tooltt.com/floatconverter/
--整数转换成补码的验证工具可用:http://www.atoolbox.net/Tool.php?Id=952
--例0:BYTE16_F64: 将四个二进制16位数据转换成IEEE-754双精度浮点数(double)
tab = {0x407D, 0x47D2,F1A9,FBE7} --0x407D47D2F1A9FBE7实际上等于468.489
val = LIB_BC("BYTE16_F64", tab[1], tab[2], tab[3], tab[4])
--例1:BYTE16_F32: 将两个二进制16位数据转换成IEEE-754浮点数(float)
tab = {0x4133, 0x3333} --0x41333333实际上等于11.2
val = LIB_BC("BYTE16_F32", tab[1], tab[2])
--结果:val=11.2
print(string.format("val=%f", val))
--例2:F32_BYTE16: 将IEEE-754浮点数转换成两个二进制16位数据
ff = 11.2
val1,val2 = LIB_BC("F32_BYTE16", ff)
--结果:val1=0x4133,val2=0x3333
print(string.format("val1=0x%04x,val2=0x%04x", val1,val2))
--例3:BYTE16_I32: 将两个二进制16位数据转换成带符号32位整数
tab = {0xffff, 0xffec} --0xffffffec实际上是-20的32位补码
val = LIB_BC("BYTE16_I32", tab[1], tab[2])
--结果:val=-20
print(string.format("val=%d", val))
--例4:I32_BYTE16: 将带符号32位整数转换成两个二进制16位数据
aa = -20
val1,val2 = LIB_BC("I32_BYTE16", aa)
--结果:val1=0xffff,val2=0xffec
print(string.format("val1=0x%04x,val2=0x%04x", val1,val2))
--例5:BYTE16_I16: 将二进制16位数据转换成带符号16位整数
tab = {0xffec} --0xffec实际上是-20的16位补码
val = LIB_BC("BYTE16_I16", tab[1])
--结果:val=-20
print(string.format("val=%d", val))
--例6:I16_BYTE16: 将带符号16位整数转换成二进制16位数据
aa = -20
val = LIB_BC("I16_BYTE16", aa)
--结果:val=0xffec
print(string.format("val=0x%04x", val))
--例7:BYTE8_F32: 将四个二进制8位数据转换成IEEE-754浮点数
tab = {0xc4,0x7a,0x25,0x1f} --0xc47a251f实际上等于-1000.58
val = LIB_BC("BYTE8_F32", tab[1],tab[2],tab[3],tab[4])
--结果:val=-1000.58
print(string.format("val=%f", val))
--例8:F32_BYTE8: 将IEEE-754浮点数转换成四个二进制8位数据
ff = -1000.58
v1,v2,v3,v4 = LIB_BC("F32_BYTE8", ff)
--结果:v1=0xc4,v2=0x7a,v3=0x25,v4=0x1f
print(string.format("v1=0x%02x,v2=0x%02x,v3=0x%02x,v4=0x%02x", v1,v2,v3,v4))
--例9:BYTE8_I32: 将四个二进制8位数据转换成带符号32位整数
tab = {0x00, 0x01, 0xe2, 0x40} --0x0001e240实际上是123456的32位补码
val = LIB_BC("BYTE8_I32", tab[1], tab[2], tab[3], tab[4])
--结果:val=123456
print(string.format("val=%d", val))
--例10:I32_BYTE8: 将带符号32位整数转换成四个二进制8位数据
aa = 123456
v1,v2,v3,v4 = LIB_BC("I32_BYTE8", aa)
--结果:v1=0x00,v2=0x01,v3=0xe2,v4=0x40
print(string.format("v1=0x%02x,v2=0x%02x,v3=0x%02x,v4=0x%02x", v1,v2,v3,v4))
--例11:BYTE8_I16: 将两个二进制8位数据转换成带符号16位整数
tab = {0xfe,0xfc} --0xfefc实际上是-260的16位补码
val = LIB_BC("BYTE8_I16", tab[1], tab[2])
--结果:val=-260
print(string.format("val=%d", val))
--例12:I16_BYTE8: 将带符号16位整数转换成两个二进制8位数据
aa = -260
v1,v2 = LIB_BC("I16_BYTE8", aa)
--结果:v1=0xfe,v2=0xfc
print(string.format("v1=0x%02x,v2=0x%02x", v1,v2))
--例13:BYTE8_I8: 将二进制8位数据转换成带符号8位整数
tab = {0xfe} --0xfe实际上是-2的8位补码
val = LIB_BC("BYTE8_I8", tab[1])
--结果:val=-2
print(string.format("val=%d", val))
--例14:I8_BYTE8: 将带符号8位整数转换成二进制8位数据
aa = -2
val = LIB_BC("I8_BYTE8", aa)
--结果:val=0xfe
print(string.format("val=0x%02x", val))
--例15:BYTE16_SWAP: 将二进制16位数据的高字节和低字节互换
tab = {0x1234}
val = LIB_BC("BYTE16_SWAP", tab[1])
--结果:val=0x3412
print(string.format("val=0x%04x", val))