Merge branch 'master' of https://gitee.com/openLuat/LuatOS

components/crypto/luat_crypto_mbedtls.c

@@ -1,4 +1,7 @@
 // crypto库的软件实现, 基于mbedtls
+#ifdef CHIP_EC616
+#include "FreeRTOS.h"
+#endif
 
 #include "luat_base.h"
 #include "luat_crypto.h"
@@ -61,6 +64,7 @@ int l_crypto_cipher_xxx(lua_State *L, uint8_t flags) {
     const char* iv = luaL_optlstring(L, 5, "", &iv_size);
     uint8_t *temp = NULL;
     int ret = 0;
+    int cipher_mode = 0;
 
     unsigned char output[32] = {0};
     size_t input_size = 0;
@@ -121,9 +125,9 @@ int l_crypto_cipher_xxx(lua_State *L, uint8_t flags) {
     block_size = mbedtls_cipher_get_block_size(&ctx);
 
     #if MBEDTLS_VERSION_NUMBER >= 0x03000000
-    int cipher_mode = mbedtls_cipher_info_get_mode(_cipher);
+    cipher_mode = mbedtls_cipher_info_get_mode(_cipher);
     #else
-    int cipher_mode = _cipher->mode;
+    cipher_mode = _cipher->mode;
     #endif
 
     if ((cipher_mode == MBEDTLS_MODE_ECB) && !strcmp("PKCS7", pad) && (flags & 0x1)) {

components/lpmem/luat_lib_lpmem.c

@@ -0,0 +1,89 @@
+
+/*
+@module  lpmem
+@summary 操作低功耗不掉电内存块
+@version V0002
+@date    2020.07.10
+*/
+
+#include "luat_base.h"
+#include "luat_malloc.h"
+#include "luat_msgbus.h"
+#include "luat_timer.h"
+#include "luat_lpmem.h"
+
+/*
+读取内存块
+@api    lpmem.read(offset, size)
+@int 内存偏移量
+@int 读取大小,单位字节
+@return string 读取成功返回字符串,否则返回nil
+@usage  
+-- 读取1kb的内存
+local data = lpmem.read(0, 1024)
+*/
+static int l_lpmem_read(lua_State *L) {
+    size_t offset = luaL_checkinteger(L, 1);
+    size_t size = luaL_checkinteger(L, 2);
+    void* buff = luat_heap_malloc(size);
+    int ret = luat_lpmem_read(offset, size, buff);
+    if (ret == 0) {
+        lua_pushlstring(L, (const char*)buff, size);
+    }
+    else {
+        lua_pushliteral(L, "");
+    }
+    luat_heap_free(buff);
+    return 1;
+}
+
+/*
+写入内存块
+@api    lpmem.write(offset, str)
+@int 内存偏移量
+@string 待写入的数据
+@return boolean 成功返回true,否则返回false
+@usage  
+-- 往偏移量为512字节的位置, 写入数据
+lpmem.write(512, data)
+*/
+static int l_lpmem_write(lua_State *L) {
+    size_t size;
+    size_t offset = luaL_checkinteger(L, 1);
+    const char* str = luaL_checklstring(L, 2, &size);
+    if (size > 0) {
+        int ret = luat_lpmem_write(offset, size, (void*)str);
+        if (ret == 0) {
+            lua_pushboolean(L, 1);
+            return 1;
+        }
+    }
+    lua_pushboolean(L, 0);
+    return 1;
+}
+
+/*
+获取内存块的总大小
+@api    lpmem.size()
+@return int 内存块的大小
+@usage  
+lpmem.size()
+*/
+static int l_lpmem_size(lua_State *L) {
+    lua_pushinteger(L, luat_lpmem_size());
+    return 1;
+}
+
+#include "rotable2.h"
+static const rotable_Reg_t reg_lpmem[] =
+{
+    { "read" ,         ROREG_FUNC(l_lpmem_read)},
+    { "write" ,        ROREG_FUNC(l_lpmem_write)},
+    { "size",          ROREG_FUNC(l_lpmem_size)},
+	{ NULL,            ROREG_INT(0) }
+};
+
+LUAMOD_API int luaopen_lpmem( lua_State *L ) {
+    luat_newlib2(L, reg_lpmem);
+    return 1;
+}

components/lpmem/luat_lpmem.h

@@ -0,0 +1,10 @@
+
+#ifndef LUAT_LPMEM_H
+#define LUAT_LPMEM_H
+#include "luat_base.h"
+
+int luat_lpmem_read(size_t offset, size_t size, void*buff);
+int luat_lpmem_write(size_t offset, size_t size, void*buff);
+int luat_lpmem_size(void);
+
+#endif

components/network/ctiot/luat_ctiot.h

@@ -0,0 +1,84 @@
+#ifndef __LUAT_CTIOT_H__
+#define __LUAT_CTIOT_H__
+#include "luat_base.h"
+#include "stdbool.h"
+enum
+{
+	CTIOT_EVENT_REG = 0,
+	CTIOT_EVENT_UPDATE,
+	CTIOT_EVENT_DEREG,
+	CTIOT_EVENT_STATE,
+	CTIOT_EVENT_OB19,
+	CTIOT_EVENT_TX,
+	CTIOT_EVENT_RX,
+	CTIOT_EVENT_NOTIFY,
+	CTIOT_EVENT_SUSPEND,
+	CTIOT_EVENT_FOTA,
+	CTIOT_EVENT_AIR,
+	CTIOT_EVENT_DBG,
+
+	CTIOT_REG_OK = 0,
+	CTIOT_REG_TIMEOUT,
+	CTIOT_REG_SERVER_REJECT,
+	CTIOT_REG_VERSION_ERROR,
+	CTIOT_REG_EP_ERROR,
+	CTIOT_REG_TX_ERROR,
+	CTIOT_REG_STACK_ERROR,
+	CTIOT_UPDATE_OK = 0,
+	CTIOT_UPDATE_NOT_LOGIN,
+	CTIOT_UPDATE_TIMEOUT,
+	CTIOT_UPDATE_PARAM_ERROR,
+	CTIOT_UPDATE_SERVER_REJECT,
+	CTIOT_UPDATE_TX_ERROR,
+	CTIOT_DEREG_DONE = 0,
+	CTIOT_STATE_TAU_WAKEUP = 0,
+	CTIOT_STATE_SS_ERROR,
+	CTIOT_STATE_SS_FAIL,
+	CTIOT_STATE_SS_STACK_ERROR,
+	CTIOT_STATE_TAU_NOTIFY,
+	CTIOT_OB19_ON = 0,
+	CTIOT_OB19_OFF,
+	CTIOT_TX_ACK = 0,
+	CTIOT_TX_DONE,
+	CTIOT_TX_TIMEOUT,
+	CTIOT_TX_SERVER_RST,
+	CTIOT_TX_FAIL,
+	CTIOT_TX_OTHER_ERROR,
+	CTIOT_TX_ERROR,
+	CTIOT_NOTIFY_ACK = 0,
+	CTIOT_NOTIFY_DONE,
+	CTIOT_NOTIFY_TIMEOUT,
+	CTIOT_NOTIFY_SERVER_RST,
+	CTIOT_NOTIFY_FAIL,
+	CTIOT_NOTIFY_OTHER_ERROR,
+	CTIOT_NOTIFY_ERROR,
+	CTIOT_SUSPEND_QUIT = 0,
+	CTIOT_SUSPEND_READY,
+	CTIOT_SUSPEND_START,
+	CTIOT_FOTA_DOWNLOADING = 0,
+	CTIOT_FOTA_DOWNLOAD_FAILED,
+	CTIOT_FOTA_DOWNLOAD_SUCCESS,
+	CTIOT_FOTA_UPDATING,
+	CTIOT_FOTA_UPDATE_SUCCESS,
+	CTIOT_FOTA_UPDATE_FAILED,
+	CTIOT_FOTA_UPDATE_OVER,
+	CTIOT_FOTA_6,
+	CTIOT_FOTA_7,
+	CTIOT_AIR_NON_SEND_START=0,
+	CTIOT_AIR_CON_OK,
+	CTIOT_AIR_NON_SEND,
+};
+extern void luat_ctiot_callback(uint8_t type, uint8_t code, void *buf, uint32_t len);
+extern void luat_ctiot_init(void);
+extern uint16_t luat_ctiot_get_ep(char *userEp);
+extern uint16_t luat_ctiot_set_ep(char *userEp);
+extern uint16_t luat_ctiot_set_para(char* serverIP,uint16_t port,uint32_t lifeTime,char* objectInstanceList/*,char* pskId,char* psk*/);
+extern uint16_t luat_ctiot_set_mod(uint8_t securityMode,uint8_t idAuthMode,uint8_t autoTAUUpdate,uint8_t onUQMode,uint8_t onCELevel2Policy,uint8_t autoHeartBeat,uint8_t wakeupNotify, uint8_t protocolMode);
+extern uint16_t luat_ctiot_get_para(char* serverIP,uint16_t* port,uint32_t* lifeTime,char* objectInstanceList/*,char* pskId,char* psk*/);
+extern uint16_t luat_ctiot_get_mod(uint8_t* securityMode,uint8_t* idAuthMode,uint8_t* autoTAUUpdate,uint8_t* onUQMode,uint8_t* onCELevel2Policy,uint8_t* autoHeartBeat,uint8_t* wakeupNotify, uint8_t* protocolMode);
+extern uint16_t luat_ctiot_reg(void);
+extern uint16_t luat_ctiot_dereg(void);
+extern uint16_t luat_ctiot_update_reg(uint16_t*msgId,bool withObjects);
+extern uint16_t luat_ctiot_send(const uint8_t* data,uint32_t datalen, uint8_t sendMode, uint8_t seqNum);
+extern uint16_t luat_ctiot_check_ready(void);
+#endif

components/network/ctiot/luat_lib_ctiot.c

@@ -0,0 +1,546 @@
+/*
+@module  ctiot
+@summary 中国电信CTIOT集成
+@version 1.0
+@date    2020.08.30
+@demo ctiot
+*/
+#include "luat_base.h"
+#include "luat_timer.h"
+#include "luat_malloc.h"
+#include "luat_msgbus.h"
+#include "luat_ctiot.h"
+#define LUAT_LOG_TAG "ctiot"
+#include "luat_log.h"
+//---------------------------
+#ifdef AIR302
+#define DBG(X,Y...) LLOGD("%s %d:"X, __FUNCTION__, __LINE__, ##Y)
+const char luat_pub_tx_tag[] = "CTIOT_TX";
+const char luat_pub_rx_tag[] = "CTIOT_RX";
+const char luat_pub_reg_tag[] = "CTIOT_REG";
+const char luat_pub_update_tag[] = "CTIOT_UPDATE";
+const char luat_pub_dereg_tag[] = "CTIOT_DEREG";
+const char luat_pub_wakeup_tag[] = "CTIOT_WAKEUP";
+const char luat_pub_other_tag[] = "CTIOT_OTHER";
+const char luat_pub_fota_tag[] = "CTIOT_FOTA";
+static int luat_ctiot_msg_handler(lua_State *L, void* ptr)
+{
+	uint8_t type;
+	uint8_t code;
+	uint32_t len;
+	uint8_t *buff = (uint8_t *)ptr;
+	char *tag;
+	LUA_INTEGER error,error_code,param;
+	type = buff[0];
+	code = buff[1];
+	memcpy(&len, buff+2, 4);
+	switch(type)
+	{
+	case CTIOT_EVENT_TX:
+		tag = (char *)luat_pub_tx_tag;
+		param = 0;
+		switch (code)
+		{
+		case CTIOT_TX_ACK:
+		case CTIOT_TX_DONE:
+			goto LUAT_CTIOT_MSG_HANDLER_DONE;
+			//break;
+		default:
+			error = 1;
+			error_code = code;
+			break;
+		}
+		break;
+	case CTIOT_EVENT_UPDATE:
+		tag = (char *)luat_pub_update_tag;
+		param = 0;
+		switch (code)
+		{
+		case CTIOT_UPDATE_OK:
+			error = 0;
+			error_code = 0;
+			param = 0;
+			break;
+		default:
+			error = 1;
+			error_code = code;
+			param = 0;
+			break;
+		}
+		break;
+	case CTIOT_EVENT_AIR:
+		tag = (char *)luat_pub_tx_tag;
+		param = 0;
+		switch (code)
+		{
+		case CTIOT_AIR_NON_SEND_START:
+			goto LUAT_CTIOT_MSG_HANDLER_DONE;
+			//break;
+		default:
+			error = 0;
+			error_code = 0;
+			param = buff[6];
+			break;
+		}
+		break;
+	case CTIOT_EVENT_RX:
+		tag = (char *)luat_pub_rx_tag;
+		break;
+	case CTIOT_EVENT_STATE:
+		switch (code)
+		{
+		case CTIOT_STATE_TAU_WAKEUP:
+		case CTIOT_STATE_TAU_NOTIFY:
+			tag = (char *)luat_pub_wakeup_tag;
+			error = 0;
+			error_code = 0;
+			param = code;
+			break;
+		default:
+			tag = (char *)luat_pub_other_tag;
+			error = 0;
+			error_code = type;
+			param = code;
+			break;
+		}
+		break;
+	case CTIOT_EVENT_REG:
+		tag = (char *)luat_pub_reg_tag;
+		switch (code)
+		{
+		case CTIOT_REG_OK:
+			error = 0;
+			error_code = 0;
+			param = 0;
+			break;
+		default:
+			error = 1;
+			error_code = code;
+			param = 0;
+			break;
+		}
+		break;
+	case CTIOT_EVENT_OB19:
+		tag = (char *)luat_pub_reg_tag;
+		switch (code)
+		{
+		case CTIOT_OB19_ON:
+			error = 0;
+			error_code = 0;
+			param = 1;
+			break;
+		default:
+			error = 1;
+			error_code = code;
+			param = 0;
+			break;
+		}
+		break;
+	case CTIOT_EVENT_DEREG:
+		tag = (char *)luat_pub_dereg_tag;
+		error = 0;
+		error_code = 0;
+		param = 0;
+		break;
+	case CTIOT_EVENT_FOTA:
+		tag = (char *)luat_pub_fota_tag;
+		error = 0;
+		error_code = 0;
+		param = code;
+		break;
+	default:
+		tag = (char *)luat_pub_other_tag;
+		error = 0;
+		error_code = type;
+		param = code;
+		break;
+	}
+	lua_getglobal(L, "sys_pub");
+	lua_pushstring(L, tag);
+/*
+@sys_pub ctiot
+CTIOT 接收回调消息
+CTIOT_RX
+@string data, CTIOT 接收数据
+@usage
+sys.subscribe("CTIOT_RX", function(data)
+    log.info("CTIOT_RX", data:toHex())
+end)
+*/
+	if (CTIOT_EVENT_RX == type)
+	{
+		lua_pushlstring(L, buff + 6, len);
+		lua_call(L, 2, 0);
+	}
+	else
+	{
+/*
+@sys_pub ctiot
+CTIOT 发送回调消息
+CTIOT_TX
+@bool error, 是否成功
+@number error_code, 错误代码
+@number param, 数据
+@usage
+sys.subscribe("CTIOT_TX", function (error, error_code, param)
+    log.info("CTIOT_TX", error, error_code, param)
+end)
+*/
+
+/*
+@sys_pub ctiot
+CTIOT REG回调消息
+CTIOT_REG
+@bool error, 是否成功
+@number error_code, 错误代码
+@number param, 数据
+@usage
+sys.subscribe("CTIOT_REG", function (error, error_code, param)
+    log.info("CTIOT_REG", error, error_code, param)
+end)
+*/
+
+/*
+@sys_pub ctiot
+CTIOT DEREG回调消息
+CTIOT_DEREG
+@bool error, 是否成功
+@number error_code, 错误代码
+@number param, 数据
+@usage
+sys.subscribe("CTIOT_DEREG", function (error, error_code, param)
+    log.info("CTIOT_DEREG", error, error_code, param)
+end)
+*/
+
+/*
+@sys_pub ctiot
+CTIOT 唤醒回调消息
+CTIOT_WAKEUP
+@bool error, 是否成功
+@number error_code, 错误代码
+@number param, 数据
+@usage
+sys.subscribe("CTIOT_WAKEUP", function (error, error_code, param)
+    log.info("CTIOT_WAKEUP", error, error_code, param)
+end)
+*/
+
+/*
+@sys_pub ctiot
+CTIOT 其他回调消息
+CTIOT_OTHER
+@bool error, 是否成功
+@number error_code, 错误代码
+@number param, 数据
+@usage
+sys.subscribe("CTIOT_OTHER", function (error, error_code, param)
+    log.info("CTIOT_OTHER", error, error_code, param)
+end)
+*/
+
+/*
+@sys_pub ctiot
+CTIOT FOTA回调消息
+CTIOT_FOTA
+@bool error, 是否成功
+@number error_code, 错误代码
+@number param, 数据
+@usage
+sys.subscribe("CTIOT_FOTA", function (error, error_code, param)
+    log.info("CTIOT_FOTA", error, error_code, param)
+end)
+*/
+
+		lua_pushboolean(L, error);
+		lua_pushinteger(L, error_code);
+		lua_pushinteger(L, param);
+		lua_call(L, 4, 0);
+	}
+LUAT_CTIOT_MSG_HANDLER_DONE:
+	luat_heap_free(ptr);
+	return 0;
+}
+
+
+void luat_ctiot_callback(uint8_t type, uint8_t code, void *buf, uint32_t len)
+{
+	rtos_msg_t msg;
+	uint8_t *buff;
+	DBG("%d,%d,0x%08x,%u",type, code, buf, len);
+	if (type >= CTIOT_EVENT_DBG)
+	{
+		return;
+	}
+	msg.handler = luat_ctiot_msg_handler;
+	if (buf)
+	{
+		msg.ptr = luat_heap_malloc(6 + len);
+	}
+	else
+	{
+		msg.ptr = luat_heap_malloc(6);
+	}
+	buff = msg.ptr;
+	if (buff)
+	{
+		buff[0] = type;
+		buff[1] = code;
+		memcpy(buff + 2, &len, 4);
+		if (buf)
+		{
+			memcpy(buff + 6, buf, len);
+		}
+	}
+	luat_msgbus_put(&msg, 0);
+
+}
+/**
+初始化ctiot，在复位开机后使用一次
+@api ctiot.init()
+@return nil 无返回值
+ */
+static int l_ctiot_init(lua_State *L)
+{
+	luat_ctiot_init();
+	return 0;
+}
+
+/**
+设置和读取ctiot相关参数，有参数输入则设置，无论是否有参数输入，均输出当前参数
+@api ctiot.param(ip, port, lifetime)
+@string 服务器ip
+@int 服务器端口
+@int 生命周期,单位秒
+@return string 服务器ip
+@return int 服务器端口
+@return int 生命周期,单位秒
+ */
+static int l_ctiot_param(lua_State *L)
+{
+	char server_ip[20];
+	const char *new_ip;
+	uint16_t port;
+	uint16_t result;
+	uint32_t lifetime;
+	size_t len;
+	uint8_t new_set = 0;
+	result = luat_ctiot_get_para(server_ip, &port, &lifetime, NULL);
+	new_ip = lua_tolstring(L, 1, &len);
+	if (len < 20 && len)
+	{
+		memset(server_ip, 0, 20);
+		memcpy(server_ip, new_ip, len);
+		new_set = 1;
+	}
+	if (lua_isinteger(L, 2))
+	{
+		port = lua_tointeger(L, 2);
+		new_set = 1;
+	}
+	if (lua_isinteger(L, 3))
+	{
+		lifetime = lua_tointeger(L, 3);
+		new_set = 1;
+	}
+	if (new_set)
+	{
+		result = luat_ctiot_set_para(server_ip, port, lifetime, NULL);
+	}
+	lua_pushstring(L, server_ip);
+	lua_pushinteger(L, port);
+	lua_pushinteger(L, lifetime);
+	return 3;
+}
+
+/**
+设置和读取自定义EP
+@api ctiot.ep(val)
+@string 自定义EP的值,默认是imei,读取的话不要填这个参数
+@return string 当前EP值
+ */
+static int l_ctiot_ep(lua_State *L)
+{
+	char userEp[40];
+	const char *new_ep;
+	size_t len;
+	uint8_t new_set = 0;
+	luat_ctiot_get_ep(userEp);
+	new_ep = lua_tolstring(L, 1, &len);
+	if (len < 40 && len)
+	{
+		memset(userEp, 0, 40);
+		memcpy(userEp, new_ep, len);
+		new_set = 1;
+	}
+	if (new_set)
+	{
+		luat_ctiot_set_ep(userEp);
+		luat_ctiot_get_ep(userEp);
+	}
+	lua_pushstring(L, userEp);
+	return 1;
+}
+
+// /**
+//设置和读取ctiot相关模式，有模式输入则设置，无论是否有模式输入，均输出当前模式
+//@api ctiot.mode()
+//@return nil 当前无返回值
+//  */
+static int l_ctiot_mode(lua_State *L)
+{
+	return 0;
+}
+
+/**
+连接CTIOT，必须在设置完参数和模式后再使用
+@api ctiot.connect()
+@return boolean 成功返回true,否则返回false
+ */
+static int l_ctiot_connect(lua_State *L)
+{
+	if (luat_ctiot_reg())
+	{
+		lua_pushboolean(L, 0);
+	}
+	else
+	{
+		lua_pushboolean(L, 1);
+	}
+	return 1;
+}
+
+/**
+断开ctiot
+@api ctiot.disconnect()
+@return nil 无返回值
+ */
+static int l_ctiot_disconnect(lua_State *L)
+{
+	luat_ctiot_dereg();
+	return 0;
+}
+
+/**
+发送数据给ctiot
+@api ctiot.write(data, mode, seq)
+@string 需要发送的数据
+@int 模式, ctiot.CON/NON/NON_REL/CON_REL
+@int 序号
+@return boolean 成功返回true,否则返回false
+@return string 成功为nil,失败返回错误描述
+ */
+static int l_ctiot_write(lua_State *L)
+{
+	const char *data;
+	uint8_t mode = 0;
+	uint8_t seq = 0;
+	size_t len = 0;
+	data = lua_tolstring(L, 1, &len);
+	if (!len)
+	{
+		lua_pushboolean(L, 0);
+		lua_pushstring(L, "no data");
+		return 2;
+	}
+	if (lua_isinteger(L, 2))
+	{
+		mode = lua_tointeger(L, 2);
+	}
+	if (lua_isinteger(L, 3))
+	{
+		seq = lua_tointeger(L, 3);
+	}
+	if (mode >= 4)
+	{
+		lua_pushboolean(L, 0);
+		lua_pushstring(L, "mode error");
+		return 2;
+	}
+	uint16_t result = luat_ctiot_send(data, len, mode, seq);
+	if (result)
+	{
+		lua_pushboolean(L, 0);
+		lua_pushfstring(L, "error code %d", result);
+	}
+	else
+	{
+		lua_pushboolean(L, 1);
+		lua_pushnil(L);
+	}
+	return 2;
+}
+
+// /**
+//读取已经接收到的数据
+//@api ctiot.read()
+//@return nil 暂无返回值
+//  */
+static int l_ctiot_read(lua_State *L)
+{
+	return 0;
+}
+
+/**
+是否已经就绪
+@api ctiot.ready()
+@return int 已经就绪返回0,否则返回错误代码
+ */
+static int l_ctiot_ready(lua_State *L)
+{
+	uint16_t result = luat_ctiot_check_ready();
+	lua_pushinteger(L, result);
+	return 1;
+}
+ /**
+发送更新注册信息给ctiot
+@api ctio.update()
+@return boolean 发送成功等待结果返回true,否则返回false
+  */
+static int l_ctiot_update(lua_State *L)
+{
+	uint16_t msgId;
+	if (luat_ctiot_update_reg(&msgId, NULL))
+	{
+		lua_pushboolean(L, 0);
+	}
+	else
+	{
+		lua_pushboolean(L, 1);
+	}
+	return 1;
+}
+#endif
+
+
+#include "rotable2.h"
+static const rotable_Reg_t reg_ctiot[] =
+{
+#ifdef AIR302
+    { "init", ROREG_FUNC(l_ctiot_init)},
+    { "param", ROREG_FUNC(l_ctiot_param)},
+	{ "ep", ROREG_FUNC(l_ctiot_ep)},
+	{ "isReady", ROREG_FUNC(l_ctiot_ready)},
+//	{ "mode", ROREG_FUNC(l_ctiot_mode)},
+	{ "connect", ROREG_FUNC(l_ctiot_connect)},
+	{ "disconnect", ROREG_FUNC(l_ctiot_disconnect)},
+	{ "write", ROREG_FUNC(l_ctiot_write)},
+//	{ "read", ROREG_FUNC(l_ctiot_read)},
+	{ "update", ROREG_FUNC(l_ctiot_update)},
+    // ----- 类型常量
+    //@const CON number CON
+	{ "CON", ROREG_INT(0)},
+    //@const NON number NON
+	{ "NON", ROREG_INT(1)},
+    //@const NON_REL number NON_REL
+	{ "NON_REL", ROREG_INT(2)},
+    //@const CON_REL number CON_REL
+	{ "CON_REL", ROREG_INT(3)},
+#endif
+	{ NULL, ROREG_INT(0) }
+};
+
+LUAMOD_API int luaopen_ctiot( lua_State *L ) {
+    luat_newlib2(L, reg_ctiot);
+    return 1;
+}

components/network/libftp/luat_ftp.h

@@ -40,22 +40,25 @@
 #define FTP_USERNAME_OK			"331" //User name okay, need password.
 #define FTP_DATA_CON_FAIL		"425" //Can't open data connection.
 
-enum
-{
+typedef enum{
+	FTP_ERROR 			,
+	FTP_SUCCESS_NO_DATE ,
+	FTP_SUCCESS_DATE 	,
+}FTP_SUCCESS_STATE_e;
+
+enum{
 	FTP_COMMAND_SYST = 1,
 	FTP_COMMAND_PULL 	,
 	FTP_COMMAND_PUSH 	,
 	FTP_COMMAND_CLOSE 	,
 };
 
-enum
-{
-	FTP_REQ_LOGIN = 1,
+enum{
+	FTP_REQ_LOGIN = 1	,
 	FTP_REQ_COMMAND 	,
 	FTP_REQ_PULL 		,
 	FTP_REQ_PUSH 		,
-	FTP_REQ_CLOSE 	,
-
+	FTP_REQ_CLOSE 		,
 
 	FTP_EVENT_LOGIN = USER_EVENT_ID_START + FTP_REQ_LOGIN,
 	FTP_EVENT_COMMAND 	,
@@ -86,10 +89,10 @@ typedef struct{
 	uint8_t adapter_index;
 	uint8_t data_netc_online;
 	uint8_t data_netc_connecting;
+	void* ftp_cb;			/**< mqtt 回调函数*/
 }luat_ftp_network_t;
 
 typedef struct{
-	uint64_t idp;
 	luat_rtos_task_handle task_handle;
 	luat_ftp_network_t *network;
 	FILE* fd;					//下载 FILE
@@ -104,11 +107,11 @@ typedef struct{
 	char *client_password;
 }luat_ftp_tls_t;
 
-
+typedef void (*luat_ftp_cb_t)(luat_ftp_ctrl_t *luat_ftp_ctrl, FTP_SUCCESS_STATE_e event);
 
 uint32_t luat_ftp_release(void);
 int luat_ftp_close(void);
-int luat_ftp_login(uint8_t adapter,const char * ip_addr,uint16_t port,const char * username,const char * password,luat_ftp_tls_t* luat_ftp_tls);
+int luat_ftp_login(uint8_t adapter,const char * ip_addr,uint16_t port,const char * username,const char * password,luat_ftp_tls_t* luat_ftp_tls,luat_ftp_cb_t ftp_cb);
 int luat_ftp_command(const char * command);
 int luat_ftp_pull(const char * local_name,const char * remote_name);
 int luat_ftp_push(const char * local_name,const char * remote_name);

components/network/libftp/luat_ftp_client.c

@@ -11,7 +11,6 @@
 
 #include "luat_network_adapter.h"
 #include "luat_rtos.h"
-#include "luat_msgbus.h"
 #include "luat_fs.h"
 #include "luat_malloc.h"
 
@@ -31,10 +30,7 @@ luat_ftp_ctrl_t g_s_ftp;
 uint32_t luat_ftp_release(void) {
 	if (!g_s_ftp.network) return 0;
 	if (g_s_ftp.network->cmd_netc){
-		if (network_close(g_s_ftp.network->cmd_netc,FTP_SOCKET_TIMEOUT) < 0)
-		{
-			network_force_close_socket(g_s_ftp.network->cmd_netc);
-		}
+		network_force_close_socket(g_s_ftp.network->cmd_netc);
 		network_release_ctrl(g_s_ftp.network->cmd_netc);
 		g_s_ftp.network->cmd_netc = NULL;
 	}
@@ -98,34 +94,6 @@ next:
 	return 0;
 }
 
-static int32_t l_ftp_callback(lua_State *L, void* ptr){
-    rtos_msg_t* msg = (rtos_msg_t*)lua_topointer(L, -1);
-	LLOGD("l_ftp_callback arg1:%d arg2:%d idp:%lld",msg->arg1,msg->arg2,g_s_ftp.idp);
-	if (g_s_ftp.idp)
-	{
-		if (msg->arg1)
-		{
-			lua_pushboolean(L, 0);
-		}
-		else if (msg->arg2)
-		{
-			lua_pushlstring(L,(const char *)(g_s_ftp.result_buffer.Data),g_s_ftp.result_buffer.Pos);
-		}
-		else
-		{
-			lua_pushboolean(L, 1);
-		}
-		luat_cbcwait(L, g_s_ftp.idp, 1);
-		g_s_ftp.idp = 0;
-	}
-	OS_DeInitBuffer(&g_s_ftp.result_buffer);
-	if (g_s_ftp.fd){
-		luat_fs_fclose(g_s_ftp.fd);
-		g_s_ftp.fd = NULL;
-	}
-	return 0;
-}
-
 static int32_t luat_ftp_data_callback(void *data, void *param){
 	OS_EVENT *event = (OS_EVENT *)data;
 	uint8_t *rx_buffer;
@@ -412,51 +380,48 @@ static int ftp_login(void)
 	return 0;
 }
 
+static void l_ftp_cb(FTP_SUCCESS_STATE_e state){
+	if (g_s_ftp.network->ftp_cb){
+		luat_ftp_cb_t ftp_cb = g_s_ftp.network->ftp_cb;
+		ftp_cb(&g_s_ftp,state);
+	}
+	OS_DeInitBuffer(&g_s_ftp.result_buffer);
+}
+
 static void ftp_task(void *param){
+	FTP_SUCCESS_STATE_e ftp_state = FTP_SUCCESS_NO_DATE;
 	int ret;
 	int count = 0;
 	luat_rtos_task_handle task_handle = g_s_ftp.task_handle;
 	OS_EVENT task_event;
-	rtos_msg_t msg = {0};
 	uint8_t is_timeout = 0;
 	g_s_ftp.is_run = 1;
-    msg.handler = l_ftp_callback;
 	luat_rtos_event_recv(g_s_ftp.task_handle, FTP_EVENT_LOGIN, &task_event, NULL, LUAT_WAIT_FOREVER);
-	if (ftp_login())
-	{
+	if (ftp_login()){
 		LLOGE("ftp login fail");
 		luat_ftp_release();
-		msg.arg1 = 1;
-		luat_msgbus_put(&msg, 0);
+		ftp_state = FTP_ERROR;
+		l_ftp_cb(ftp_state);
 		g_s_ftp.task_handle = NULL;
 		luat_rtos_task_delete(task_handle);
 		return;
-	}
-	else
-	{
-		msg.arg1 = 0;
-		msg.arg2 = 0;
-		luat_msgbus_put(&msg, 0);
+	}else{
+		l_ftp_cb(ftp_state);
 	}
     while (g_s_ftp.is_run) {
     	is_timeout = 0;
     	ret = network_wait_event(g_s_ftp.network->cmd_netc, &task_event, 3600000, &is_timeout);
-    	if (ret < 0)
-    	{
-    		LLOGE("ftp network error");
+    	if (ret < 0){    		
+			LLOGE("ftp network error");
     		goto wait_event_and_out;
-    	}
-    	else if (is_timeout || !task_event.ID)
-    	{
-        	if (g_s_ftp.network->cmd_netc->new_rx_flag)
-        	{
+    	}else if (is_timeout || !task_event.ID){
+        	if (g_s_ftp.network->cmd_netc->new_rx_flag){
         		network_rx(g_s_ftp.network->cmd_netc, g_s_ftp.network->cmd_recv_data, 1024, 0, NULL, NULL, &ret);
         		LLOGD("ftp rx %dbyte", ret);
         	}
     		continue;
     	}
-    	msg.arg1 = 0;
-    	msg.arg2 = 0;
+    	ftp_state = FTP_SUCCESS_NO_DATE;
 		switch (task_event.ID)
 		{
 		case FTP_EVENT_LOGIN:
@@ -495,7 +460,7 @@ static void ftp_task(void *param){
 						luat_fs_fclose(g_s_ftp.fd);
 						g_s_ftp.fd = NULL;
 					}
-					luat_msgbus_put(&msg, 0);
+					l_ftp_cb(ftp_state);
 					break;
 				}
 			}
@@ -516,7 +481,7 @@ static void ftp_task(void *param){
 				luat_fs_fclose(g_s_ftp.fd);
 				g_s_ftp.fd = NULL;
 			}
-			luat_msgbus_put(&msg, 0);
+			l_ftp_cb(ftp_state);
 			break;
 		case FTP_EVENT_PUSH:
 			if(luat_ftp_pasv_connect(&g_s_ftp,FTP_SOCKET_TIMEOUT)){
@@ -570,7 +535,7 @@ static void ftp_task(void *param){
 				luat_fs_fclose(g_s_ftp.fd);
 				g_s_ftp.fd = NULL;
 			}
-			luat_msgbus_put(&msg, 0);
+			l_ftp_cb(ftp_state);
 			break;
 		case FTP_EVENT_CLOSE:
 			g_s_ftp.is_run = 0;
@@ -600,8 +565,8 @@ static void ftp_task(void *param){
 					if (strstr((const char *)(g_s_ftp.network->cmd_recv_data), FTP_CLOSE_CONNECT))
 					{
 						LLOGD("ftp LIST ok!");
-						msg.arg2 = 1;
-						luat_msgbus_put(&msg, 0);
+						ftp_state = FTP_SUCCESS_DATE;
+						l_ftp_cb(ftp_state);
 						break;
 					}
 				}
@@ -614,8 +579,8 @@ static void ftp_task(void *param){
 						goto operation_failed;
 					}
 				}
-				msg.arg2 = 1;
-				luat_msgbus_put(&msg, 0);
+				ftp_state = FTP_SUCCESS_DATE;
+				l_ftp_cb(ftp_state);
 				break;
 			}
 			luat_ftp_cmd_send(&g_s_ftp, g_s_ftp.network->cmd_send_data, strlen((const char *)(g_s_ftp.network->cmd_send_data)),FTP_SOCKET_TIMEOUT);
@@ -666,34 +631,32 @@ static void ftp_task(void *param){
 				}
 			}
 			OS_BufferWrite(&g_s_ftp.result_buffer, g_s_ftp.network->cmd_recv_data, g_s_ftp.network->cmd_recv_len);
-			msg.arg2 = 1;
-			luat_msgbus_put(&msg, 0);
+			ftp_state = FTP_SUCCESS_DATE;
+			l_ftp_cb(ftp_state);
 			break;
 		default:
 			break;
 		}
 		continue;
 operation_failed:
-		msg.arg1 = 1;
-		luat_msgbus_put(&msg, 0);
+		ftp_state = FTP_ERROR;
+		l_ftp_cb(ftp_state);
 	}
-
-	msg.arg1 = 0;
-	msg.arg2 = 0;
+	ftp_state = FTP_SUCCESS_NO_DATE;
 	luat_ftp_cmd_send(&g_s_ftp, (uint8_t*)"QUIT\r\n", strlen("QUIT\r\n"),FTP_SOCKET_TIMEOUT);
 	ret = luat_ftp_cmd_recv(&g_s_ftp,g_s_ftp.network->cmd_recv_data,&g_s_ftp.network->cmd_recv_len,FTP_SOCKET_TIMEOUT);
 	if (ret){
-		msg.arg1 = 1;
+		ftp_state = FTP_ERROR;
 	}else{
 		if (memcmp(g_s_ftp.network->cmd_recv_data, FTP_CLOSE_CONTROL, 3)){
 			LLOGE("ftp QUIT wrong");
-			msg.arg1 = 1;
+			ftp_state = FTP_ERROR;
 		}
 	}
 	OS_BufferWrite(&g_s_ftp.result_buffer, g_s_ftp.network->cmd_recv_data, g_s_ftp.network->cmd_recv_len);
-	msg.arg2 = 1;
+	if (ftp_state == FTP_SUCCESS_NO_DATE) ftp_state = FTP_SUCCESS_DATE;
+	l_ftp_cb(ftp_state);
 	luat_ftp_release();
-	luat_msgbus_put(&msg, 0);
 	g_s_ftp.task_handle = NULL;
 	luat_rtos_task_delete(task_handle);
 	return;
@@ -704,8 +667,8 @@ wait_event_and_out:
 		if (task_event.ID >= FTP_EVENT_LOGIN && task_event.ID <= FTP_EVENT_CLOSE)
 		{
 			luat_ftp_release();
-			msg.arg1 = 1;
-			luat_msgbus_put(&msg, 0);
+			ftp_state = FTP_ERROR;
+			l_ftp_cb(ftp_state);
 			g_s_ftp.task_handle = NULL;
 			luat_rtos_task_delete(task_handle);
 			return;
@@ -714,7 +677,7 @@ wait_event_and_out:
 }
 
 
-int luat_ftp_login(uint8_t adapter,const char * ip_addr,uint16_t port,const char * username,const char * password,luat_ftp_tls_t* luat_ftp_tls){
+int luat_ftp_login(uint8_t adapter,const char * ip_addr,uint16_t port,const char * username,const char * password,luat_ftp_tls_t* luat_ftp_tls,luat_ftp_cb_t ftp_cb){
 	if (g_s_ftp.network){
 		LLOGE("ftp already login, please close first");
 		return FTP_ERROR_STATE;
@@ -725,6 +688,9 @@ int luat_ftp_login(uint8_t adapter,const char * ip_addr,uint16_t port,const char
 		return FTP_ERROR_NO_MEM;
 	}
 	memset(g_s_ftp.network, 0, sizeof(luat_ftp_network_t));
+	if (ftp_cb){
+		g_s_ftp.network->ftp_cb = ftp_cb;
+	}
 	g_s_ftp.network->adapter_index = adapter;
 	if (g_s_ftp.network->adapter_index >= NW_ADAPTER_QTY){
 		LLOGE("bad network adapter index %d", g_s_ftp.network->adapter_index);
@@ -801,7 +767,7 @@ int luat_ftp_command(const char * command){
 	}
 	memset(g_s_ftp.network->cmd_send_data,0,FTP_CMD_SEND_MAX);
 	snprintf_((char *)(g_s_ftp.network->cmd_send_data), FTP_CMD_SEND_MAX, "%s\r\n",command);
-	luat_rtos_event_send(g_s_ftp.task_handle, FTP_EVENT_COMMAND, (uint32_t)g_s_ftp.idp, (uint32_t)(g_s_ftp.idp >> 32), 0, LUAT_WAIT_FOREVER);
+	luat_rtos_event_send(g_s_ftp.task_handle, FTP_EVENT_COMMAND, 0, 0, 0, 0);
 	return 0;
 }
 

components/network/libftp/luat_lib_ftp.c

@@ -10,13 +10,41 @@
 #include "luat_base.h"
 
 #include "luat_network_adapter.h"
+#include "luat_msgbus.h"
 #include "luat_malloc.h"
 #include "luat_ftp.h"
 
 #define LUAT_LOG_TAG "ftp"
 #include "luat_log.h"
 
-extern luat_ftp_ctrl_t g_s_ftp;
+static uint64_t ftp_idp = 0;
+
+static int32_t l_ftp_callback(lua_State *L, void* ptr){
+    rtos_msg_t* msg = (rtos_msg_t*)lua_topointer(L, -1);
+	luat_ftp_ctrl_t *luat_ftp_ctrl = (luat_ftp_ctrl_t *)msg->ptr;
+	// LLOGD("l_ftp_callback arg1:%d arg2:%d idp:%lld",msg->arg1,msg->arg2,ftp_idp);
+	if (ftp_idp){
+		if (msg->arg1 == FTP_ERROR){
+			lua_pushboolean(L, 0);
+		}else if (msg->arg1 == FTP_SUCCESS_DATE){
+			lua_pushlstring(L,(const char *)(luat_ftp_ctrl->result_buffer.Data),luat_ftp_ctrl->result_buffer.Pos);
+		}else{
+			lua_pushboolean(L, 1);
+		}
+		luat_cbcwait(L, ftp_idp, 1);
+		ftp_idp = 0;
+	}
+	return 0;
+}
+
+
+static void luat_ftp_cb(luat_ftp_ctrl_t *luat_ftp_ctrl, FTP_SUCCESS_STATE_e event){
+	rtos_msg_t msg = {0};
+	msg.handler = l_ftp_callback;
+	msg.ptr = luat_ftp_ctrl;
+	msg.arg1 = event;
+	luat_msgbus_put(&msg, 0);
+}
 
 /*
 FTP客户端
@@ -91,13 +119,13 @@ static int l_ftp_login(lua_State *L) {
 		}
 	}
 	
-	if (0!=(result = luat_ftp_login(adapter,ip_addr,port,username,password,luat_ftp_tls))){
+	if (0!=(result = luat_ftp_login(adapter,ip_addr,port,username,password,luat_ftp_tls,luat_ftp_cb))){
 		LLOGE("ftp login fail");
 		luat_ftp_release();
 		lua_pushinteger(L,result);
 		luat_pushcwait_error(L,1);
 	}else{
-		g_s_ftp.idp = luat_pushcwait(L);
+		ftp_idp = luat_pushcwait(L);
 	}
 	if (luat_ftp_tls){
 		luat_heap_free(luat_ftp_tls);
@@ -129,7 +157,7 @@ static int l_ftp_command(lua_State *L) {
 		lua_pushinteger(L,FTP_ERROR_FILE);
 		luat_pushcwait_error(L,1);
 	}else{
-		g_s_ftp.idp = luat_pushcwait(L);
+		ftp_idp = luat_pushcwait(L);
 	}
 	return 1;
 }
@@ -152,7 +180,7 @@ static int l_ftp_pull(lua_State *L) {
 		lua_pushinteger(L,FTP_ERROR_FILE);
 		luat_pushcwait_error(L,1);
 	}else{
-		g_s_ftp.idp = luat_pushcwait(L);
+		ftp_idp = luat_pushcwait(L);
 	}
 	return 1;
 }
@@ -176,7 +204,7 @@ static int l_ftp_push(lua_State *L) {
 		lua_pushinteger(L,FTP_ERROR_CONNECT);
 		luat_pushcwait_error(L,1);
 	}else{
-		g_s_ftp.idp = luat_pushcwait(L);
+		ftp_idp = luat_pushcwait(L);
 	}
 	return 1;
 }
@@ -193,7 +221,7 @@ static int l_ftp_close(lua_State *L) {
 		lua_pushinteger(L,FTP_ERROR_CONNECT);
 		luat_pushcwait_error(L,1);
 	}else{
-		g_s_ftp.idp = luat_pushcwait(L);
+		ftp_idp = luat_pushcwait(L);
 	}
 	return 1;
 }

components/rtos/freertos/luat_common_freertos.c

@@ -1,20 +1,25 @@
-#include "luat_base.h"
-#include "luat_rtos.h"
-#include "luat_mcu.h"
-#include "luat_malloc.h"
-#include "common.h"
-#include "c_common.h"
 
-#if (defined(CONFIG_IDF_CMAKE))
+
+#ifdef LUAT_FREERTOS_FULL_INCLUDE
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/queue.h"
+#include "freertos/semphr.h"
+#include "freertos/timers.h"
 #else
 #include "FreeRTOS.h"
 #include "task.h"
 #include "queue.h"
+#include "semphr.h"
+#include "timers.h"
 #endif
 
+#include "luat_base.h"
+#include "luat_rtos.h"
+#include "luat_mcu.h"
+#include "luat_malloc.h"
+#include "c_common.h"
+
 #define LUAT_LOG_TAG "rtos"
 #include "luat_log.h"
 

components/rtos/freertos/luat_rtos_freertos_mutex.c

@@ -1,14 +1,22 @@
-#include "luat_base.h"
-#include "luat_rtos.h"
 
-#if (defined(CONFIG_IDF_CMAKE))
+
+#ifdef LUAT_FREERTOS_FULL_INCLUDE
 #include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
 #include "freertos/semphr.h"
+#include "freertos/timers.h"
 #else
 #include "FreeRTOS.h"
+#include "task.h"
+#include "queue.h"
 #include "semphr.h"
+#include "timers.h"
 #endif
 
+#include "luat_base.h"
+#include "luat_rtos.h"
+
 int luat_rtos_mutex_create(luat_rtos_mutex_t *mutex_handle)
 {
 	if (!mutex_handle) return -1;

components/rtos/freertos/luat_rtos_freertos_queue.c

@@ -1,14 +1,22 @@
-#include "luat_base.h"
-#include "luat_rtos.h"
 
-#if (defined(CONFIG_IDF_CMAKE))
+#ifdef LUAT_FREERTOS_FULL_INCLUDE
 #include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
 #include "freertos/queue.h"
+#include "freertos/semphr.h"
+#include "freertos/timers.h"
 #else
 #include "FreeRTOS.h"
+#include "task.h"
 #include "queue.h"
+#include "semphr.h"
+#include "timers.h"
 #endif
 
+#include "luat_base.h"
+#include "luat_rtos.h"
+
+
 int luat_rtos_queue_create(luat_rtos_queue_t *queue_handle, uint32_t item_count, uint32_t item_size)
 {
 	if (!queue_handle) return -1;

components/rtos/freertos/luat_rtos_freertos_semaphore.c

@@ -1,14 +1,22 @@
-#include "luat_base.h"
-#include "luat_rtos.h"
 
-#if (defined(CONFIG_IDF_CMAKE))
+#ifdef LUAT_FREERTOS_FULL_INCLUDE
 #include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
 #include "freertos/semphr.h"
+#include "freertos/timers.h"
 #else
 #include "FreeRTOS.h"
+#include "task.h"
+#include "queue.h"
 #include "semphr.h"
+#include "timers.h"
 #endif
 
+#include "luat_base.h"
+#include "luat_rtos.h"
+
+
 int luat_rtos_semaphore_create(luat_rtos_semaphore_t *semaphore_handle, uint32_t init_count)
 {
 	if (!semaphore_handle) return -1;

components/rtos/freertos/luat_rtos_freertos_task.c

@@ -1,17 +1,22 @@
-#include "luat_base.h"
-#include "luat_rtos.h"
-#include "common.h"
 
-#if (defined(CONFIG_IDF_CMAKE))
+#ifdef LUAT_FREERTOS_FULL_INCLUDE
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/queue.h"
+#include "freertos/semphr.h"
+#include "freertos/timers.h"
 #else
 #include "FreeRTOS.h"
 #include "task.h"
 #include "queue.h"
+#include "semphr.h"
+#include "timers.h"
 #endif
 
+
+#include "luat_base.h"
+#include "luat_rtos.h"
+
 typedef struct
 {
 	uint32_t ID;
@@ -134,7 +139,7 @@ int luat_rtos_event_send(luat_rtos_task_handle task_handle, uint32_t id, uint32_
 
 int luat_rtos_event_recv(luat_rtos_task_handle task_handle, uint32_t wait_event_id, luat_event_t *out_event, luat_rtos_event_wait_callback_t *callback_fun, uint32_t timeout){
 	if (!task_handle) return -1;
-	return get_event_from_task(task_handle, wait_event_id, (void *)out_event, callback_fun, timeout);
+	return get_event_from_task(task_handle, wait_event_id, (void *)out_event, (CBFuncEx_t)callback_fun, timeout);
 }
 
 int luat_send_event_to_task(void *task_handle, uint32_t id, uint32_t param1, uint32_t param2, uint32_t param3)
@@ -146,7 +151,7 @@ int luat_send_event_to_task(void *task_handle, uint32_t id, uint32_t param1, uin
 int luat_wait_event_from_task(void *task_handle, uint32_t wait_event_id, luat_event_t *out_event, void *call_back, uint32_t ms)
 {
 	if (!task_handle) return -1;
-	return get_event_from_task(task_handle, wait_event_id, (void *)out_event, call_back, ms);
+	return get_event_from_task(task_handle, wait_event_id, (void *)out_event, (CBFuncEx_t)call_back, ms);
 }
 
 /* ------------------------------------------------ critical begin----------------------------------------------- */

components/rtos/freertos/luat_rtos_freertos_timer.c

@@ -1,15 +1,22 @@
-#include "luat_base.h"
-#include "luat_rtos.h"
-#include "luat_malloc.h"
 
-#if (defined(CONFIG_IDF_CMAKE))
+#ifdef LUAT_FREERTOS_FULL_INCLUDE
 #include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
 #include "freertos/timers.h"
 #else
 #include "FreeRTOS.h"
+#include "task.h"
+#include "queue.h"
+#include "semphr.h"
 #include "timers.h"
 #endif
 
+#include "luat_base.h"
+#include "luat_rtos.h"
+#include "luat_malloc.h"
+
 typedef struct
 {
 	void *timer;

components/wlan/luat_lib_wlan.c

@@ -110,9 +110,10 @@ static int l_wlan_ready(lua_State* L){
 
 /*
 作为STATION时,连接到指定AP
-@api wlan.connect(ssid, password)
+@api wlan.connect(ssid, password, auto_reconnect)
 @string AP的ssid
 @string AP的password,可选
+@int    0关闭自动重连,1开启自动重连.当前强制开启自动重连
 @return bool 发起连接成功返回true,否则返回false.注意,不代表连接AP成功!!
 @usage
 

demo/jt808/JT808Prot.lua

@@ -44,7 +44,7 @@ end
 local function calCrc(d)
     local sum = 0
     for i=1,d:len() do
-        sum = sum^d:byte(i)
+        sum = sum~d:byte(i)
     end
     return sum
 end

demo/socket/EC618/async_socket_demo.lua

@@ -86,16 +86,13 @@ local function SSLTask()
 end
 
 function socketDemo()
-    mobile.rtime(1)
 	sys.taskInit(socketTask)
 end
 
 function UDPDemo()
-    mobile.rtime(1)
     sys.taskInit(UDPTask)
 end
 
 function SSLDemo()
-    mobile.rtime(1)
     sys.taskInit(SSLTask)
 end

demo/socket/EC618_W5500/async_socket_demo.lua

@@ -82,16 +82,13 @@ local function SSLTask()
 end
 
 function socketDemo()
-    mobile.rtime(1)
 	sys.taskInit(socketTask)
 end
 
 function UDPDemo()
-    mobile.rtime(1)
     sys.taskInit(UDPTask)
 end
 
 function SSLDemo()
-    mobile.rtime(1)
     sys.taskInit(SSLTask)
 end

demo/uart_wakeup/EC618/main.lua

@@ -60,7 +60,6 @@ sys.taskInit(function()
     end
 end)
 
-mobile.rtime(1)
 -- 用户代码已结束---------------------------------------------
 -- 结尾总是这一句
 sys.run()

luat/freertos/luat_msgbus_freertos.c

@@ -1,7 +1,7 @@
 #include "luat_base.h"
 #include "luat_msgbus.h"
 
-#if (defined(CONFIG_IDF_CMAKE))
+#ifdef LUAT_FREERTOS_FULL_INCLUDE
 #include "freertos/FreeRTOS.h"
 #include "freertos/queue.h"
 #else

luat/freertos/luat_timer_freertos.c

@@ -4,7 +4,7 @@
 #include "luat_timer.h"
 #include "luat_msgbus.h"
 
-#if (defined(CONFIG_IDF_CMAKE))
+#ifdef LUAT_FREERTOS_FULL_INCLUDE
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/timers.h"

luat/include/crc.h

@@ -17,5 +17,5 @@
 uint32_t calcCRC32(const uint8_t* buf, uint32_t len);
 uint8_t calcCRC8(const uint8_t *buf, uint32_t len);
 uint16_t calcCRC16(const uint8_t *data, const char *cmd, int length, uint16_t poly, uint16_t initial, uint16_t finally, BOOL bInReverse, BOOL bOutReverse);
-uint16_t calcCRC16_modbus(const uint8_t *data, uint32_t length);
+uint16_t calcCRC16_modbus(const uint8_t *data, uint32_t length, uint16_t crc_init);
 #endif

luat/modules/crc.c

@@ -98,10 +98,10 @@ static void InvertUint16(uint16_t *dBuf,uint16_t *srcBuf)
     }  
     dBuf[0] = tmp[0];  
 } 
-uint16_t calcCRC16_modbus(const uint8_t *data, uint32_t length)
+uint16_t calcCRC16_modbus(const uint8_t *data, uint32_t length, uint16_t crc_init)
 {
-    uint8_t crcHi = 0xFF;
-    uint8_t crcLo = 0xFF;
+    uint8_t crcHi = crc_init >> 8;
+    uint8_t crcLo = crc_init & 0xFF;
     uint8_t index;
     
     while(length--)

luat/modules/luat_lib_crypto.c

@@ -314,19 +314,23 @@ static int l_crypto_crc16(lua_State *L)
 
 /**
 直接计算modbus的crc16值
-@api crypto.crc16_modbus(data)
+@api crypto.crc16_modbus(data, start)
 @string 数据
+@int 初始化值,默认0xFFFF
 @return int 对应的CRC16值
 @usage
 -- 计算CRC16 modbus
 local crc = crypto.crc16_modbus(data)
+-- 2023.11.06 新增初始值设置
+crc = crypto.crc16_modbus(data, 0xFFFF)
  */
 static int l_crypto_crc16_modbus(lua_State *L)
 {
     size_t len = 0;
     const unsigned char *inputData = (const unsigned char*)luaL_checklstring(L, 1, &len);
+    uint16_t crc_init = luaL_optinteger(L, 2, 0xFFFF);
 
-    lua_pushinteger(L, calcCRC16_modbus(inputData, len));
+    lua_pushinteger(L, calcCRC16_modbus(inputData, len, crc_init));
     return 1;
 }
 

luat/modules/luat_lib_i2s.c

@@ -15,6 +15,9 @@
 #include "luat_malloc.h"
 #include "luat_i2s.h"
 #include "luat_zbuff.h"
+
+#ifdef LUAT_USE_I2S
+
 #include "c_common.h"
 #define LUAT_LOG_TAG "i2s"
 #include "luat_log.h"
@@ -305,3 +308,5 @@ LUAMOD_API int luaopen_i2s(lua_State *L)
     return 1;
 }
 
+#endif
+

luat/vfs/luat_fs_inline.c

@@ -8,7 +8,7 @@
 
 typedef struct luat_fs_inline
 {
-    char* ptr;
+    const char* ptr;
     uint32_t  size;
     uint32_t  offset;
 }luat_fs_inline_t;
@@ -25,7 +25,7 @@ extern const luadb_file_t luat_inline2_libs_source[];
 
 FILE* luat_vfs_inline_fopen(void* userdata, const char *filename, const char *mode) {
     //LLOGD("open inline %s", filename);
-    luadb_file_t* file = NULL;
+    const luadb_file_t* file = NULL;
 #ifdef LUAT_CONF_USE_LIBSYS_SOURCE
     file = luat_inline2_libs_source;
 #else
@@ -129,7 +129,7 @@ size_t luat_vfs_inline_fread(void* userdata, void *ptr, size_t size, size_t nmem
 }
 
 int luat_vfs_inline_fexist(void* userdata, const char *filename) {
-    luadb_file_t* file = NULL;
+    const luadb_file_t* file = NULL;
 #ifdef LUAT_CONF_VM_64bit
     #if defined(LUA_USE_LINUX) || (defined(LUA_USE_WINDOWS) && defined(__XMAKE_BUILD__))
     file = luat_inline2_libs_64bit_size64;

luat/weak/luat_log_weak.c

@@ -73,7 +73,7 @@ LUAT_WEAK void luat_log_log(int level, const char* tag, const char* _fmt, ...) {
             luat_log_write("D/", 2);
             break;
         }
-    luat_log_write(tag, strlen(tag));
+    luat_log_write((char*)tag, strlen(tag));
     luat_log_write(" ", 1);
 
     va_list args;

luat/weak/luat_rtos_legacy_to_std.c

@@ -29,7 +29,7 @@ LUAT_WEAK int luat_rtos_event_recv(luat_rtos_task_handle task_handle, uint32_t w
 LUAT_WEAK int luat_rtos_message_send(luat_rtos_task_handle task_handle, uint32_t message_id, void *p_message)
 {
 	if (!task_handle) return -1;
-	return luat_send_event_to_task(task_handle, message_id, p_message, 0, 0);
+	return luat_send_event_to_task(task_handle, message_id, (uint32_t)p_message, 0, 0);
 }
 LUAT_WEAK int luat_rtos_message_recv(luat_rtos_task_handle task_handle, uint32_t *message_id, void **p_p_message, uint32_t timeout)
 {

script/libs/pcf8563t.lua

@@ -93,13 +93,13 @@ function pcf8563t.read()
     if not data or #data ~= 7 then
         return time_data
     end
-    time_data.year  = bcd_to_hex(data:byte(7)) + baseyear
-    time_data.mon   = bcd_to_hex(bit.band(data:byte(6),0x7f))
-    time_data.wday  = bcd_to_hex(data:byte(5)) + 1
-    time_data.day   = bcd_to_hex(data:byte(4))
-    time_data.hour  = bcd_to_hex(data:byte(3))
-    time_data.min   = bcd_to_hex(data:byte(2))
-    time_data.sec   = bcd_to_hex(data:byte(1) & 0x7F)
+    time_data.year = bcd_to_hex(data:byte(7)) + baseyear
+    time_data.mon = bcd_to_hex(data:byte(6) & 0x9F)
+    time_data.wday = bcd_to_hex(data:byte(5) & 0x07) + 1
+    time_data.day = bcd_to_hex(data:byte(4) & 0x3F)
+    time_data.hour = bcd_to_hex(data:byte(3) & 0x3F)
+    time_data.min = bcd_to_hex(data:byte(2) & 0x7F)
+    time_data.sec = bcd_to_hex(data:byte(1) & 0x7F)
 	return time_data
 end