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

components/gmssl/bind/luat_lib_gmssl.c

@@ -82,7 +82,7 @@ sm2算法加密
 @string 公钥y,必选. HEX字符串
 @string 待计算的数据,必选,最长32字节, 非HEX字符串
 @boolean 输出模式,默认false. false-GMSSL默认格式DER, true-网站兼容模式
-@boolean 标准版本,默认false. false-C1C3C2新国际, true-C1C2C3老国际
+@boolean 标准版本,默认false. false-C1C3C2新国际, true-C1C2C3老国际. 仅"网站兼容模式"时有效
 @return string 加密后的字符串, 原样输出,未经HEX转换. 若加密失败会返回nil或空字符串
 @usage
 -- 提示 mode/mode2 参数是 2023.10.17 新增
@@ -674,6 +674,46 @@ static int l_sm2_verify(lua_State *L)
     return 1;
 }
 
+/*
+SM2密钥生成
+@api sm.sm2keygen()
+@return string 公钥X, HEX字符串
+@return string 公钥Y, HEX字符串
+@return string 私钥, HEX字符串
+@usage
+-- 本函数于2025.8.27新增
+-- 注意返回值是HEX字符串, 传递给sm2系列函数可以直接使用
+-- 如果传递给服务器, 按格式需要, 可能需要 fromHex 操作
+local pkx, pky, private = gmssl.sm2keygen()
+local originStr = "32wrniosadnfvnadsio;fasiow"
+local encodeStr = gmssl.sm2encrypt(pkx,pky,originStr)
+log.info("sm2默认模式", "加密后", encodeStr and  string.toHex(encodeStr))
+if encodeStr then
+    log.info("sm2默认模式", "解密后", gmssl.sm2decrypt(private,encodeStr))
+end
+
+-- 提醒, 生成的密钥对请妥善保管
+-- 一定要看 gmssl.sm2encrypt 的文档和demo
+*/
+static int l_sm2_keygen(lua_State *L)
+{
+    int ret = 0;
+    SM2_SIGN_CTX ctx = {0};
+    ret = sm2_key_generate(&ctx.key);
+    if (ret != 1) {
+        LLOGW("sm2_keygen %d", ret);
+        return 0;
+    }
+    char tmp[128] = {0};
+    luat_str_tohex((const char*)ctx.key.public_key.x, 32, tmp);
+    lua_pushlstring(L, tmp, 64);
+    luat_str_tohex((const char*)ctx.key.public_key.y, 32, tmp);
+    lua_pushlstring(L, tmp, 64);
+    luat_str_tohex((const char*)ctx.key.private_key, 32, tmp);
+    lua_pushlstring(L, tmp, 64);
+    return 3;
+}
+
 #include "rotable2.h"
 static const rotable_Reg_t reg_gmssl[] =
 {
@@ -686,6 +726,7 @@ static const rotable_Reg_t reg_gmssl[] =
     { "sm4decrypt",      ROREG_FUNC(l_sm4_decrypt)},
     { "sm2sign",         ROREG_FUNC(l_sm2_sign)},
     { "sm2verify",       ROREG_FUNC(l_sm2_verify)},
+    { "sm2keygen",       ROREG_FUNC(l_sm2_keygen)},
 
 	{ NULL,             ROREG_INT(0) }
 };

components/multimedia/luat_lib_multimedia_audio.c

@@ -423,7 +423,7 @@ static int l_audio_record_stop(lua_State *L) {
 /**
 往一个多媒体通道写入音频数据
 @api audio.write(id, data)
-@string or zbuff 音频数据
+@string/zbuff 音频数据
 @return boolean 成功返回true,否则返回false
 @usage
 audio.write(0, "xxxxxx")

components/multimedia/luat_multimedia_audio.c

@@ -136,6 +136,7 @@ LUAT_WEAK void luat_audio_config_dac(uint8_t multimedia_id, int pin, int level,
     luat_audio_conf_t* audio_conf = luat_audio_get_config(multimedia_id);
     if (audio_conf){
         if (pin != LUAT_GPIO_NONE){
+            luat_gpio_mode(pin, Luat_GPIO_OUTPUT, Luat_GPIO_DEFAULT, level);
             audio_conf->power_pin = pin;
             audio_conf->power_on_level = level;
             audio_conf->power_off_delay_time = dac_off_delay_time;

components/network/libftp/luat_ftp_client.c

@@ -540,12 +540,6 @@ static void ftp_task(void *param){
 					break;
 				luat_ftp_data_send(&g_s_ftp, buff, len);
 				offset += len;
-				// BK72xx平台, 内存使用量过大时, wifi会死, 这里加点sleep试试
-				#if defined(CONFIG_LUATOS)
-				if (offset % 32*1024 == 0) {
-					luat_rtos_task_sleep(200);
-				}
-				#endif
 			}
 			luat_heap_free(buff);
 			LLOGD("offset:%d file_size:%d",offset,g_s_ftp.network->local_file_size);

luat/demo/gmssl/main.lua

@@ -5,131 +5,18 @@ VERSION = "1.0.0"
 
 log.info("main", PROJECT, VERSION)
 
--- sys库是标配
-_G.sys = require("sys")
-
-if wdt then
-    --添加硬狗防止程序卡死，在支持的设备上启用这个功能
-    wdt.init(9000)--初始化watchdog设置为9s
-    sys.timerLoopStart(wdt.feed, 3000)--3s喂一次狗
-end
-
--- Air101/Air103默认80M主频, 跑国密算法会很慢的,调整到240M
-if mcu and (rtos.bsp() == "AIR101" or rtos.bsp() == "AIR103" or rtos.bsp() == "AIR601" ) then
-    mcu.setClk(240)
-end
 
 sys.taskInit(function()
-
-    sys.wait(1000)
-    log.info("gmssl", "start")
-    -- 未加密字符串
-    local originStr = "!!from LuatOS!!"
-
-    -- SM2 , 非对称加密, 类似于RSA,但属于椭圆算法
-    -- 就当前实现还是比较慢的
-    if gmssl.sm2encrypt then -- 部分BSP不支持
-        local pkx = "ABE87C924B7ECFDEA1748A06E89003C9F7F4DC5C3563873CE2CAE46F66DE8141"
-        local pky = "9514733D38CC026F2452A6A3A3A4DA0C28F864AFA5FE2C45E0EB6B761FBB5286"
-        local private = "129EDC282CD2E9C1144C2E7315F926D772BC96600D2771E8BE02060313FE00D5"
-
-        -- GMSSL默认格式
-        log.info("==== SM2 默认GMSSL模式")
-        local encodeStr = gmssl.sm2encrypt(pkx,pky,originStr)
-        log.info("sm2默认模式", "加密后", encodeStr and  string.toHex(encodeStr))
-        if encodeStr then
-            log.info("sm2默认模式", "解密后", gmssl.sm2decrypt(private,encodeStr))
-        end
-        
-
-        -- 网站兼容模式 https://i.goto327.top/CryptTools/SM2.aspx
-        -- 密文格式 C1C3C2, 新国标, 一般是这种
-        log.info("==== SM2 网站兼容模式")
-        local encodeStr = gmssl.sm2encrypt(pkx,pky,originStr, true)
-        log.info("sm2网站兼容模式 C1C3C2", "加密后", encodeStr and  string.toHex(encodeStr))
-        if encodeStr then
-            log.info("sm2网站兼容模式 C1C3C2", "解密后", gmssl.sm2decrypt(private,encodeStr, true))
-        else
-            log.info("解密失败")
-        end
-        -- 密文格式 C1C2C3, 老国标, 老的Java库通常支持这种
-        log.info("==== SM2 网站兼容模式, 但C1C2C3")
-        local encodeStr = gmssl.sm2encrypt(pkx,pky,originStr, true, true)
-        log.info("sm2网站兼容模式 C1C2C3", "加密后", encodeStr and  string.toHex(encodeStr))
-        if encodeStr then
-            log.info("sm2网站兼容模式 C1C2C3", "解密后", gmssl.sm2decrypt(private,encodeStr, true, true))
-        else
-            log.info("解密失败")
-        end
-    end
-
-    -- SM3 算法, hash类
-    if gmssl.sm3update then
-        log.info("=== SM3测试")
-        encodeStr = gmssl.sm3update("lqlq666lqlq946")
-        log.info("gmssl.sm3update",string.toHex(encodeStr))
-    end
-
-    if gmssl.sm4encrypt then
-        log.info("=== SM4测试")
-        local passwd = "1234567890123456"
-        local iv = "1234567890666666"
-        -- SM4 算法, 对称加密
-        originStr = ">>SM4 ECB ZeroPadding test<<"
-        --加密模式：ECB；填充方式：ZeroPadding；密钥：1234567890123456；密钥长度：128 bit
-        encodeStr = gmssl.sm4encrypt("ECB", "ZERO", originStr, passwd)
-        log.info("sm4.ecb.zero", "加密后", string.toHex(encodeStr))
-        log.info("sm4.ecb.zero", "解密后", gmssl.sm4decrypt("ECB","ZERO",encodeStr,passwd))
-
-        originStr = ">>SM4 ECB Pkcs5Padding test<<"
-        --加密模式：ECB；填充方式：Pkcs5Padding；密钥：1234567890123456；密钥长度：128 bit
-        encodeStr = gmssl.sm4encrypt("ECB", "PKCS5", originStr, passwd)
-        log.info("sm4.ecb.pks5", "加密后", string.toHex(encodeStr))
-        log.info("sm4.ecb.pks5", "解密后", gmssl.sm4decrypt("ECB","PKCS5",encodeStr,passwd))
-
-        originStr = ">>SM4 CBC Pkcs5Padding test<<"
-        --加密模式：CBC；填充方式：Pkcs5Padding；密钥：1234567890123456；密钥长度：128 bit；偏移量：1234567890666666
-        encodeStr = gmssl.sm4encrypt("CBC","PKCS5", originStr, passwd, iv)
-        log.info("sm4.cbc.pks5", "加密后", string.toHex(encodeStr))
-        log.info("sm4.cbc.pks5", "解密后", gmssl.sm4decrypt("CBC","PKCS5",encodeStr,passwd, iv))
-
-        -- 完全对齐16字节的对比测试
-        originStr = "1234567890123456"
-        encodeStr = gmssl.sm4encrypt("ECB","PKCS7",originStr,passwd)
-        log.info("sm4.ecb.pkcs7", encodeStr:toHex())
-        encodeStr = gmssl.sm4encrypt("ECB","PKCS5",originStr,passwd)
-        log.info("sm4.ecb.pkcs5", encodeStr:toHex())
-        encodeStr = gmssl.sm4encrypt("ECB","ZERO",originStr,passwd)
-        log.info("sm4.ecb.zero", encodeStr:toHex())
-        encodeStr = gmssl.sm4encrypt("ECB","NONE",originStr,passwd)
-        log.info("sm4.ecb.none", encodeStr:toHex())
-    end
-
-    -- SM2签名和验签
-    if gmssl.sm2sign then
-        local originStr = string.fromHex("434477813974bf58f94bcf760833c2b40f77a5fc360485b0b9ed1bd9682edb45")
-        local pkx = "ABE87C924B7ECFDEA1748A06E89003C9F7F4DC5C3563873CE2CAE46F66DE8141"
-        local pky = "9514733D38CC026F2452A6A3A3A4DA0C28F864AFA5FE2C45E0EB6B761FBB5286"
-        local private = "129EDC282CD2E9C1144C2E7315F926D772BC96600D2771E8BE02060313FE00D5"
-
-        -- 不带id的情况,即默认id="1234567812345678"
-        local sig = gmssl.sm2sign(private, originStr, nil)
-        log.info("sm2sign", sig and sig:toHex())
-        if sig then
-            local ret = gmssl.sm2verify(pkx, pky, originStr, nil, sig)
-            log.info("sm2verify", ret or "false")
-        end
-
-        -- 带id的情况
-        local id = "1234"
-        local sig = gmssl.sm2sign(private, originStr, id)
-        log.info("sm2sign", sig and sig:toHex())
-        if sig then
-            local ret = gmssl.sm2verify(pkx, pky, originStr, id, sig)
-            log.info("sm2verify", ret or "false")
-        end
-    end
-
+    -- 测试sm2算法, 含密钥生成
+    require "sm2test"
+    -- 测试sm3算法
+    require "sm3test"
+    -- 测试sm4算法
+    require "sm4test"
+    -- 测试sm2签名和验签
+    require "sm2sign"
+
+    log.info("=====================================")
     log.info("gmssl", "ALL Done")
 end)
 

luat/demo/gmssl/sm2sign.lua

@@ -0,0 +1,28 @@
+
+sys.taskInit(function()
+
+    -- SM2签名和验签
+    if gmssl.sm2sign then
+        local originStr = string.fromHex("434477813974bf58f94bcf760833c2b40f77a5fc360485b0b9ed1bd9682edb45")
+        local pkx = "ABE87C924B7ECFDEA1748A06E89003C9F7F4DC5C3563873CE2CAE46F66DE8141"
+        local pky = "9514733D38CC026F2452A6A3A3A4DA0C28F864AFA5FE2C45E0EB6B761FBB5286"
+        local private = "129EDC282CD2E9C1144C2E7315F926D772BC96600D2771E8BE02060313FE00D5"
+
+        -- 不带id的情况,即默认id="1234567812345678"
+        local sig = gmssl.sm2sign(private, originStr, nil)
+        log.info("sm2sign", sig and sig:toHex())
+        if sig then
+            local ret = gmssl.sm2verify(pkx, pky, originStr, nil, sig)
+            log.info("sm2verify", ret or "false")
+        end
+
+        -- 带id的情况
+        local id = "1234"
+        local sig = gmssl.sm2sign(private, originStr, id)
+        log.info("sm2sign", sig and sig:toHex())
+        if sig then
+            local ret = gmssl.sm2verify(pkx, pky, originStr, id, sig)
+            log.info("sm2verify", ret or "false")
+        end
+    end
+end)

luat/demo/gmssl/sm2test.lua

@@ -0,0 +1,55 @@
+
+function sm2test(originStr, pkx, pky, private)
+    -- GMSSL默认格式
+    log.info("==== SM2 默认GMSSL模式")
+    local encodeStr = gmssl.sm2encrypt(pkx,pky,originStr)
+    log.info("sm2默认模式", "加密后", encodeStr and  string.toHex(encodeStr))
+    if encodeStr then
+        log.info("sm2默认模式", "解密后", gmssl.sm2decrypt(private,encodeStr))
+    end
+    
+
+    -- 网站兼容模式 https://i.goto327.top/CryptTools/SM2.aspx
+    -- 密文格式 C1C3C2, 新国标, 一般是这种
+    log.info("==== SM2 网站兼容模式")
+    local encodeStr = gmssl.sm2encrypt(pkx,pky,originStr, true)
+    log.info("sm2网站兼容模式 C1C3C2", "加密后", encodeStr and  string.toHex(encodeStr))
+    if encodeStr then
+        log.info("sm2网站兼容模式 C1C3C2", "解密后", gmssl.sm2decrypt(private,encodeStr, true))
+    else
+        log.info("解密失败")
+    end
+    -- 密文格式 C1C2C3, 老国标, 老的Java库通常支持这种
+    log.info("==== SM2 网站兼容模式, 但C1C2C3")
+    local encodeStr = gmssl.sm2encrypt(pkx,pky,originStr, true, true)
+    log.info("sm2网站兼容模式 C1C2C3", "加密后", encodeStr and  string.toHex(encodeStr))
+    if encodeStr then
+        log.info("sm2网站兼容模式 C1C2C3", "解密后", gmssl.sm2decrypt(private,encodeStr, true, true))
+    else
+        log.info("解密失败")
+    end
+end
+
+sys.taskInit(function()
+    -- 未加密字符串
+    local originStr = "!!from LuatOS!!"
+
+    -- SM2 , 非对称加密, 类似于RSA,但属于椭圆算法
+    -- 就当前实现还是比较慢的
+    if gmssl.sm2encrypt then -- 部分BSP不支持
+        local pkx = "ABE87C924B7ECFDEA1748A06E89003C9F7F4DC5C3563873CE2CAE46F66DE8141"
+        local pky = "9514733D38CC026F2452A6A3A3A4DA0C28F864AFA5FE2C45E0EB6B761FBB5286"
+        local private = "129EDC282CD2E9C1144C2E7315F926D772BC96600D2771E8BE02060313FE00D5"
+        sm2test(originStr, pkx, pky, private)
+    end
+
+    -- SM密钥生成
+    if gmssl.sm2keygen then
+        log.info("SM2密钥生成测试")
+        originStr = "32wrniosadnfvnadsio;fasiow"
+        local pkx, pky, private = gmssl.sm2keygen()
+        sm2test(originStr, pkx, pky, private)
+    end
+
+end)
+

luat/demo/gmssl/sm3test.lua

@@ -0,0 +1,11 @@
+
+sys.taskInit(function()
+
+    -- SM3 算法, hash类
+    if gmssl.sm3update then
+        log.info("=== SM3测试")
+        encodeStr = gmssl.sm3update("lqlq666lqlq946")
+        log.info("gmssl.sm3update",string.toHex(encodeStr))
+    end
+end)
+

luat/demo/gmssl/sm4test.lua

@@ -0,0 +1,43 @@
+
+sys.taskInit(function()
+
+    if gmssl.sm4encrypt then
+        log.info("=== SM4测试")
+        local passwd = "1234567890123456"
+        local iv = "1234567890666666"
+        -- SM4 算法, 对称加密
+        originStr = ">>SM4 ECB ZeroPadding test<<"
+        --加密模式：ECB；填充方式：ZeroPadding；密钥：1234567890123456；密钥长度：128 bit
+        encodeStr = gmssl.sm4encrypt("ECB", "ZERO", originStr, passwd)
+        log.info("sm4.ecb.zero", "加密后", string.toHex(encodeStr))
+        log.info("sm4.ecb.zero", "解密后", gmssl.sm4decrypt("ECB","ZERO",encodeStr,passwd))
+
+        originStr = ">>SM4 ECB Pkcs5Padding test<<"
+        --加密模式：ECB；填充方式：Pkcs5Padding；密钥：1234567890123456；密钥长度：128 bit
+        encodeStr = gmssl.sm4encrypt("ECB", "PKCS5", originStr, passwd)
+        log.info("sm4.ecb.pks5", "加密后", string.toHex(encodeStr))
+        log.info("sm4.ecb.pks5", "解密后", gmssl.sm4decrypt("ECB","PKCS5",encodeStr,passwd))
+
+        originStr = ">>SM4 CBC Pkcs5Padding test<<"
+        --加密模式：CBC；填充方式：Pkcs5Padding；密钥：1234567890123456；密钥长度：128 bit；偏移量：1234567890666666
+        encodeStr = gmssl.sm4encrypt("CBC","PKCS5", originStr, passwd, iv)
+        log.info("sm4.cbc.pks5", "加密后", string.toHex(encodeStr))
+        log.info("sm4.cbc.pks5", "解密后", gmssl.sm4decrypt("CBC","PKCS5",encodeStr,passwd, iv))
+
+        -- 完全对齐16字节的对比测试
+        originStr = "1234567890123456"
+        encodeStr = gmssl.sm4encrypt("ECB","PKCS7",originStr,passwd)
+        log.info("sm4.ecb.pkcs7", encodeStr:toHex())
+        encodeStr = gmssl.sm4encrypt("ECB","PKCS5",originStr,passwd)
+        log.info("sm4.ecb.pkcs5", encodeStr:toHex())
+        encodeStr = gmssl.sm4encrypt("ECB","ZERO",originStr,passwd)
+        log.info("sm4.ecb.zero", encodeStr:toHex())
+        encodeStr = gmssl.sm4encrypt("ECB","NONE",originStr,passwd)
+        log.info("sm4.ecb.none", encodeStr:toHex())
+    end
+end)
+
+-- 用户代码已结束---------------------------------------------
+-- 结尾总是这一句
+sys.run()
+-- sys.run()之后后面不要加任何语句!!!!!

luat/vfs/luat_fs_inline.c

@@ -30,11 +30,7 @@ FILE* luat_vfs_inline_fopen(void* userdata, const char *filename, const char *mo
     file = luat_inline2_libs_source;
 #else
 #ifdef LUAT_CONF_VM_64bit
-    #if defined(LUA_USE_LINUX) || (defined(LUA_USE_WINDOWS) && defined(__XMAKE_BUILD__))
-    file = luat_inline2_libs_64bit_size64;
-    #else
     file = luat_inline2_libs_64bit_size32;
-    #endif
 #else
     file = luat_inline2_libs;
 #endif

module/Air6101/core/readme.md

@@ -0,0 +1 @@
+Air6101内核固件，待完善

module/Air6101/demo/zbuff/main.lua

@@ -0,0 +1,64 @@
+--[[
+@module  main
+@summary LuatOS用户应用脚本文件入口，总体调度应用逻辑
+@version 003.000.000
+@date    2025.08.08
+@author  王棚嶙
+@usage
+本 Demo 完整覆盖了 zbuff 的核心到高级操作，包括：
+​基础​：创建、读写、指针控制、元信息查询
+​进阶​：结构化数据打包/解包、类型化操作、浮点处理
+​内存管理​：动态调整、块操作、数据比对、Base64 编码
+适用于嵌入式开发中高效处理二进制数据流、协议解析、内存优化等场景。
+
+]]
+
+--[[
+必须定义PROJECT和VERSION变量，Luatools工具会用到这两个变量，远程升级功能也会用到这两个变量
+PROJECT：项目名，ascii string类型
+        可以随便定义，只要不使用,就行
+VERSION：项目版本号，ascii string类型
+        如果使用合宙iot.openluat.com进行远程升级，必须按照"XXX.YYY.ZZZ"三段格式定义：
+            X、Y、Z各表示1位数字，三个X表示的数字可以相同，也可以不同，同理三个Y和三个Z表示的数字也是可以相同，可以不同
+            因为历史原因，YYY这三位数字必须存在，但是没有任何用处，可以一直写为000
+        如果不使用合宙iot.openluat.com进行远程升级，根据自己项目的需求，自定义格式即可
+]]
+PROJECT = "zbuff"
+VERSION = "003.000.000"
+log.info("main", "项目启动", PROJECT, VERSION)
+
+
+
+-- 如果内核固件支持errDump功能，此处进行配置，【强烈建议打开此处的注释】
+-- 因为此功能模块可以记录并且上传脚本在运行过程中出现的语法错误或者其他自定义的错误信息，可以初步分析一些设备运行异常的问题
+-- 以下代码是最基本的用法，更复杂的用法可以详细阅读API说明文档
+-- 启动errDump日志存储并且上传功能，600秒上传一次
+--示例：
+-- if errDump then
+--     errDump.config(true, 600)
+-- end
+
+
+-- 使用LuatOS开发的任何一个项目，都强烈建议使用远程升级FOTA功能
+-- 可以使用合宙的iot.openluat.com平台进行远程升级
+-- 也可以使用客户自己搭建的平台进行远程升级
+-- 远程升级的详细用法，可以参考fota的demo进行使用
+
+
+-- 启动一个循环定时器
+-- 每隔3秒钟打印一次总内存，实时的已使用内存，历史最高的已使用内存情况
+-- 方便分析内存使用是否有异常
+--示例：
+-- sys.timerLoopStart(function()
+--     log.info("mem.lua", rtos.meminfo())
+--     log.info("mem.sys", rtos.meminfo("sys"))
+-- end, 3000)
+
+
+-- 加载zbuff应用功能模块
+require "zbuff_core"
+require "zbuff_advanced"
+require "zbuff_memory"
+
+-- 启动系统调度
+sys.run()

module/Air6101/demo/zbuff/readme.md

@@ -0,0 +1,172 @@
+## **功能模块介绍：**
+
+本demo进行了一个完整的 zbuff 二进制数据处理库 的演示，示了在嵌入式环境中高效处理二进制数据的全流程。项目分为三个核心模块，覆盖了从基础到高级的二进制数据处理场景：
+
+1、main.lua:主程序入口
+
+2、zbuff_core.lua：为zbuff的基础操作模块，包含zbuff最常用的创建，读写高效查询等基础功能。
+
+3、zbuff_advanced.lua：为zbuff高级操作模块，包含zbuff较为复杂的结构化打包，类型化操作等数据处理功能。
+
+4、zbuff_memory.lua：为内存管理模块，核心业务逻辑为内存管理操作。
+
+## 演示功能概述
+
+### 1、核心功能模块 (zbuff_core.lua)
+
+#### 缓冲区管理:
+
+（1）创建固定大小(1024字节)的缓冲区 zbuff.create
+
+（2）索引直接访问(如 buff[0] = 0xAE)
+
+#### 基础IO操作:
+
+（1）写入字符串和数值数据(write("123"))
+
+（2）指针控制(seek()定位操作)
+
+（3）数据读取(read(3))
+
+#### 元信息查询
+
+（1）获取缓冲区总长度(len())
+
+（2）查询已使用空间(used())
+
+#### 高效数据查询
+
+（1）query()接口快速提取数据
+
+（2）自动格式转换(大端序处理)
+
+### 2、高级功能模块 (zbuff_advanced.lua)
+
+#### 结构化数据处理
+
+（1）数据打包(pack(">IIHA", ...))：支持大端序/多种数据类型
+
+（2）数据解包(unpack(">IIHA10"))：自动解析复合数据结构
+
+#### 类型化操作
+
+（1）精确类型读写：writeI8()/readU32()等
+
+#### 浮点处理
+
+（1）单精度浮点写入(writeF32(1.2))
+
+（2）浮点数据读取(readF32())
+
+### 3、内存管理模块 (zbuff_memory.lua)
+
+#### 动态内存管理
+
+（1）缓冲区动态扩容resize(2048)
+
+#### 块操作
+
+（1）内存块设置(set(10,0xaa,5))类似 memset
+
+（2）数据删除(del(2,3))及前移
+
+#### 数据工具
+
+（1）内存比较(isEqual())
+
+（2）Base64编码转换(toBase64())
+
+## **演示硬件环境**
+
+1、Air8101_B11开发板一块/Air8101系列核心板一块
+
+2、TYPE-C USB数据线一根
+
+3、Air8101开发板和数据线的硬件接线方式为
+
+- Air8101开发板通过串口小板上的TYPE-C USB口供电。（USB旁边的开关拨到ON）
+- TYPE-C USB数据线直接插到Air8101开发板配套的外接串口小板的的TYPE-C USB座子，另外一端连接电脑USB口；
+
+4、如果是Air8101系列核心板，需要将正面拨到3.3V，背面拨码拨到off, 通过TYPE-C USB口供电，另外一端连接电脑USB口；
+
+## **演示软件环境**
+
+1、Luatools下载调试工具： https://docs.openluat.com/air780epm/common/Luatools/
+
+2、内核固件版本：https://docs.openluat.com/air8101/luatos/firmware/
+
+## **演示核心步骤**
+
+1、搭建好硬件环境
+
+2、通过Luatools将demo与内核固件烧录到核心板中
+
+3、烧录好后，板子开机将会在Luatools上看到如下打印：
+
+```Lua
+（1）开始打印项目信息正式开始展示。
+[2025-08-11 16:38:35.922][000000000.369] I/user.main 项目启动 zbuff 003.000.000
+[2025-08-11 16:38:35.932][000000000.379] I/user.zbuff_core 启动核心功能演示
+[2025-08-11 16:38:35.938][000000000.380] I/user.zbuff_core 缓冲区创建 长度: 1024
+
+
+（2）进行BUFF创建,初始化以及索引,读写,清除等基础功能演示操作
+[2025-08-11 16:38:35.950][000000000.380] I/user.zbuff_core === 缓冲区创建与初始化演示 ===
+[2025-08-11 16:38:35.955][000000000.380] I/user.zbuff_core 索引访问示例 buff[0] = 174
+
+[2025-08-11 16:38:35.965][000000000.381] I/user.zbuff_core === 基础IO操作演示 ===
+[2025-08-11 16:38:35.971][000000000.381] I/user.zbuff_core 写入字符串 123
+[2025-08-11 16:38:35.979][000000000.381] I/user.zbuff_core 写入数值 0x12, 0x13, 0x13, 0x33
+[2025-08-11 16:38:35.985][000000000.381] I/user.zbuff_core 指针当前位置 向后移动5字节 当前位置: 12
+[2025-08-11 16:38:35.991][000000000.382] I/user.zbuff_core 指针移动 重置到开头
+[2025-08-11 16:38:36.000][000000000.382] I/user.zbuff_core 读取数据 长度3: 123
+
+[2025-08-11 16:38:36.005][000000000.382] I/user.zbuff_core === 缓冲区清除操作 ===
+[2025-08-11 16:38:36.013][000000000.382] I/user.zbuff_core 清除操作 全部清零
+[2025-08-11 16:38:36.019][000000000.382] I/user.zbuff_core 清除操作 填充0xA5
+
+[2025-08-11 16:38:36.027][000000000.383] I/user.zbuff_core === 元信息查询 ===
+[2025-08-11 16:38:36.033][000000000.383] I/user.zbuff_core 元信息 总长度: 1024
+[2025-08-11 16:38:36.043][000000000.383] I/user.zbuff_core 元信息 已使用: 3
+
+[2025-08-11 16:38:36.048][000000000.383] I/user.zbuff_core === 高效数据查询 ===
+[2025-08-11 16:38:36.056][000000000.384] I/user.zbuff_core query查询 全部数据: 123456789ABC 12
+[2025-08-11 16:38:36.060][000000000.384] I/user.zbuff_core query查询 大端序格式: 305419896
+[2025-08-11 16:38:36.067][000000000.384] I/user.zbuff_core 核心功能演示完成
+
+
+（3）进行高级功能演示，包括数据打包与解包、类型化读写、浮点操作演示等。
+[2025-08-11 16:38:36.072][000000000.398] I/user.zbuff_advanced 启动高级功能演示
+
+[2025-08-11 16:38:36.078][000000000.398] I/user.zbuff_advanced === 数据打包与解包演示 ===
+[2025-08-11 16:38:36.088][000000000.399] I/user.zbuff_advanced 数据打包 格式: >IIHA 值: 0x1234, 0x4567, 0x12, 'abcdefg'
+[2025-08-11 16:38:36.092][000000000.399] I/user.zbuff_advanced 打包后数据 0000123400004567001261626364656667 34
+[2025-08-11 16:38:36.101][000000000.400] I/user.zbuff_advanced 数据解包 数量: 20 值: 4660 17767 18 abcdefg
+[2025-08-11 16:38:36.105][000000000.401] I/user.zbuff_advanced 解包输出内容 cnt: 20 a(32位): 0x1234 b(32位): 0x4567 c(16位): 0x12 s(字符串): abcdefg
+
+[2025-08-11 16:38:36.109][000000000.401] I/user.zbuff_advanced === 类型化读写演示 ===
+[2025-08-11 16:38:36.119][000000000.401] I/user.zbuff_advanced 类型化写入 I8: 10
+[2025-08-11 16:38:36.126][000000000.402] I/user.zbuff_advanced 类型化写入 U32: 1024
+[2025-08-11 16:38:36.135][000000000.402] I/user.zbuff_advanced 类型化读取 I8: 10
+[2025-08-11 16:38:36.140][000000000.402] I/user.zbuff_advanced 类型化读取 U32: 1024
+
+[2025-08-11 16:38:36.151][000000000.402] I/user.zbuff_advanced === 浮点数操作演示 ===
+[2025-08-11 16:38:36.156][000000000.403] I/user.zbuff_advanced 浮点数操作 写入F32: 1.200000
+[2025-08-11 16:38:36.165][000000000.403] I/user.zbuff_advanced 浮点数操作 读取F32: 1.200000
+[2025-08-11 16:38:36.171][000000000.403] I/user.zbuff_advanced 高级功能演示完成
+
+
+（4）内存管理演示:内存块设置(set(10,0xaa,5)),数据删除(del(2,3))及前移,内存比较,Base64编码转换等
+[2025-08-11 16:38:36.182][000000000.415] I/user.zbuff_memory 启动内存管理功能演示
+[2025-08-11 16:38:36.188][000000000.416] I/user.zbuff_memory 大小调整 原始大小: 1024 新大小: 2048
+[2025-08-11 16:38:36.198][000000000.417] I/user.zbuff_memory 内存设置 位置10-14设置为0xaa
+[2025-08-11 16:38:36.204][000000000.417] I/user.zbuff_memory 验证结果 位置10: 170 应为0xaa
+[2025-08-11 16:38:36.215][000000000.417] I/user.zbuff_memory 删除前数据 
+[2025-08-11 16:38:36.222][000000000.418] ABCDEFGH
+[2025-08-11 16:38:36.233][000000000.418] I/user.zbuff_memory 删除操作 删除位置2-4 结果: 
+[2025-08-11 16:38:36.244][000000000.418] ABFGH
+[2025-08-11 16:38:36.251][000000000.418] I/user.zbuff_memory 内存比较 结果: false 差异位置: 0
+[2025-08-11 16:38:36.258][000000000.419] I/user.zbuff_memory Base64编码 长度: 8 结果: QUJGR0g=
+[2025-08-11 16:38:36.264][000000000.419] I/user.zbuff_memory 内存管理功能演示完成
+```
+

module/Air6101/demo/zbuff/zbuff_advanced.lua

@@ -0,0 +1,100 @@
+--[[
+    @module  zbuff_advanced
+    @summary zbuff的高级操作模块
+    @version 1.0.0
+    @date    2025.08.08
+    @author  王棚嶙
+    @usage
+    本文件为本部分为zbuff高级操作模块，包含zbuff的复杂数据处理功能,包括：
+    1. 数据打包/解包
+    2. 类型化读写
+    3. 浮点数操作
+    本文件没有对外接口，直接在main.lua中require "zbuff_advanced"就可以加载运行
+    ]] --
+local function zbuff_advanced_task_func()
+    log.info("zbuff_advanced", "启动高级功能演示")
+
+    -- 创建1024字节的缓冲区
+    local buff = zbuff.create(1024)
+
+    -- === 数据打包与解包演示 ===
+    log.info("zbuff_advanced", "=== 数据打包与解包演示 ===")
+
+    -- 清空缓冲区
+    buff:clear()
+    -- 重置指针到开头
+    buff:seek(0)
+
+    -- 打包数据：大端序，2个32位整数，1个16位整数，1个字符串
+    buff:pack(">IIHA", 0x1234, 0x4567, 0x12, "abcdefg")
+    log.info("zbuff_advanced", "数据打包", "格式: >IIHA", "值: 0x1234, 0x4567, 0x12, 'abcdefg'")
+    -- 显示打包后的二进制内容
+    local packed = buff:toStr(0, buff:used()) -- 按照起始位置和长度，取出数据，并转换为字符串
+    log.info("zbuff_advanced", "打包后数据", packed:toHex())
+
+    -- 重置指针到开头
+    buff:seek(0)
+
+    -- 解包数据：大端序，2个32位整数，1个16位整数，1个10字节字符串
+    local cnt, a, b, c, s = buff:unpack(">IIHA10")
+    log.info("zbuff_advanced", "数据解包", "数量:", cnt, "值:", a, b, c, s)
+    -- 显示解包后的输出内容
+    -- string.forma是Lua的格式化字符串函数，按照格式化参数formatstring，返回后面...内容的格式化版本。string.format("0x%X", a)表示将整数a转换为十六进制字符串。
+    log.info("zbuff_advanced", "解包输出内容", "cnt:", cnt, "a(32位):", string.format("0x%X", a), "b(32位):",
+        string.format("0x%X", b), "c(16位):", string.format("0x%X", c), "s(字符串):", s)
+    -- === 类型化读写演示 ===
+    --[[
+    类型化读写演示
+    展示I8和U32两种类型操作
+    @param buff zbuff对象
+    --]]
+    log.info("zbuff_advanced", "=== 类型化读写演示 ===")
+
+    -- 重置指针到开头
+    buff:seek(0)
+
+    -- 写入8位有符号整数
+    buff:writeI8(10)
+    log.info("zbuff_advanced", "类型化写入", "I8:", 10)
+
+    -- 写入32位无符号整数
+    buff:writeU32(1024)
+    log.info("zbuff_advanced", "类型化写入", "U32:", 1024)
+
+    -- 重置指针到开头
+    buff:seek(0)
+
+    -- 读取8位有符号整数
+    local i8data = buff:readI8()
+    log.info("zbuff_advanced", "类型化读取", "I8:", i8data)
+
+    -- 读取32位无符号整数
+    local u32data = buff:readU32()
+    log.info("zbuff_advanced", "类型化读取", "U32:", u32data)
+
+    --[[
+    浮点数操作演示
+    @param buff zbuff对象
+    --]]
+    log.info("zbuff_advanced", "=== 浮点数操作演示 ===")
+    -- 重置指针到开头
+    buff:seek(0)
+
+    -- 写入32位浮点数
+    buff:writeF32(1.2)
+    log.info("zbuff_advanced", "浮点数操作", "写入F32:", 1.2)
+
+    -- 重置指针到开头
+    buff:seek(0)
+
+    -- 读取32位浮点数
+    local f32data = buff:readF32()
+    log.info("zbuff_advanced", "浮点数操作", "读取F32:", f32data)
+
+    -- 清空缓冲区
+    buff:clear()
+    -- 重置指针到开头
+    buff:seek(0)
+    log.info("zbuff_advanced", "高级功能演示完成")
+end
+sys.taskInit(zbuff_advanced_task_func)

module/Air6101/demo/zbuff/zbuff_core.lua

@@ -0,0 +1,89 @@
+ --[[
+    @module  zbuff_core
+    @summary zbuff的基础操作模块
+    @version 1.0.0
+    @date    2025.08.08
+    @author  王棚嶙
+    @usage
+    本文件为zbuff的基础操作模块，包含zbuff最常用的基础功能：
+
+    1. 缓冲区创建与初始化
+    2. 基础功能操作（读写）
+    3. 指针控制
+    4. 元信息查询
+    5. 高效数据查询（query接口）
+    本文件没有对外接口，直接在main.lua中require "zbuff_core"就可以加载运行
+    ]]
+    
+       
+local function zbuff_core_task_func()
+    log.info("zbuff_core", "启动核心功能演示")
+    
+    -- 创建1024字节的缓冲区
+    local buff = zbuff.create(1024)
+    log.info("zbuff_core", "缓冲区创建", "长度:", buff:len()) -- 打印缓冲区长度
+    -- === 缓冲区创建与初始化演示 ===
+    log.info("zbuff_core", "=== 缓冲区创建与初始化演示 ===")
+    buff[0] = 0xAE -- 通过索引直接访问和修改数据（索引从0开始）
+    log.info("zbuff_core", "索引访问示例", "buff[0] =", buff[0])
+
+
+    
+    -- === 基础读写操作演示 ===
+    log.info("zbuff_core", "=== 基础IO操作演示 ===")
+    --此处的读写操作只作为演示，具体的读取数据看后续的buff:query接口
+    --buff：write()中的参数可以是任意类型，zbuff会自动进行类型转换，写入buff的数据，string时为一个参数，number时可为多个参数
+
+    buff:write("123")
+    log.info("zbuff_core", "写入字符串", "123")
+    buff:write(0x12, 0x13, 0x13, 0x33)
+    log.info("zbuff_core", "写入数值", "0x12, 0x13, 0x13, 0x33")
+    
+    buff:seek(5, zbuff.SEEK_CUR)
+    log.info("zbuff_core", "指针当前位置", "向后移动5字节","当前位置:", buff:used())
+    
+    buff:seek(0)
+    log.info("zbuff_core", "指针移动", "重置到开头")
+    
+    local data = buff:read(3)
+    log.info("zbuff_core", "读取数据", "长度3:",data)
+   
+    
+
+    -- === 缓冲区清除操作 ===
+    log.info("zbuff_core", "=== 缓冲区清除操作 ===")
+    buff:clear()
+    log.info("zbuff_core", "清除操作", "全部清零")
+    
+    buff:clear(0xA5)
+    log.info("zbuff_core", "清除操作", "填充0xA5")
+    
+
+
+    -- === 元信息查询 ===
+    log.info("zbuff_core", "=== 元信息查询 ===")
+    local len = buff:len()
+    log.info("zbuff_core", "元信息", "总长度:", len)
+    
+    local used = buff:used()
+    log.info("zbuff_core", "元信息", "已使用:", used)
+    
+
+
+    -- === 高效数据查询 ===
+    log.info("zbuff_core", "=== 高效数据查询 ===")
+    buff:clear()
+    buff:seek(0)
+    buff:write(0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC)
+    
+    local all_data = buff:query(0, 6)
+    log.info("zbuff_core", "query查询", "全部数据:" ,all_data:toHex())
+     -- 查询部分数据并转换格式,查询1,2，4,8字节的时候会自动根据后续参数进行转换（大端序、无符号）
+    -- 参数：起始位置0，长度4，大端序，无符号，非浮点
+    local part_data = buff:query(0, 4, true, false, false)
+    log.info("zbuff_core", "query查询", "大端序格式:", part_data)
+    
+    log.info("zbuff_core", "核心功能演示完成")
+end
+
+sys.taskInit(zbuff_core_task_func)

module/Air6101/demo/zbuff/zbuff_memory.lua

@@ -0,0 +1,62 @@
+    --[[
+    @module  zbuff_memory
+    @summary zbuff的内存管理模块
+    @version 1.0.0
+    @date    2025.08.08
+    @author  王棚嶙
+    @usage
+    本文件为zbuff的内存管理模块，核心业务逻辑为内存管理操作,包括：
+    1.缓冲区大小调整 
+    2.内存块设置 
+    3.数据删除
+    4.内存比较 
+    5.Base64编码转换功能
+    本文件没有对外接口，直接在main.lua中require "zbuff_memory"就可以加载运行
+    ]]
+local function zbuff_memory_task_func()
+    --[[内存管理操作演示@param buff zbuff对象]]
+    log.info("zbuff_memory", "启动内存管理功能演示")
+
+
+    -- 1. 调整缓冲区大小
+    local buff = zbuff.create(1024)
+    local original_size = buff:len()
+    buff:resize(2048)  -- 扩容到2048字节
+    log.info("zbuff_memory", "大小调整", "原始大小:", original_size, "新大小:", buff:len())
+    
+    -- 2. 内存块设置（类似memset）
+    -- 从位置10开始设置5个字节为0xaa
+    buff:set(10,0xaa,5)
+    log.info("zbuff_memory", "内存设置", "位置10-14设置为0xaa")
+    -- 验证设置结果
+    log.info("zbuff_memory", "验证结果", "位置10:", buff[10], "应为0xaa")
+    
+    -- 3. 数据删除操作
+    -- 写入测试数据
+    buff:clear()
+    buff:seek(0)
+    buff:write("ABCDEFGH")
+    log.info("zbuff_memory", "删除前数据", buff:toStr())
+    
+    -- 删除位置2开始的3个字节
+    buff:del(2, 3)
+    log.info("zbuff_memory", "删除操作", "删除位置2-4", "结果:", buff:toStr())
+    
+    -- 4. 内存比较
+    local buff2 = zbuff.create(10)
+    buff2:write("12345")
+    
+    -- 比较两个缓冲区前5字节内容
+    local equal, offset = buff:isEqual(0, buff2, 0, 5)
+    log.info("zbuff_memory", "内存比较", "结果:", equal, "差异位置:", offset)
+    
+    -- 5. Base64编码转换
+    local dst = zbuff.create(buff:used() * 2)  -- 创建足够大的目标缓冲区
+    
+    -- 进行Base64编码
+    local len = buff:toBase64(dst)
+    log.info("zbuff_memory", "Base64编码", "长度:", len, "结果:", dst:toStr(0, len))
+
+    log.info("zbuff_memory", "内存管理功能演示完成")
+end
+sys.taskInit(zbuff_memory_task_func)

module/Air6101/demolib/readme.md

@@ -0,0 +1 @@
+待完善

module/Air780EPM/demo/fota2/self_server/psm_power_fota.lua

@@ -60,7 +60,7 @@ end
 
 -- 使用合宙iot平台进行升级, 支持自定义参数, 也可以不配置，如果要配置参数可以参考此链接https://docs.openluat.com/osapi/ext/libfota2/
 local opts = {
-    url = "###http://cdn.openluat-backend.openluat.com/upgrade_firmware/fotademo_2008.001.001_LuatOS-SoC_Air8000.bin_20250623184110381812",
+    url = "###http://cdn.openluat-backend.openluat.com/upgrade_firmware/fotademo_2008.001.001_LuatOS-SoC_Air8000.bin",
     -- 合宙IOT平台的默认升级URL, 不填就是这个默认值
     -- 如果是自建的OTA服务器, 则需要填写正确的URL, 例如 http://192.168.1.5:8000/update
     -- 如果自建OTA服务器,且url包含全部参数,不需要额外添加参数, 请在url前面添加 ###

module/Air780EPM/demo/fota2/self_server/update.lua

@@ -76,7 +76,7 @@ end
 -- 13. opts.body string 额外添加的请求body,默认不需要
 ]]
 local opts = {
-    url = "###http://cdn.openluat-backend.openluat.com/upgrade_firmware/fotademo_2008.001.001_LuatOS-SoC_Air8000.bin_20250623184110381812",
+    url = "###http://cdn.openluat-backend.openluat.com/upgrade_firmware/fotademo_2008.001.001_LuatOS-SoC_Air8000.bin",
     -- 合宙IOT平台的默认升级URL, 不填就是这个默认值
     -- 如果是自建的OTA服务器, 则需要填写正确的URL, 例如 http://192.168.1.5:8000/update
     -- 如果自建OTA服务器,且url包含全部参数,不需要额外添加参数, 请在url前面添加 ###

module/Air8000/demo/luatos_framework/luatos_task/create.lua

@@ -1,46 +0,0 @@
---[[
-@module  create
-@summary task调度演示 
-@version 1.0
-@date    2025.08.12
-@author  朱天华
-@usage
-本文件为task_scheduling应用功能模块，用来演示task调度，核心业务逻辑为：
-1、创建两个task，task1和task2；
-2、在task1的任务处理函数中，每隔500毫秒，task1的计数器加1，并且通过日志打印task1计数器的值；
-3、在task2的任务处理函数中，每隔300毫秒，task2的计数器加1，并且通过日志打印task2计数器的值；
-
-本文件没有对外接口，直接在main.lua中require "create"就可以加载运行；
-]]
-
-local count = 0
-
--- led task的任务处理函数
-local function led_task_func()
-    while true do
-        log.info("led_task_func")
-
-        -- 等待500ms
-        -- sys.wait(500)
-
-        sys.waitUntil("INVALID_MESSAGE")
-
-        -- log.info("during led task, mem.lua", rtos.meminfo())
-        -- log.info("before led task, mem.sys", rtos.meminfo("sys"))
-    end
-end
-
-log.info("before led task, mem.lua", rtos.meminfo())
-log.info("before led task, mem.sys", rtos.meminfo("sys"))
-
--- 创建并启动第一个led task
--- 运行这个task的任务处理函数led_task_func
-while true do
-    sys.taskInit(led_task_func)
-    count = count+1
-    log.info("create task count", count)
-end
-
-log.info("after led task, mem.lua", rtos.meminfo())
-log.info("before led task, mem.sys", rtos.meminfo("sys"))
-

module/Air8000/demo/luatos_framework/luatos_task/global_msg_receiver1.lua

@@ -1,4 +1,18 @@
-
+--[[
+@module  global_msg_receiver1
+@summary “使用sys.subscribe和sys.unsubscribe接口实现用户全局消息订阅和取消订阅”功能模块
+@version 1.0
+@date    2025.08.12
+@author  朱天华
+@usage
+本文件为global_msg_receiver1应用功能模块；
+用来演示“使用sys.subscribe和sys.unsubscribe接口实现用户全局消息订阅和取消订阅”的功能，核心业务逻辑为：
+1、开机初始化时，订阅"SEND_DATA_REQ"全局消息的回调函数init_subscribe_cbfunc；
+2、开机后延时5秒，订阅"SEND_DATA_REQ"全局消息的回调函数delay_subscribe_cbfunc；
+3、开机10秒后，取消订阅"SEND_DATA_REQ"全局消息的以上两个回调函数；
+
+本文件没有对外接口，直接在main.lua中require "global_msg_receiver1"就可以加载运行；
+]]
 
 
 local function init_subscribe_cbfunc(tag, count)

module/Air8000/demo/luatos_framework/luatos_task/global_msg_receiver2.lua

@@ -1,4 +1,17 @@
-
+--[[
+@module  global_msg_receiver2
+@summary “使用sys.waitUntil接口实现task内用户全局消息接收”功能模块
+@version 1.0
+@date    2025.08.12
+@author  朱天华
+@usage
+本文件为global_msg_receiver2应用功能模块；
+用来演示“使用sys.waitUntil接口实现task内用户全局消息接收”的功能，核心业务逻辑为：
+1、创建一个基础task，演示“使用sys.waitUntil接口实现task内用户全局消息接收”的正确方法；
+2、创建另一个基础task，演示“使用sys.waitUntil接口实现task内用户全局消息接收”的错误方法；
+
+本文件没有对外接口，直接在main.lua中require "global_msg_receiver2"就可以加载运行；
+]]
 
 
 local function success_wait_until_base_task_func()
@@ -15,6 +28,8 @@ end
 local function lost_wait_until_base_task_func()
     local result, tag, count
     while true do
+        -- 阻塞等待3秒钟
+        -- 在这段时间内，本task无法及时处理全局消息发送模块发布的"SEND_DATA_REQ"消息，会造成消息丢失
         sys.wait(3000)
         
         result, tag, count = sys.waitUntil("SEND_DATA_REQ")
@@ -24,7 +39,11 @@ local function lost_wait_until_base_task_func()
     end
 end
 
-
+-- 创建并且启动一个基础task
+-- 运行这个task的任务处理函数success_wait_until_base_task_func
 sys.taskInit(success_wait_until_base_task_func)
+
+-- 创建并且启动一个基础task
+-- 运行这个task的任务处理函数lost_wait_until_base_task_func
 sys.taskInit(lost_wait_until_base_task_func)
 

module/Air8000/demo/luatos_framework/luatos_task/global_msg_sender.lua

@@ -1,4 +1,16 @@
+--[[
+@module  global_msg_sender
+@summary “用户全局消息发送”演示功能模块
+@version 1.0
+@date    2025.08.12
+@author  朱天华
+@usage
+本文件为global_msg_sender应用功能模块，用来演示“用户全局消息发送”功能，核心业务逻辑为：
+1、创建并且启动一个基础task，每隔一秒钟发布一条全局消息；
+2、创建并且启动一个循环定时器，每隔一秒钟发布一条全局消息；
 
+本文件没有对外接口，直接在main.lua中require "global_msg_sender"就可以加载运行；
+]]
 
 
 local function global_sender_msg_task_func()
@@ -38,6 +50,8 @@ end
 -- 运行这个task的任务处理函数global_sender_msg_task_func
 sys.taskInit(global_sender_msg_task_func)
 
+-- 首先执行定时器的处理函数发布一条全局消息
 global_sender_msg_timer_cbfunc()
+-- 创建并且启动一个超时时长为1秒钟的循环定时器
 sys.timerLoopStart(global_sender_msg_timer_cbfunc, 1000)
 

module/Air8000/demo/luatos_framework/luatos_task/main.lua

@@ -6,7 +6,8 @@
 @author  朱天华
 @usage
 本demo演示的核心功能为：
-每隔一秒钟通过日志输出一次Hello, LuatOS
+基于sys核心库提供的api，演示LuatOS框架（task，msg，timer，调度器）如何使用
+
 更多说明参考本目录下的readme.md文件
 ]]
 
@@ -63,15 +64,12 @@ end
 -- end, 3000)
 
 -- 加载“task调度”演示功能模块
--- require "scheduling"
+require "scheduling"
 
 -- 加载“task访问共享资源”演示功能模块
 -- require "shared_resource"
 
--- 加载“task创建”演示功能模块
--- require "create"
-
--- 加载“用户可用ram信息”演示功能模块
+-- 加载“查看用户可用ram信息”演示功能模块
 -- require "memory_valid"
 
 -- 加载“单个task占用的ram资源”演示功能模块
@@ -80,7 +78,7 @@ end
 -- 加载“创建task的数量”演示功能模块
 -- require "task_count"
 
--- 加载“task_func参数”演示功能模块
+-- 加载“task任务处理函数”演示功能模块
 -- require "task_func"
 
 -- 加载“task创建时的可变参数”演示功能模块
@@ -102,7 +100,7 @@ end
 -- require "timer"
 
 -- 加载“task内外部运行环境典型错误”演示功能模块
-require "task_inout_env_err"
+-- require "task_inout_env_err"
 
 
 -- 用户代码已结束---------------------------------------------

module/Air8000/demo/luatos_framework/luatos_task/memory_task.lua

@@ -1,16 +1,16 @@
 --[[
-@module  create
-@summary task调度演示 
+@module  memory_task
+@summary “单个task占用的ram资源”演示功能模块 
 @version 1.0
 @date    2025.08.12
 @author  朱天华
 @usage
-本文件为task_scheduling应用功能模块，用来演示task调度，核心业务逻辑为：
-1、创建两个task，task1和task2；
-2、在task1的任务处理函数中，每隔500毫秒，task1的计数器加1，并且通过日志打印task1计数器的值；
-3、在task2的任务处理函数中，每隔300毫秒，task2的计数器加1，并且通过日志打印task2计数器的值；
+本文件为memory_task应用功能模块，用来演示“单个task占用的ram资源”，核心业务逻辑为：
+1、在创建一个task前，打印下当前的ram信息；
+2、创建并且启动一个task；
+3、在创建并且启动这个task后，打印下当前的ram信息；
 
-本文件没有对外接口，直接在main.lua中require "create"就可以加载运行；
+本文件没有对外接口，直接在main.lua中require "memory_task"就可以加载运行；
 ]]
 
 local function print_mem_info()
@@ -41,6 +41,7 @@ local function led_task_func()
 end
 
 log.info("before led task")
+-- 在创建一个task之前，打印下当前的ram信息
 print_mem_info()
 
 -- 创建并启动一个led task
@@ -48,5 +49,6 @@ print_mem_info()
 sys.taskInit(led_task_func)
 
 log.info("after led task")
+-- 在创建一个task之后，打印下当前的ram信息
 print_mem_info()
 

module/Air8000/demo/luatos_framework/luatos_task/memory_valid.lua

@@ -1,16 +1,15 @@
 --[[
-@module  create
-@summary task调度演示 
+@module  memory_valid
+@summary “查看用户可用ram信息”演示功能模块
 @version 1.0
 @date    2025.08.12
 @author  朱天华
 @usage
-本文件为task_scheduling应用功能模块，用来演示task调度，核心业务逻辑为：
-1、创建两个task，task1和task2；
-2、在task1的任务处理函数中，每隔500毫秒，task1的计数器加1，并且通过日志打印task1计数器的值；
-3、在task2的任务处理函数中，每隔300毫秒，task2的计数器加1，并且通过日志打印task2计数器的值；
+本文件为memory_valid应用功能模块，用来演示：如何查看用户可用ram信息，核心业务逻辑为：
+1、创建一个task；
+2、在task的任务处理函数中，每隔1秒查询一次当前的ram信息；
 
-本文件没有对外接口，直接在main.lua中require "create"就可以加载运行；
+本文件没有对外接口，直接在main.lua中require "memory_valid"就可以加载运行；
 ]]
 
 
@@ -31,12 +30,18 @@ local function print_mem_info()
     log.info("mem.sys", rtos.meminfo("sys"))
 end
 
+
 local function mem_task_func()
     while true do
+        -- 打印当前的ram信息
         print_mem_info()
+
+        -- 延时1秒
         sys.wait(1000)
     end
 end
 
+-- 创建并启动一个task
+-- 运行这个task的任务处理函数mem_task_func
 sys.taskInit(mem_task_func)
 

module/Air8000/demo/luatos_framework/luatos_task/non_targeted_msg.lua

@@ -1,21 +1,21 @@
 --[[
-@module  create
-@summary task调度演示 
+@module  non_targeted_msg
+@summary “非目标消息回调函数”演示功能模块 
 @version 1.0
 @date    2025.08.12
 @author  朱天华
 @usage
-本文件为task_scheduling应用功能模块，用来演示task调度，核心业务逻辑为：
-1、创建两个task，task1和task2；
-2、在task1的任务处理函数中，每隔500毫秒，task1的计数器加1，并且通过日志打印task1计数器的值；
-3、在task2的任务处理函数中，每隔300毫秒，task2的计数器加1，并且通过日志打印task2计数器的值；
+本文件为non_targeted_msg应用功能模块，用来演示“非目标消息回调函数”如何使用，核心业务逻辑为：
+1、创建一个高级task，task名称为"MQTT_CLINET_MAIN"，task的非目标消息回调函数为mqtt_client_main_cbfunc；
+2、创建一个基础task，每隔一秒向名称为"MQTT_CLINET_MAIN"的高级task发送一条非目标消息；
+3、创建一个高级task，task名称为"SEND_MSG_TASK"，每隔一秒向名称为"MQTT_CLINET_MAIN"的高级task发送一条目标消息；
 
-本文件没有对外接口，直接在main.lua中require "create"就可以加载运行；
+本文件没有对外接口，直接在main.lua中require "non_targeted_msg"就可以加载运行；
 ]]
 
 
--- tcp_client_main的任务名
-local TASK_NAME = "TCP_CLINET_MAIN"
+-- mqtt_client_main的任务名
+local TASK_NAME = "MQTT_CLINET_MAIN"
 
 
 -- 非目标消息回调函数
@@ -28,7 +28,7 @@ local function mqtt_client_main_task_func()
     -- 连接、断开连接、订阅、取消订阅、异常等各种事件的处理调度逻辑
     while true do
         -- 等待"MQTT_EVENT"消息
-        msg = sysplus.waitMsg(TASK_NAME, "MQTT_EVENT")
+        msg = sys.waitMsg(TASK_NAME, "MQTT_EVENT")
         log.info("mqtt_client_main_task_func waitMsg", msg[2], msg[3], msg[4])
 
         -- connect连接结果
@@ -77,22 +77,6 @@ local function send_non_targeted_msg_task_func()
     end
 end
 
-local function send_non_targeted_msg_task_func()
-    local count = 0
-
-    while true do
-        count = count+1
-
-        -- 向TASK_NAME这个任务发送一条消息
-        -- 消息名称为"UNKNOWN_EVENT"
-        -- 消息携带一个number类型的参数count
-        sysplus.sendMsg(TASK_NAME, "UNKNOWN_EVENT", count)
-
-        -- 延时等待1秒
-        sys.wait(1000)
-    end
-end
-
 
 local function send_targeted_msg_task_func()
     while true do
@@ -102,7 +86,7 @@ local function send_targeted_msg_task_func()
         -- 第一个参数为"CONNECT"
         -- 第二个参数为true
         -- 这条消息的意思是MQTT连接成功
-        sysplus.sendMsg(TASK_NAME, "MQTT_EVENT", "CONNECT", true)
+        sys.sendMsg(TASK_NAME, "MQTT_EVENT", "CONNECT", true)
 
         -- 延时等待1秒
         sys.wait(1000)
@@ -114,7 +98,7 @@ local function send_targeted_msg_task_func()
         -- 第二个参数为true
         -- 第三个参数为0
         -- 这条消息的意思是MQTT订阅成功，qos为0
-        sysplus.sendMsg(TASK_NAME, "MQTT_EVENT", "SUBSCRIBE", true, 0)
+        sys.sendMsg(TASK_NAME, "MQTT_EVENT", "SUBSCRIBE", true, 0)
 
         -- 延时等待1秒
         sys.wait(1000)
@@ -123,7 +107,7 @@ local function send_targeted_msg_task_func()
         -- 消息名称为"MQTT_EVENT"
         -- 消息携带一个参数"DISCONNECTED"
         -- 这条消息的意思是MQTT连接被动断开
-        sysplus.sendMsg(TASK_NAME, "MQTT_EVENT", "DISCONNECTED")
+        sys.sendMsg(TASK_NAME, "MQTT_EVENT", "DISCONNECTED")
 
         -- 延时等待1秒
         sys.wait(1000)
@@ -135,7 +119,7 @@ end
 -- task的名称为TASK_NAME变量的值"MQTT_CLINET_MAIN"
 -- task的非目标消息回调函数为mqtt_client_main_cbfunc
 -- 运行这个task的任务处理函数mqtt_client_main_task_func
-sysplus.taskInitEx(mqtt_client_main_task_func, TASK_NAME, mqtt_client_main_cbfunc)
+sys.taskInitEx(mqtt_client_main_task_func, TASK_NAME, mqtt_client_main_cbfunc)
 
 
 -- 创建并且启动一个基础task
@@ -146,4 +130,4 @@ sys.taskInit(send_non_targeted_msg_task_func)
 -- task的任务处理函数为send_targeted_msg_task_func
 -- task的名称为SEND_TASK_NAME
 -- 运行这个task的任务处理函数send_targeted_msg_task_func
-sysplus.taskInitEx(send_targeted_msg_task_func, "SEND_MSG_TASK")
+sys.taskInitEx(send_targeted_msg_task_func, "SEND_MSG_TASK")

module/Air8000/demo/luatos_framework/luatos_task/readme.md

@@ -1,9 +1,17 @@
 
 ## 演示功能概述
 
-1、创建一个task；
+演示LuatOS运行框架如何使用，包括：
 
-2、在task中的任务处理函数中，每隔一秒钟通过日志输出一次Hello, LuatOS；
+1、LuatOS task如何使用；
+
+2、LuatOS msg如何使用；
+
+3、LuatOS timer如何使用；
+
+4、LuatOS 调度器如何使用；
+
+5、以上四项功能全部基于sys核心库提供的api才能正常运行，所以本demo本质是在演示sys核心库提供的所有api如何使用；
 
 
 ## 演示硬件环境
@@ -30,18 +38,98 @@
 
 1、搭建好硬件环境
 
-2、Luatools烧录内核固件和demo脚本代码
+2、在main.lua中按需启动如下某一段代码，单独演示某一项功能，这样分析起来比较清晰
+
+``` lua
+-- 加载“task调度”演示功能模块
+-- require "scheduling"
+
+-- 加载“task访问共享资源”演示功能模块
+-- require "shared_resource"
+
+-- 加载“查看用户可用ram信息”演示功能模块
+-- require "memory_valid"
+
+-- 加载“单个task占用的ram资源”演示功能模块
+-- require "memory_task"
+
+-- 加载“创建task的数量”演示功能模块
+-- require "task_count"
+
+-- 加载“task任务处理函数”演示功能模块
+-- require "task_func"
+
+-- 加载“task创建时的可变参数”演示功能模块
+-- require "variable_args"
+
+-- 加载“非目标消息回调函数”演示功能模块
+-- require "non_targeted_msg"
+
+-- 加载“用户全局消息处理”演示功能模块
+-- require "global_msg_receiver1"
+-- require "global_msg_receiver2"
+-- require "global_msg_sender"
+
+-- 加载“用户定向消息处理”演示功能模块
+-- require "tgted_msg_receiver"
+-- require "targeted_msg_sender"
+
+-- 加载“定时器”演示功能模块
+-- require "timer"
+
+-- 加载“task内外部运行环境典型错误”演示功能模块
+-- require "task_inout_env_err"
+```
+
+2、Luatools烧录内核固件和修改main.lua后的demo脚本代码
 
 3、烧录成功后，自动开机运行
 
-4、出现类似于下面的日志，每隔1秒输出1次Hello, LuatOS，就表示运行成功：
+4、在main.lua中打开不同的演示功能模块，对应在Luatools的日志窗口会出现不同的日志信息，例如：
 
 ``` lua
-[2025-07-19 23:19:04.944][000000015.256] I/user.Hello, LuatOS
-[2025-07-19 23:19:05.954][000000016.256] I/user.Hello, LuatOS
-[2025-07-19 23:19:06.956][000000017.256] I/user.Hello, LuatOS
-[2025-07-19 23:19:07.947][000000018.256] I/user.Hello, LuatOS
-[2025-07-19 23:19:08.955][000000019.256] I/user.Hello, LuatOS
-[2025-07-19 23:19:09.944][000000020.256] I/user.Hello, LuatOS
+如果在main.lua中开启以下代码
+-- 加载“task调度”演示功能模块
+require "scheduling"
+
+则日志信息如下：
+[2025-08-28 12:04:33.469][00000000.228] I/user.task1_func 运行中，计数: 1
+[2025-08-28 12:04:33.469][00000000.228] I/user.task_scheduling after task1 and before task2
+[2025-08-28 12:04:33.469][00000000.228] I/user.task2_func 运行中，计数: 1
+[2025-08-28 12:04:33.554][00000000.313] I/user.task2_func 运行中，计数: 2
+[2025-08-28 12:04:33.748][00000000.507] I/user.task1_func 运行中，计数: 2
+[2025-08-28 12:04:33.865][00000000.624] I/user.task2_func 运行中，计数: 3
+[2025-08-28 12:04:34.179][00000000.938] I/user.task2_func 运行中，计数: 4
+[2025-08-28 12:04:34.254][00000001.013] I/user.task1_func 运行中，计数: 3
+[2025-08-28 12:04:34.494][00000001.253] I/user.task2_func 运行中，计数: 5
+[2025-08-28 12:04:34.763][00000001.522] I/user.task1_func 运行中，计数: 4
+[2025-08-28 12:04:34.808][00000001.567] I/user.task2_func 运行中，计数: 6
+[2025-08-28 12:04:35.121][00000001.880] I/user.task2_func 运行中，计数: 7
+[2025-08-28 12:04:35.274][00000002.033] I/user.task1_func 运行中，计数: 5
+[2025-08-28 12:04:35.436][00000002.196] I/user.task2_func 运行中，计数: 8
+[2025-08-28 12:04:35.739][00000002.499] I/user.task2_func 运行中，计数: 9
+[2025-08-28 12:04:35.783][00000002.542] I/user.task1_func 运行中，计数: 6
+[2025-08-28 12:04:36.046][00000002.806] I/user.task2_func 运行中，计数: 10
+[2025-08-28 12:04:36.285][00000003.045] I/user.task1_func 运行中，计数: 7
+[2025-08-28 12:04:36.357][00000003.116] I/user.task2_func 运行中，计数: 11
+[2025-08-28 12:04:36.661][00000003.420] I/user.task2_func 运行中，计数: 12
+[2025-08-28 12:04:36.797][00000003.556] I/user.task1_func 运行中，计数: 8
+[2025-08-28 12:04:36.960][00000003.719] I/user.task2_func 运行中，计数: 13
+[2025-08-28 12:04:37.275][00000004.034] I/user.task2_func 运行中，计数: 14
+[2025-08-28 12:04:37.305][00000004.064] I/user.task1_func 运行中，计数: 9
+[2025-08-28 12:04:37.579][00000004.338] I/user.task2_func 运行中，计数: 15
+[2025-08-28 12:04:37.818][00000004.577] I/user.task1_func 运行中，计数: 10
+[2025-08-28 12:04:37.889][00000004.648] I/user.task2_func 运行中，计数: 16
+[2025-08-28 12:04:38.199][00000004.958] I/user.task2_func 运行中，计数: 17
+[2025-08-28 12:04:38.325][00000005.084] I/user.task1_func 运行中，计数: 11
+[2025-08-28 12:04:38.500][00000005.259] I/user.task2_func 运行中，计数: 18
+[2025-08-28 12:04:38.812][00000005.571] I/user.task2_func 运行中，计数: 19
+[2025-08-28 12:04:38.825][00000005.584] I/user.task1_func 运行中，计数: 12
+[2025-08-28 12:04:39.113][00000005.872] I/user.task2_func 运行中，计数: 20
+[2025-08-28 12:04:39.333][00000006.092] I/user.task1_func 运行中，计数: 13
+[2025-08-28 12:04:39.414][00000006.173] I/user.task2_func 运行中，计数: 21
+[2025-08-28 12:04:39.717][00000006.476] I/user.task2_func 运行中，计数: 22
+[2025-08-28 12:04:39.835][00000006.594] I/user.task1_func 运行中，计数: 14
+[2025-08-28 12:04:40.020][00000006.779] I/user.task2_func 运行中，计数: 23
 
 ```

module/Air8000/demo/luatos_framework/luatos_task/scheduling.lua

@@ -5,12 +5,13 @@
 @date    2025.08.12
 @author  朱天华
 @usage
-本文件为task_scheduling应用功能模块，用来演示task调度，核心业务逻辑为：
+本文件为scheduling应用功能模块，用来演示task协作式的调度方式，核心业务逻辑为：
 1、创建两个task，task1和task2；
 2、在task1的任务处理函数中，每隔500毫秒，task1的计数器加1，并且通过日志打印task1计数器的值；
 3、在task2的任务处理函数中，每隔300毫秒，task2的计数器加1，并且通过日志打印task2计数器的值；
 
-本文件没有对外接口，直接在main.lua中require "task_scheduling"就可以加载运行；
+
+本文件没有对外接口，直接在main.lua中require "scheduling"就可以加载运行；
 ]]
 
 

module/Air8000/demo/luatos_framework/luatos_task/shared_resource.lua

@@ -5,7 +5,7 @@
 @date    2025.08.15
 @author  朱天华
 @usage
-本文件为shared_resource应用功能模块，用来演示多个task访问共享资源，核心业务逻辑为：
+本文件为shared_resource应用功能模块，用来演示多个task访问共享资源的功能，核心业务逻辑为：
 1、创建一个全局共享变量global_shared_variable，变量值初始化为0；
 2、创建两个task，task1和task2；
 2、在task1的任务处理函数中：

module/Air8000/demo/luatos_framework/luatos_task/targeted_msg_sender.lua

@@ -1,4 +1,15 @@
+--[[
+@module  targeted_msg_sender
+@summary “用户定向消息发送”演示功能模块
+@version 1.0
+@date    2025.08.12
+@author  朱天华
+@usage
+本文件为targeted_msg_sender应用功能模块，用来演示“用户定向消息发送”功能，核心业务逻辑为：
+1、创建并且启动一个基础task，每隔一秒钟向两个高级task发布各发送一条定向消息；
 
+本文件没有对外接口，直接在main.lua中require "targeted_msg_sender"就可以加载运行；
+]]
 
 
 local function targeted_msg_sender_task_func()
@@ -12,14 +23,14 @@ local function targeted_msg_sender_task_func()
         -- 消息携带两个参数：
         -- 第一个参数是"from task"
         -- 第二个参数是number类型的count
-        sysplus.sendMsg("nromal_wait_msg_task", "SEND_DATA_REQ", "from task", count)
+        sys.sendMsg("nromal_wait_msg_task", "SEND_DATA_REQ", "from task", count)
 
         -- 发布一条定向消息到名称为"delay_wait_msg_task"的高级task
         -- 消息名称为"SEND_DATA_REQ"
         -- 消息携带两个参数：
         -- 第一个参数是"from task"
         -- 第二个参数是number类型的count
-        sysplus.sendMsg("delay_wait_msg_task", "SEND_DATA_REQ", "from task", count)
+        sys.sendMsg("delay_wait_msg_task", "SEND_DATA_REQ", "from task", count)
 
         -- 延时等待1秒
         sys.wait(1000)

module/Air8000/demo/luatos_framework/luatos_task/task_count.lua

@@ -1,21 +1,21 @@
 --[[
-@module  create
-@summary task调度演示 
+@module  task_count
+@summary “创建task的数量”演示功能模块 
 @version 1.0
 @date    2025.08.12
 @author  朱天华
 @usage
-本文件为task_scheduling应用功能模块，用来演示task调度，核心业务逻辑为：
-1、创建两个task，task1和task2；
-2、在task1的任务处理函数中，每隔500毫秒，task1的计数器加1，并且通过日志打印task1计数器的值；
-3、在task2的任务处理函数中，每隔300毫秒，task2的计数器加1，并且通过日志打印task2计数器的值；
+本文件为task_count应用功能模块，用来演示“可以创建多少个task”，核心业务逻辑为：
+执行一个while true循环，每次执行到循环体内，执行以下两项动作：
+1、创建并且启动一个task，启动后，task处于阻塞状态，永远不会死亡
+2、task数量的计数器加一，并且打印当前已经创建的task总数量
 
-本文件没有对外接口，直接在main.lua中require "create"就可以加载运行；
+本文件没有对外接口，直接在main.lua中require "task_count"就可以加载运行；
 ]]
 
 local count = 0
 
--- led task的任务处理函数
+-- task的任务处理函数
 local function led_task_func()
     while true do
         log.info("led_task_func")
@@ -23,8 +23,7 @@ local function led_task_func()
     end
 end
 
--- 创建并启动第一个led task
--- 运行这个task的任务处理函数led_task_func
+-- 不断地创建task，直到ram资源耗尽
 while true do
     sys.taskInit(led_task_func)
     count = count+1

module/Air8000/demo/luatos_framework/luatos_task/task_func.lua

@@ -1,18 +1,20 @@
 --[[
-@module  create
-@summary task调度演示 
+@module  task_func
+@summary “task任务处理函数”演示功能模块 
 @version 1.0
 @date    2025.08.12
 @author  朱天华
 @usage
-本文件为task_scheduling应用功能模块，用来演示task调度，核心业务逻辑为：
-1、创建两个task，task1和task2；
-2、在task1的任务处理函数中，每隔500毫秒，task1的计数器加1，并且通过日志打印task1计数器的值；
-3、在task2的任务处理函数中，每隔300毫秒，task2的计数器加1，并且通过日志打印task2计数器的值；
+本文件为task_func应用功能模块，用来演示“如何设置task任务处理函数”，核心业务逻辑为：
+1、创建一个task时，需要设置task任务处理函数；
+2、演示一种常见的错误设置方式；
 
-本文件没有对外接口，直接在main.lua中require "create"就可以加载运行；
+本文件没有对外接口，直接在main.lua中require "task_func"就可以加载运行；
 ]]
 
+-- 创建并启动一个led task
+-- 运行这个task的任务处理函数led_task_func
+-- 此处运行会报错，因为执行到这行代码时，找不到led_task_func函数的定义，犯了“先使用，后定义”的错误
 sys.taskInit(led_task_func)
 
 
@@ -23,5 +25,3 @@ local function led_task_func()
     end
 end
 
-
-

module/Air8000/demo/luatos_framework/luatos_task/task_inout_env_err.lua

@@ -1,7 +1,24 @@
+--[[
+@module  targeted_msg_sender
+@summary “task内和task外运行环境典型错误”演示功能模块
+@version 1.0
+@date    2025.08.12
+@author  朱天华
+@usage
+本文件为task_inout_env_err应用功能模块，用来演示“task内和task外运行环境典型错误”，核心业务逻辑为：
+演示“task内外运行环境使用不当”而出现的典型错误
+1、在用户全局消息订阅的回调函数中执行sys.wait接口；
+2、在单次定时器的回调函数中执行sys.waitUntil接口；
+3、在循环定时器的回调函数中执行sys.waitMsg接口；
+4、以上三种都是在task外的运行环境中执行“必须在task内运行”的接口，还有其他类似的使用错误，不再一一列举；
+
+本文件没有对外接口，直接在main.lua中require "task_inout_env_err"就可以加载运行；
+]]
 
 
 local function mqtt_event_cbfunc()
     log.info("mqtt_event_cbfunc")
+    -- 在用户全局消息订阅的回调函数中执行sys.wait接口，会报错
     sys.wait(1000)
 end
 
@@ -9,17 +26,25 @@ end
 -- sys.timerStart(sys.publish, 1000, "MQTT_EVENT")
 
 
+
+
+
 local function timer_cbfunc()
     log.info("timer_cbfunc")
+    -- 在单次定时器的回调函数中执行sys.waitUntil接口，会报错
     sys.waitUntil("UNKNOWN_MSG", 1000)
 end
 
 -- sys.timerStart(timer_cbfunc, 1000)
 
 
+
+
+
 local function loop_timer_cbfunc()
     log.info("loop_timer_cbfunc")
-    sysplus.waitMsg("SEND_MSG_TASK", "UNKNOWN_MSG", 1000)
+    -- 在循环定时器的回调函数中执行sys.waitMsg接口，会报错
+    sys.waitMsg("SEND_MSG_TASK", "UNKNOWN_MSG", 1000)
 end
 
 local function send_targeted_msg_task_func()
@@ -33,5 +58,5 @@ end
 -- task的任务处理函数为send_targeted_msg_task_func
 -- task的名称为SEND_TASK_NAME
 -- 运行这个task的任务处理函数send_targeted_msg_task_func
-sysplus.taskInitEx(send_targeted_msg_task_func, "SEND_MSG_TASK")
+sys.taskInitEx(send_targeted_msg_task_func, "SEND_MSG_TASK")
 sys.timerLoopStart(loop_timer_cbfunc, 1000)

module/Air8000/demo/luatos_framework/luatos_task/tgted_msg_receiver.lua

@@ -1,131 +1,48 @@
-local TASK_NAME = "MQTT_CLINET_MAIN"
-
--- 非目标消息回调函数
-local function mqtt_client_main_cbfunc(msg)
-	log.info("mqtt_client_main_cbfunc", msg[1], msg[2], msg[3], msg[4])
-end
-
--- mqtt main task 的任务处理函数
-local function mqtt_client_main_task_func()
-    -- 连接、断开连接、订阅、取消订阅、异常等各种事件的处理调度逻辑
+--[[
+@module  tgted_msg_receiver
+@summary “使用sys.waitMsg接口实现task内用户定向消息接收”功能演示模块
+@version 1.0
+@date    2025.08.12
+@author  朱天华
+@usage
+本文件为tgted_msg_receiver应用功能模块；
+用来演示“使用sys.waitMsg接口实现task内用户定向消息接收”的功能，核心业务逻辑为：
+1、创建并且启动一个高级task，task名称为"nromal_wait_msg_task"，在task的任务处理函数内及时接收发送给自己的定向消息；
+2、创建并且启动另一个高级task，task名称为"delay_wait_msg_task"，在task的任务处理函数内延时接收发送给自己的定向消息；
+
+本文件没有对外接口，直接在main.lua中require "tgted_msg_receiver"就可以加载运行；
+]]
+
+local function normal_wait_msg_task_func()
+    local msg
     while true do
-        -- 等待"MQTT_EVENT"消息
-        msg = sysplus.waitMsg(TASK_NAME, "MQTT_EVENT")
-        log.info("mqtt_client_main_task_func waitMsg", msg[2], msg[3], msg[4])
-
-        -- connect连接结果
-        -- msg[3]表示连接结果，true为连接成功，false为连接失败
-        if msg[2] == "CONNECT" then
-            -- mqtt连接成功
-            if msg[3] then
-                log.info("mqtt_client_main_task_func", "connect success")
-            -- mqtt连接失败
-            else
-                log.info("mqtt_client_main_task_func", "connect error")
-            end
-
-        -- subscribe订阅结果
-        -- msg[3]表示订阅结果，true为订阅成功，false为订阅失败
-        elseif msg[2] == "SUBSCRIBE" then
-            -- 订阅成功
-            if msg[3] then
-                log.info("mqtt_client_main_task_func", "subscribe success", "qos: "..(msg[4] or "nil"))
-            -- 订阅失败
-            else
-                log.error("mqtt_client_main_task_func", "subscribe error", "code", msg[4])
-            end
-
-        -- 被动关闭了mqtt连接
-        -- 被网络或者服务器断开了连接
-        elseif msg[2] == "DISCONNECTED" then
-            log.info("mqtt_client_main_task_func", "disconnected")
+        msg = sys.waitMsg("nromal_wait_msg_task", "SEND_DATA_REQ")
+        if msg then
+            log.info("normal_wait_msg_task_func", msg[1], msg[2], msg[3], msg[4])
         end
     end
 end
 
-local function send_non_targeted_msg_task_func()
-    local count = 0
-
+local function delay_wait_msg_task_func()
+    local msg
     while true do
-        count = count+1
-
-        -- 向TASK_NAME这个任务发送一条消息
-        -- 消息名称为"UNKNOWN_EVENT"
-        -- 消息携带一个number类型的参数count
-        sys.sendMsg(TASK_NAME, "UNKNOWN_EVENT", count)
-
-        -- 延时等待1秒
-        sys.wait(1000)
-    end
-end
-
-local function send_non_targeted_msg_task_func()
-    local count = 0
-
-    while true do
-        count = count+1
-
-        -- 向TASK_NAME这个任务发送一条消息
-        -- 消息名称为"UNKNOWN_EVENT"
-        -- 消息携带一个number类型的参数count
-        sysplus.sendMsg(TASK_NAME, "UNKNOWN_EVENT", count)
-
-        -- 延时等待1秒
-        sys.wait(1000)
-    end
-end
-
-
-local function send_targeted_msg_task_func()
-    while true do
-        -- 向TASK_NAME这个任务发送一条消息
-        -- 消息名称为"MQTT_EVENT"
-        -- 消息携带两个参数
-        -- 第一个参数为"CONNECT"
-        -- 第二个参数为true
-        -- 这条消息的意思是MQTT连接成功
-        sysplus.sendMsg(TASK_NAME, "MQTT_EVENT", "CONNECT", true)
-
-        -- 延时等待1秒
-        sys.wait(1000)
-
-        -- 向TASK_NAME这个任务发送一条消息
-        -- 消息名称为"MQTT_EVENT"
-        -- 消息携带三个参数
-        -- 第一个参数为"SUBSCRIBE"
-        -- 第二个参数为true
-        -- 第三个参数为0
-        -- 这条消息的意思是MQTT订阅成功，qos为0
-        sysplus.sendMsg(TASK_NAME, "MQTT_EVENT", "SUBSCRIBE", true, 0)
-
-        -- 延时等待1秒
-        sys.wait(1000)
-
-        -- 向TASK_NAME这个任务发送一条消息
-        -- 消息名称为"MQTT_EVENT"
-        -- 消息携带一个参数"DISCONNECTED"
-        -- 这条消息的意思是MQTT连接被动断开
-        sysplus.sendMsg(TASK_NAME, "MQTT_EVENT", "DISCONNECTED")
-
-        -- 延时等待1秒
-        sys.wait(1000)
+        -- 阻塞等待3秒钟
+        -- 在这段时间内，本task无法及时处理定向消息发送模块发布的"SEND_DATA_REQ"消息
+        -- 但是不会造成消息丢失，消息会存储到本task绑定的定向消息队列中
+        -- 虽然不会造成消息丢失，但是业务逻辑中这样写明显也存在问题，因为消息处理的及时性很差
+        sys.wait(3000)
+        
+        msg = sys.waitMsg("delay_wait_msg_task", "SEND_DATA_REQ")
+        if msg then
+            log.info("delay_wait_msg_task_func", msg[1], msg[2], msg[3], msg[4])
+        end
     end
 end
 
--- 创建并且启动一个高级task
--- task的任务处理函数为mqtt_client_main_task_func
--- task的名称为TASK_NAME变量的值"MQTT_CLINET_MAIN"
--- task的非目标消息回调函数为mqtt_client_main_cbfunc
--- 运行这个task的任务处理函数mqtt_client_main_task_func
-sysplus.taskInitEx(mqtt_client_main_task_func, TASK_NAME, mqtt_client_main_cbfunc)
-
-
--- 创建并且启动一个基础task
--- 运行这个task的任务处理函数send_targeted_msg_task_func
-sys.taskInit(send_non_targeted_msg_task_func)
+-- 创建并且启动一个高级task，task名称为"nromal_wait_msg_task"
+-- 运行这个task的任务处理函数normal_wait_msg_task_func
+sys.taskInitEx(normal_wait_msg_task_func, "nromal_wait_msg_task")
 
--- 创建并且启动一个高级task
--- task的任务处理函数为send_targeted_msg_task_func
--- task的名称为SEND_TASK_NAME
--- 运行这个task的任务处理函数send_targeted_msg_task_func
-sysplus.taskInitEx(send_targeted_msg_task_func, "SEND_MSG_TASK")
+-- 创建并且启动一个高级task，task名称为"delay_wait_msg_task"
+-- 运行这个task的任务处理函数delay_wait_msg_task_func
+sys.taskInitEx(delay_wait_msg_task_func, "delay_wait_msg_task")

module/Air8000/demo/luatos_framework/luatos_task/timer.lua

@@ -1,18 +1,41 @@
+--[[
+@module  timer
+@summary “定时器”演示功能模块
+@version 1.0
+@date    2025.08.12
+@author  朱天华
+@usage
+本文件为timer应用功能模块，用来演示“定时器”如何使用，核心业务逻辑为：
+1、演示单次定时器，循环定时器，task内的延时定时器的创建，启动，停止和删除功能；
 
+本文件没有对外接口，直接在main.lua中require "timer"就可以加载运行；
+]]
 
 
 local function timer_test_task_func()
+    -- 以下三行代码执行后，只有最后一个定时器存在
     sys.timerStart(log.info, 1000, "red")
     sys.timerStart(log.info, 2000, "red")
     sys.timerStart(log.info, 3000, "red")
 
+    -- 阻塞等待3秒钟，实际上创建了一个3秒钟超时时长的单次定时器
+    -- 超时时长到达后，会控制本task退出阻塞状态，继续运行
     sys.wait(3000)
 
+    -- 创建并且启动一个循环定时器，每隔1秒钟执行一次sys.publish("loop_timer_cbfunc_msg")
+    -- 相当于每隔1秒钟发布一条用户全局消息"loop_timer_cbfunc_msg"
     sys.timerLoopStart(sys.publish, 1000, "loop_timer_cbfunc_msg")
+
+    -- 创建并且启动一个单次定时器，5.5秒后执行sys.timerStop(sys.publish, "loop_timer_cbfunc_msg")
+    -- 相当于5.5秒后主动停止并且删除了上一行代码创建的循环定时器
     sys.timerStart(sys.timerStop, 5500, sys.publish, "loop_timer_cbfunc_msg")
 
     while true do
+        -- 阻塞等待用户全局消息"loop_timer_cbfunc_msg"，超时时长为2秒钟
+        -- 5秒内，每秒都会收到一次消息；
+        -- 5秒后，不再收到消息，超时2秒退出阻塞状态；
         local result = sys.waitUntil("loop_timer_cbfunc_msg", 2000)
+        
         if result then
             log.info("receive loop_timer_cbfunc_msg")
         else
@@ -21,19 +44,29 @@ local function timer_test_task_func()
         end
     end
 
+    -- 以下五行代码执行后，创建并且启动了5个不同的定时器
     local timer_id = sys.timerStart(log.info, 1000, "1")
     sys.timerStart(log.info, 2000, "2")
     sys.timerStart(log.info, 3000, "3")
     sys.timerStart(log.info, 4000, "4")
     sys.timerStart(log.info, 5000, "5")
 
+    -- 根据定时器id停止并且删除刚才创建的5个定时器中的第一个定时器
     sys.timerStop(timer_id)
     
+    -- 阻塞等待2秒钟
     sys.wait(2000)
 
+    -- 运行到这里
+    -- 刚才创建的5个定时器中的后4个定时器：
+    -- sys.timerStart(log.info, 2000, "2")，这个定时器已经超时，并且自动停止和删除
+    -- 还剩下另外3个定时器处于运行状态，超时时长未到达
+    -- 执行下面这行代码后，可以将这3个定时器全部停止并且删除
     sys.timerStopAll(log.info)
 end
 
-
+-- 创建并且启动一个单次定时器，超时时长为3秒
+-- 3秒后执行sys.taskInit(timer_test_task_func)
+-- 相当于3秒后，创建并且启动一个基础task，然后执行这个task的任务处理函数timer_test_task_func
 sys.timerStart(sys.taskInit, 3000, timer_test_task_func)
 

module/Air8000/demo/luatos_framework/luatos_task/variable_args.lua

@@ -1,16 +1,15 @@
 --[[
-@module  create
-@summary task调度演示 
+@module  variable_args
+@summary “task创建时的可变参数”演示功能模块 
 @version 1.0
 @date    2025.08.12
 @author  朱天华
 @usage
-本文件为task_scheduling应用功能模块，用来演示task调度，核心业务逻辑为：
-1、创建两个task，task1和task2；
-2、在task1的任务处理函数中，每隔500毫秒，task1的计数器加1，并且通过日志打印task1计数器的值；
-3、在task2的任务处理函数中，每隔300毫秒，task2的计数器加1，并且通过日志打印task2计数器的值；
+本文件为variable_args应用功能模块，用来演示“task创建时的可变参数”如何使用，核心业务逻辑为：
+1、创建一个task，可变参数部分携带5个参数；
+2、在task的任务处理函数中打印传入的5个参数的值；
 
-本文件没有对外接口，直接在main.lua中require "create"就可以加载运行；
+本文件没有对外接口，直接在main.lua中require "variable_args"就可以加载运行；
 ]]
 
 
@@ -21,4 +20,8 @@ local function led_task_func(arg1, arg2, arg3, arg4, arg5)
     end
 end
 
+-- 创建并启动一个task
+-- 这个task的任务处理函数为led_task_func
+-- 携带5个参数，分别为"arg1", 3, nil, true, led_task_func
+-- 运行这个task的任务处理函数led_task_func时，会将这5个参数传递给任务处理函数使用
 sys.taskInit(led_task_func, "arg1", 3, nil, true, led_task_func)

module/test.lua

@@ -1,190 +0,0 @@
-记住下面文档格式以及内容：
-
-六、合宙自有服务器 FOTA 简介
-FOTA 有多种方式，可以使用合宙的 iot 平台进行升级，也可以使用用户自建平台升级，可以只升级 core，可以只升级用户脚本，也可以 core+ 脚本一起升级，接下来先介绍合宙自有服务器升级，第三方升级在下一篇文章中介绍
-
-6.1 云平台配置
-使用合宙自建服务器的话，需要先登录合宙 IOT 平台，如下图所示，没有账号的，可以先注册一个 客户向合宙采购4G模块时，如果采购人员没有告知合宙这批模块放在iot.openluat.com上的哪个产品下，则合宙会以采购人的手机号为账号，默认密码888888，创建一个“合宙标准模块”的项目，此次采购的所有模块都会放在这个项目下，如果你的账号下没有对应imei，可以联系合宙销售帮忙添加模块进对应项目下(最好还是从哪里买的模块，就让他给你转移到你自己名下)
-
-如果不在自己账号下，也可以通过烧录专属固件的方法，把模块归属到您指定的项目下，可以通过点击帮助中心，查看详细说明。
-
-
-
-
-
-登录以后点击红框所示位置
-
-
-
-然后依次点击如下图所示红框所示的地方，创建一个新项目
-
-
-
-在所有项目的最后，找到自己刚刚新建的项目，并且点击红框内的"查看/点击复制"复制后面升级所需要的校验码，复制到自己剪切板中
-
-
-
-至此，合宙云平台上的预备动作就做完了
-
-6.2 仅脚本升级简介
-如果用户只是新增一些自己的脚本逻辑，没有更新底层，可以选择仅脚本升级
-
-6.2.1 仅脚本升级示例
-仅脚本升级 demo 链接
-
-
-
-打开 luatools 的项目管理界面，点击生成量产文件，Air8000的纯脚本升级文件放在 luatools 根目录下的"SOC 量产及远程升级文件\Air8000"目录下
-
-
-
-
-
-因为模块烧录的是 001.000.000 版本，所以我们需要给脚本里的版本号改一下，改为 001.000.001 版本
-
-
-
-再将脚本中增加几行打印(为了模拟用户修改脚本的动作)
-
-
-
-然后重新生成一次量产固件
-
-
-
-打开刚刚的合宙 iot 平台点击我的项目--固件列表--创建固件
-
-
-
-点击选择文件，把刚刚的 bin 后缀文件上传到 iot 平台
-
-
-
-文件名、固件名、版本号都是自动识别的，用户无需修改
-
-
-
-点击确定，等待上传成功的动画提示
-
-模块刚开机，luatools 会打印模块的 imei 号，如下图所示，当然也可以使用手机扫描模块上的二维码获得模块 imei 号，或者将模块屏蔽盖上二维码的下方第一排模块的 imei 号，记录下来
-
-
-
-在刚刚创建固件的地方，下拉，找到刚刚创建的升级任务，然后按下图所示，添加模块的 imei
-
-
-
-将升级文件上传和添加 imei 工作完成以后，点击 luatools 上的重启模块或者按照代码里的等待 4 小时，触发远程升级逻辑
-
-
-
-6.2.2 示例效果展示
-升级前：因为没有升级固件，所以请求升级的结果为"已是最新版本"，每隔 5S 会打印一句"降功耗找合宙"和当前版本号
-
-
-
-升级中：模块请求升级，下载完升级包以后会进行 MD5 验证升级包有无问题，如果没问题，就会启动重启程序，然后进行升级工作
-
-
-
-升级后：升级成功后按我们之前的脚本，每隔 1S，打印五次"降功耗,找合宙"以及当前脚本版本号，可以看出，当前版本号已经由原来的 001.000.000 变为了 001.000.001
-
-
-
-当然：升级完成以后，因为脚本中有联网就去请求一次升级的代码，所以，会再去请求一次升级，因为没有更高的版本了，所以会上报"已是最新版本"
-
-
-
-6.3 含 core 升级简介
-每一次 core 的升级都会带来一些网络上的优化(例如信号差时的网络稳定性)以及一些 bug 修复，所以在发布新版本以后，用户可以先测试下 core 对自己脚本有无明显影响或性能提升，然后进行远程 FOTA
-
-6.3.1 含 core 升级测试 demo
-demo 示例
-
-
-这里选择升级到 2008 的core 版本进行演示，001.000.001 脚本选择搭配的 core 为 V2007 版本，再次点击"生成量产文件"，稍等即可在 luatools 根目录下的"SOC 量产及远程升级文件\Air8000"目录下，找到 core 版本号为 V2007 且脚本版本号为 001.000.001 的 soc 后缀文件
-
-
-
-生成了这个版本以后，再去脚本中改动脚本版本号为 001.000.002(只要前后两位有一位大于 1 即可(当然第一位大于 1 的时候，整个版本号自然大于 001.000.001)，如 002.000.200,001.000.002,030.000.311 等)
-
-脚本版本号分为 A.B.C 三段；
-
-因为历史原因，中间这一段 B 没有任何意义，但是必须存在；
-
-假设旧的脚本版本号为 A1.B1.C1，新的脚本版本号为 A2.B2.C2；
-
-当新旧脚本版本号满足以下任何一种条件时，版本号允许升级：
-
-1、A2 等于 A1，同时 C2 大于 C1；
-
-2、A2 大于 A1，同时 C2 大于或者等于 C1；
-
-3、B1 B2 无意义
-
-
-
-然后在 luatools 里重新选择 core 为 V2008 版本，同样点击生成固件，稍等即可在在 luatools 根目录下的"SOC 量产及远程升级文件\Air8000"目录下，找到 core 版本号为 V2008 且脚本版本号为 001.000.002 的 soc 后缀文件
-
-
-
-接下来就是针对这两个量产文件，制作一个差分文件，用来远程升级(注：远程升级中 core 为差分，脚本为全量升级)
-
-点击到 luatools 的主界面，依次点击图中蓝框所示意的地方(注：必须使用 luatools_3.0.9 及其以上版本，要不差分包升级的时候可能会出问题)
-
-
-
-按下图所示选择低版本以及高版本的固件，然后点击开始执行即可，如果不想输出的差分包在 luatools 根目录下，可以自行选择一个输出路径
-
-
-
-因为包含了 core 中的改动，所以时间会稍长一些，luatools 可能会出现"假死"情况，不要关闭它，稍等一会即可看到
-
-
-
-同样，在你选择的目录下(没选择的在 luatools 根目录下)看到如下所示，带着脚本的 PROJECT core 版本号 脚本版本号的 bin 后缀的差分文件。
-
-
-
-至于 iot 平台的配置还是和上文一样的步骤
-
-登录 iot 平台
-
-打开刚刚的合宙 iot 平台点击我的项目--固件列表--创建固件
-
-
-
-点击选择文件，把刚刚的 bin 后缀文件上传到 iot 平台
-
-
-
-文件名、固件名、版本号都是自动识别的，用户无需修改
-
-
-
-点击确定，等待上传成功的动画提示
-
-如果上传了其他文件，会提示"升级文件有误"
-
-
-
-模块刚开机，luatools 会打印模块的 imei 号，如下图所示，当然也可以使用手机扫描模块上的二维码获得模块 imei 号，或者在模块屏蔽盖 二维码的下方第一排就是模块的 imei 号，记录下来
-
-
-
-在刚刚创建固件的地方，下拉，找到刚刚创建的升级任务，然后按下图所示，添加模块的 imei
-
-
-
-将升级文件上传和添加 imei 工作完成以后，为了防止模块当前固件不是fotademo_2007.001.001_LuatOS-SoC_Air8000 版本，可以点击 luatools 主界面右边的"下载固件"选择最早的 001.000.001 版本，按住 BOOT 重启模块，然后点击下载，将最早的固件下载进模块里
-
-
-
-6.3.2 示例效果展示
-升级前：模块打印当前脚本版本号和 core 版本号
-
-升级中下载差分包，校验差分包完成后就会重启模块进入真正的升级逻辑
-
-
-
-因为升级包带 core，所以从重启命令执行下去，到最终升级完成，模块重新开机打印了第一条开机日志，中间隔了不到一分钟，如果 core 中代码改动较多，两分钟三分钟都是正常的。