update：提交bit64 demo

module/Air780EHM_Air780EHV_Air780EGH/demo/bit64/bit64_app.lua

@@ -0,0 +1,124 @@
+--[[
+@module  bit64_app
+@summary bit64_app应用功能模块 
+@version 1.0
+@date    2025.10.14
+@author  沈园园
+@usage
+本文件为bit64应用功能模块，核心业务逻辑为：
+1、演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算；
+
+本文件没有对外接口，直接在main.lua中require "bit64_app"就可以加载运行；
+]]
+
+--定义几个变量
+local data,b64,b32,a,b
+
+--设置调试风格1: I/main.lua:12 ABC DEF 123（在开头添加文件位置信息）
+log.style(1)
+
+--本文的64bit数据为：小端格式的9字节数据的字符串，最后一个字节是类型（0是整数，1是浮点）, 前面8个字节是数据。
+--十进制转123456对应64bit十六进制字符串"40E2010000000000"
+
+if bit64 then
+	log.info("bit64 演示")
+    
+    --将数据进行 32 位和 64 位互转
+    --123456对应64bit的9字节数据HEX字符
+    data = "40E201000000000000"
+    --需将HEX字符串转成Lua字符串填入 
+    b32 = bit64.to32(data:fromHex())
+    log.info("i32", b32, mcu.x32(b32))    
+    
+    data = 12345678
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("i32", b32, mcu.x32(b32))
+	data = -12345678
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("i32", b32, mcu.x32(b32))
+	data = 12.34234
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("f32", data, b32)
+	data = -12.34234
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("f32", data, b32)
+
+    --64 位数据之间进行运算
+    --64bit数据格式化打印成字符串，用于显示值
+    --64bit数据加,a+b,a和b中有一个为浮点，则按照浮点运算
+    --64bit数据减,a-b,a和b中有一个为浮点，则按照浮点运算
+    --64bit数据乘,a*b,a和b中有一个为浮点，则按照浮点运算
+    --64bit数据除,a/b,a和b中有一个为浮点，则按照浮点运算
+	a = bit64.to64(87654321)
+	b = bit64.to64(12345678)
+	log.info("87654321+12345678=", bit64.show(bit64.plus(a,b)))
+	log.info("87654321-12345678=", bit64.show(bit64.minus(a,b)))
+	log.info("87654321*12345678=", bit64.show(bit64.multi(a,b)))
+	log.info("87654321/12345678=", bit64.show(bit64.pide(a,b)))
+
+	--64 位与 32 位数据之间进行运算
+    a = bit64.to64(87654321)
+	b = 1234567
+	log.info("87654321+1234567=", bit64.show(bit64.plus(a,b)))
+	log.info("87654321-1234567=", bit64.show(bit64.minus(a,b)))
+	log.info("87654321*1234567=", bit64.show(bit64.multi(a,b)))
+	log.info("87654321/1234567=", bit64.show(bit64.pide(a,b)))
+
+
+	--64 位数据之间，一个数是浮点数进行运算
+    a = bit64.to64(87654.326)
+	b = bit64.to64(12345)
+	log.info("87654.326+12345=", 87654.326 + 12345)
+	log.info("87654.326+12345=", bit64.show(bit64.plus(a,b)))
+	log.info("87654.326-12345=", bit64.show(bit64.minus(a,b)))
+	log.info("87654.326*12345=", bit64.show(bit64.multi(a,b)))
+	log.info("87654.326/12345=", bit64.show(bit64.pide(a,b)))
+
+	--64 位浮点数计算
+    a = bit64.to64(87654.32)
+	b = bit64.to64(12345.67)
+	log.info("float", "87654.32+12345.67=", 87654.32 + 12345.67)
+	log.info("double","87654.32+12345.67=", bit64.show(bit64.plus(a,b)))
+	log.info("double to float","87654.32+12345.67=", bit64.to32(bit64.plus(a,b)))
+	log.info("87654.32-12345.67=", bit64.show(bit64.minus(a,b)))
+	log.info("87654.32*12345.67=", bit64.show(bit64.multi(a,b)))
+	log.info("87654.32/12345.67=", bit64.show(bit64.pide(a,b)))
+	log.info("double to int64", "87654.32/12345.67=", bit64.show(bit64.pide(a,b,nil,true)))
+
+	--64 位数据移位操作
+    a = bit64.to64(0xc0000000)
+	b = 2
+	a = bit64.shift(a,8,true)
+	log.info("0xc0000000 << 8 =", bit64.show(a, 16))
+	log.info("0xc000000000+2=", bit64.show(bit64.plus(a,b), 16))
+	log.info("0xc000000000-2=", bit64.show(bit64.minus(a,b), 16))
+	log.info("0xc000000000*2=", bit64.show(bit64.multi(a,b), 16))
+	log.info("0xc000000000/2=", bit64.show(bit64.pide(a,b), 16))
+	log.style(0)
+
+	--将字符串转为 LongLong 数据
+    if bit64.strtoll then
+		local data = bit64.strtoll("864040064024194", 10)
+		log.info("data", data:toHex())
+		log.info("data", bit64.show(data))
+	end
+end
+
+--获取高精度 tick，输出转换好的 64 位结构
+local function sys_run_time()
+	local tick64, per = mcu.tick64(true)
+	local per_cnt = per * 1000000
+	while true do
+		tick64, per = mcu.tick64(true)
+		log.info("work time","当前时间", bit64.to32(bit64.pide(tick64,per_cnt)))
+		sys.wait(1000)
+	end
+end
+
+if mcu.tick64 then
+	sys.taskInit(sys_run_time)
+end

module/Air780EHM_Air780EHV_Air780EGH/demo/bit64/main.lua

@@ -1,114 +1,71 @@
-
--- LuaTools需要PROJECT和VERSION这两个信息
-PROJECT = "bit64_test"
-VERSION = "1.0.0"
-
+--[[
+@module  main
+@summary LuatOS用户应用脚本文件入口，总体调度应用逻辑 
+@version 1.0
+@date    2025.10.14
+@author  沈园园
+@usage
+本demo演示的核心功能为：
+演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算
+更多说明参考本目录下的readme.md文件
+]]
+
+
+--[[
+必须定义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 = "luatos_bit64_app"
+VERSION = "001.000.000"
+
+
+-- 在日志中打印项目名和项目版本号
 log.info("main", PROJECT, VERSION)
 
--- 引入必要的库文件(lua编写), 内部库不需要require
-sys = require("sys")
-
--- Air780E的AT固件默认会为开机键防抖, 导致部分用户刷机很麻烦
-if rtos.bsp() == "EC618" and pm and pm.PWK_MODE then
-    pm.power(pm.PWK_MODE, false)
-end
-
 
+-- 如果内核固件支持wdt看门狗功能，此处对看门狗进行初始化和定时喂狗处理
+-- 如果脚本程序死循环卡死，就会无法及时喂狗，最终会自动重启
 if wdt then
-    --添加硬狗防止程序卡死，在支持的设备上启用这个功能
-    wdt.init(9000)--初始化watchdog设置为9s
-    sys.timerLoopStart(wdt.feed, 3000)--3s喂一次狗
+    --配置喂狗超时时间为9秒钟
+    wdt.init(9000)
+    --启动一个循环定时器，每隔3秒钟喂一次狗
+    sys.timerLoopStart(wdt.feed, 3000)
 end
 
 
-local data,b64,b32,a,b
-
-if bit64 then
-	log.style(1)
-	log.info("bit64 演示")
-	data = 12345678
-	b64 = bit64.to64(data)
-	b32 = bit64.to32(b64)
-	log.info("i32", b32, mcu.x32(b32))
-	data = -12345678
-	b64 = bit64.to64(data)
-	b32 = bit64.to32(b64)
-	log.info("i32", b32, mcu.x32(b32))
-	data = 12.34234
-	b64 = bit64.to64(data)
-	b32 = bit64.to32(b64)
-	log.info("f32", data, b32)
-	data = -12.34234
-	b64 = bit64.to64(data)
-	b32 = bit64.to32(b64)
-	log.info("f32", data, b32)
-
+-- 如果内核固件支持errDump功能，此处进行配置，【强烈建议打开此处的注释】
+-- 因为此功能模块可以记录并且上传脚本在运行过程中出现的语法错误或者其他自定义的错误信息，可以初步分析一些设备运行异常的问题
+-- 以下代码是最基本的用法，更复杂的用法可以详细阅读API说明文档
+-- 启动errDump日志存储并且上传功能，600秒上传一次
+-- if errDump then
+--     errDump.config(true, 600)
+-- end
 
-	a = bit64.to64(87654321)
-	b = bit64.to64(12345678)
-	log.info("87654321+12345678=", bit64.show(bit64.plus(a,b)))
-	log.info("87654321-12345678=", bit64.show(bit64.minus(a,b)))
-	log.info("87654321*12345678=", bit64.show(bit64.multi(a,b)))
-	log.info("87654321/12345678=", bit64.show(bit64.pide(a,b)))
 
-	a = bit64.to64(87654321)
-	b = 1234567
-	log.info("87654321+1234567=", bit64.show(bit64.plus(a,b)))
-	log.info("87654321-1234567=", bit64.show(bit64.minus(a,b)))
-	log.info("87654321*1234567=", bit64.show(bit64.multi(a,b)))
-	log.info("87654321/1234567=", bit64.show(bit64.pide(a,b)))
+-- 使用LuatOS开发的任何一个项目，都强烈建议使用远程升级FOTA功能
+-- 可以使用合宙的iot.openluat.com平台进行远程升级
+-- 也可以使用客户自己搭建的平台进行远程升级
+-- 远程升级的详细用法，可以参考fota的demo进行使用
 
 
-	a = bit64.to64(87654.326)
-	b = bit64.to64(12345)
-	log.info("87654.326+12345=", 87654.326 + 12345)
-	log.info("87654.326+12345=", bit64.show(bit64.plus(a,b)))
-	log.info("87654.326-12345=", bit64.show(bit64.minus(a,b)))
-	log.info("87654.326*12345=", bit64.show(bit64.multi(a,b)))
-	log.info("87654.326/12345=", bit64.show(bit64.pide(a,b)))
+-- 启动一个循环定时器
+-- 每隔3秒钟打印一次总内存，实时的已使用内存，历史最高的已使用内存情况
+-- 方便分析内存使用是否有异常
+-- sys.timerLoopStart(function()
+--     log.info("mem.lua", rtos.meminfo())
+--     log.info("mem.sys", rtos.meminfo("sys"))
+-- end, 3000)
 
-	a = bit64.to64(87654.32)
-	b = bit64.to64(12345.67)
-	log.info("float", "87654.32+12345.67=", 87654.32 + 12345.67)
-	log.info("double","87654.32+12345.67=", bit64.show(bit64.plus(a,b)))
-	log.info("double to float","87654.32+12345.67=", bit64.to32(bit64.plus(a,b)))
-	log.info("87654.32-12345.67=", bit64.show(bit64.minus(a,b)))
-	log.info("87654.32*12345.67=", bit64.show(bit64.multi(a,b)))
-	log.info("87654.32/12345.67=", bit64.show(bit64.pide(a,b)))
-	log.info("double to int64", "87654.32/12345.67=", bit64.show(bit64.pide(a,b,nil,true)))
-
-	a = bit64.to64(0xc0000000)
-	b = 2
-	a = bit64.shift(a,8,true)
-	log.info("0xc0000000 << 8 =", bit64.show(a, 16))
-	log.info("0xc000000000+2=", bit64.show(bit64.plus(a,b), 16))
-	log.info("0xc000000000-2=", bit64.show(bit64.minus(a,b), 16))
-	log.info("0xc000000000*2=", bit64.show(bit64.multi(a,b), 16))
-	log.info("0xc000000000/2=", bit64.show(bit64.pide(a,b), 16))
-	log.style(0)
-
-	if bit64.strtoll then
-		local data = bit64.strtoll("864040064024194", 10)
-		log.info("data", data:toHex())
-		log.info("data", bit64.show(data))
-	end
-end
-
-local function sys_run_time()
-	local tick64, per = mcu.tick64(true)
-	local per_cnt = per * 1000000
-	while true do
-		tick64, per = mcu.tick64(true)
-		log.info("work time","当前时间", bit64.to32(bit64.pide(tick64,per_cnt)))
-		sys.wait(1000)
-	end
-end
-
-if mcu.tick64 then
-	sys.taskInit(sys_run_time)
-end
+-- 加载bit64_app应用功能模块
+require "bit64_app"
 
 -- 用户代码已结束---------------------------------------------
 -- 结尾总是这一句
 sys.run()
--- sys.run()之后后面不要加任何语句!!!!!
+-- sys.run()之后不要加任何语句!!!!!因为添加的任何语句都不会被执行

module/Air780EHM_Air780EHV_Air780EGH/demo/bit64/readme.md

@@ -0,0 +1,85 @@
+## 功能模块介绍
+
+1、main.lua：主程序入口；
+
+2、bit64_app.lua：32 位系统上对 64 位数据的基本算术运算和逻辑运算；
+
+## 演示功能概述
+
+1、创建一个task；
+
+2、演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算；
+
+
+## 演示硬件环境
+
+![](https://docs.openluat.com/air780ehv/luatos/common/hwenv/image/Air780EHV2.png)
+
+1、Air780EHM/Air780EHV/Air780EGH核心板一块
+
+2、TYPE-C USB数据线一根
+
+3、Air780EHM/Air780EHV/Air780EGH核心板和数据线的硬件接线方式为
+
+- Air780EHM/Air780EHV/Air780EGH核心板通过TYPE-C USB口连接TYPE-C USB 数据线，数据线的另外一端连接电脑的USB口；
+- 核心板正面的 ON/OFF 拨动开关 拨到ON一端；
+
+
+## 演示软件环境
+
+1、[Luatools下载调试工具](https://docs.openluat.com/air780ehv/luatos/common/download/)
+
+2、[Air780EHM 最新版本的内核固件](https://docs.openluat.com/air780epm/luatos/firmware/version/)
+
+3、[Air780EHV 最新版本的内核固件](https://docs.openluat.com/air780ehv/luatos/firmware/version/)
+
+4、[Air780EGH 最新版本的内核固件](https://docs.openluat.com/air780egh/luatos/firmware/version/)
+
+
+## 演示核心步骤
+
+1、搭建好硬件环境
+
+2、Luatools烧录内核固件和demo脚本代码
+
+3、烧录成功后，自动开机运行
+
+4、出现类似于下面的日志，就表示运行成功：
+
+``` lua
+[2025-10-15 11:10:19.702][000000000.210] I/bit64_luatos.lua:24 bit64 演示
+[2025-10-15 11:10:19.706][000000000.211] I/bit64_luatos.lua:31 i32 123456 0x1e240
+[2025-10-15 11:10:19.713][000000000.211] I/bit64_luatos.lua:36 i32 12345678 0xbc614e
+[2025-10-15 11:10:19.721][000000000.211] I/bit64_luatos.lua:40 i32 -12345678 0xff439eb2
+[2025-10-15 11:10:19.727][000000000.212] I/bit64_luatos.lua:44 f32   12.3423   12.3423
+[2025-10-15 11:10:19.734][000000000.212] I/bit64_luatos.lua:48 f32  -12.3423  -12.3423
+[2025-10-15 11:10:19.742][000000000.212] I/bit64_luatos.lua:58 87654321+12345678= 99999999
+[2025-10-15 11:10:19.747][000000000.213] I/bit64_luatos.lua:59 87654321-12345678= 75308643
+[2025-10-15 11:10:19.752][000000000.213] I/bit64_luatos.lua:60 87654321*12345678= 1082152022374638
+[2025-10-15 11:10:19.757][000000000.213] I/bit64_luatos.lua:61 87654321/12345678= 7
+[2025-10-15 11:10:19.763][000000000.213] I/bit64_luatos.lua:66 87654321+1234567= 88888888
+[2025-10-15 11:10:19.768][000000000.214] I/bit64_luatos.lua:67 87654321-1234567= 86419754
+[2025-10-15 11:10:19.773][000000000.214] I/bit64_luatos.lua:68 87654321*1234567= 108215132114007
+[2025-10-15 11:10:19.777][000000000.214] I/bit64_luatos.lua:69 87654321/1234567= 71
+[2025-10-15 11:10:19.784][000000000.214] I/bit64_luatos.lua:75 87654.326+12345=   99999.3
+[2025-10-15 11:10:19.789][000000000.215] I/bit64_luatos.lua:76 87654.326+12345= 99999.328125
+[2025-10-15 11:10:19.794][000000000.215] I/bit64_luatos.lua:77 87654.326-12345= 75309.328125
+[2025-10-15 11:10:19.799][000000000.215] I/bit64_luatos.lua:78 87654.326*12345= 1.082093e+09
+[2025-10-15 11:10:19.804][000000000.216] I/bit64_luatos.lua:79 87654.326/12345= 7.100391
+[2025-10-15 11:10:19.811][000000000.216] I/bit64_luatos.lua:84 float 87654.32+12345.67=  100000.0
+[2025-10-15 11:10:19.816][000000000.216] I/bit64_luatos.lua:85 double 87654.32+12345.67= 99999.990234
+[2025-10-15 11:10:19.823][000000000.217] I/bit64_luatos.lua:86 double to float 87654.32+12345.67=  100000.0
+[2025-10-15 11:10:19.827][000000000.217] I/bit64_luatos.lua:87 87654.32-12345.67= 75308.650391
+[2025-10-15 11:10:19.832][000000000.217] I/bit64_luatos.lua:88 87654.32*12345.67= 1.082151e+09
+[2025-10-15 11:10:19.836][000000000.218] I/bit64_luatos.lua:89 87654.32/12345.67= 7.100005
+[2025-10-15 11:10:19.842][000000000.218] I/bit64_luatos.lua:90 double to int64 87654.32/12345.67= 7
+[2025-10-15 11:10:19.849][000000000.218] I/bit64_luatos.lua:96 0xc0000000 << 8 = 0xc000000000
+[2025-10-15 11:10:19.853][000000000.218] I/bit64_luatos.lua:97 0xc000000000+2= 0xc000000002
+[2025-10-15 11:10:19.860][000000000.219] I/bit64_luatos.lua:98 0xc000000000-2= 0xbffffffffe
+[2025-10-15 11:10:19.867][000000000.219] I/bit64_luatos.lua:99 0xc000000000*2= 0x18000000000
+[2025-10-15 11:10:19.871][000000000.219] I/bit64_luatos.lua:100 0xc000000000/2= 0x6000000000
+[2025-10-15 11:10:19.876][000000000.219] I/user.data 827E1601D711030000 18
+[2025-10-15 11:10:19.882][000000000.220] I/user.data 864040064024194
+[2025-10-15 11:10:19.887][000000000.220] I/user.work time 当前时间 0
+[2025-10-15 11:10:20.345][000000001.220] I/user.work time 当前时间 1
+```

module/Air780EPM/demo/bit64/bit64_app.lua

@@ -0,0 +1,124 @@
+--[[
+@module  bit64_app
+@summary bit64_app应用功能模块 
+@version 1.0
+@date    2025.10.14
+@author  沈园园
+@usage
+本文件为bit64应用功能模块，核心业务逻辑为：
+1、演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算；
+
+本文件没有对外接口，直接在main.lua中require "bit64_app"就可以加载运行；
+]]
+
+--定义几个变量
+local data,b64,b32,a,b
+
+--设置调试风格1: I/main.lua:12 ABC DEF 123（在开头添加文件位置信息）
+log.style(1)
+
+--本文的64bit数据为：小端格式的9字节数据的字符串，最后一个字节是类型（0是整数，1是浮点）, 前面8个字节是数据。
+--十进制转123456对应64bit十六进制字符串"40E2010000000000"
+
+if bit64 then
+	log.info("bit64 演示")
+    
+    --将数据进行 32 位和 64 位互转
+    --123456对应64bit的9字节数据HEX字符
+    data = "40E201000000000000"
+    --需将HEX字符串转成Lua字符串填入 
+    b32 = bit64.to32(data:fromHex())
+    log.info("i32", b32, mcu.x32(b32))    
+    
+    data = 12345678
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("i32", b32, mcu.x32(b32))
+	data = -12345678
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("i32", b32, mcu.x32(b32))
+	data = 12.34234
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("f32", data, b32)
+	data = -12.34234
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("f32", data, b32)
+
+    --64 位数据之间进行运算
+    --64bit数据格式化打印成字符串，用于显示值
+    --64bit数据加,a+b,a和b中有一个为浮点，则按照浮点运算
+    --64bit数据减,a-b,a和b中有一个为浮点，则按照浮点运算
+    --64bit数据乘,a*b,a和b中有一个为浮点，则按照浮点运算
+    --64bit数据除,a/b,a和b中有一个为浮点，则按照浮点运算
+	a = bit64.to64(87654321)
+	b = bit64.to64(12345678)
+	log.info("87654321+12345678=", bit64.show(bit64.plus(a,b)))
+	log.info("87654321-12345678=", bit64.show(bit64.minus(a,b)))
+	log.info("87654321*12345678=", bit64.show(bit64.multi(a,b)))
+	log.info("87654321/12345678=", bit64.show(bit64.pide(a,b)))
+
+	--64 位与 32 位数据之间进行运算
+    a = bit64.to64(87654321)
+	b = 1234567
+	log.info("87654321+1234567=", bit64.show(bit64.plus(a,b)))
+	log.info("87654321-1234567=", bit64.show(bit64.minus(a,b)))
+	log.info("87654321*1234567=", bit64.show(bit64.multi(a,b)))
+	log.info("87654321/1234567=", bit64.show(bit64.pide(a,b)))
+
+
+	--64 位数据之间，一个数是浮点数进行运算
+    a = bit64.to64(87654.326)
+	b = bit64.to64(12345)
+	log.info("87654.326+12345=", 87654.326 + 12345)
+	log.info("87654.326+12345=", bit64.show(bit64.plus(a,b)))
+	log.info("87654.326-12345=", bit64.show(bit64.minus(a,b)))
+	log.info("87654.326*12345=", bit64.show(bit64.multi(a,b)))
+	log.info("87654.326/12345=", bit64.show(bit64.pide(a,b)))
+
+	--64 位浮点数计算
+    a = bit64.to64(87654.32)
+	b = bit64.to64(12345.67)
+	log.info("float", "87654.32+12345.67=", 87654.32 + 12345.67)
+	log.info("double","87654.32+12345.67=", bit64.show(bit64.plus(a,b)))
+	log.info("double to float","87654.32+12345.67=", bit64.to32(bit64.plus(a,b)))
+	log.info("87654.32-12345.67=", bit64.show(bit64.minus(a,b)))
+	log.info("87654.32*12345.67=", bit64.show(bit64.multi(a,b)))
+	log.info("87654.32/12345.67=", bit64.show(bit64.pide(a,b)))
+	log.info("double to int64", "87654.32/12345.67=", bit64.show(bit64.pide(a,b,nil,true)))
+
+	--64 位数据移位操作
+    a = bit64.to64(0xc0000000)
+	b = 2
+	a = bit64.shift(a,8,true)
+	log.info("0xc0000000 << 8 =", bit64.show(a, 16))
+	log.info("0xc000000000+2=", bit64.show(bit64.plus(a,b), 16))
+	log.info("0xc000000000-2=", bit64.show(bit64.minus(a,b), 16))
+	log.info("0xc000000000*2=", bit64.show(bit64.multi(a,b), 16))
+	log.info("0xc000000000/2=", bit64.show(bit64.pide(a,b), 16))
+	log.style(0)
+
+	--将字符串转为 LongLong 数据
+    if bit64.strtoll then
+		local data = bit64.strtoll("864040064024194", 10)
+		log.info("data", data:toHex())
+		log.info("data", bit64.show(data))
+	end
+end
+
+--获取高精度 tick，输出转换好的 64 位结构
+local function sys_run_time()
+	local tick64, per = mcu.tick64(true)
+	local per_cnt = per * 1000000
+	while true do
+		tick64, per = mcu.tick64(true)
+		log.info("work time","当前时间", bit64.to32(bit64.pide(tick64,per_cnt)))
+		sys.wait(1000)
+	end
+end
+
+if mcu.tick64 then
+	sys.taskInit(sys_run_time)
+end

module/Air780EPM/demo/bit64/main.lua

@@ -1,114 +1,71 @@
-
--- LuaTools需要PROJECT和VERSION这两个信息
-PROJECT = "bit64_test"
-VERSION = "1.0.0"
-
+--[[
+@module  main
+@summary LuatOS用户应用脚本文件入口，总体调度应用逻辑 
+@version 1.0
+@date    2025.10.14
+@author  沈园园
+@usage
+本demo演示的核心功能为：
+演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算
+更多说明参考本目录下的readme.md文件
+]]
+
+
+--[[
+必须定义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 = "luatos_bit64_app"
+VERSION = "001.000.000"
+
+
+-- 在日志中打印项目名和项目版本号
 log.info("main", PROJECT, VERSION)
 
--- 引入必要的库文件(lua编写), 内部库不需要require
-sys = require("sys")
-
--- Air780E的AT固件默认会为开机键防抖, 导致部分用户刷机很麻烦
-if rtos.bsp() == "EC618" and pm and pm.PWK_MODE then
-    pm.power(pm.PWK_MODE, false)
-end
-
 
+-- 如果内核固件支持wdt看门狗功能，此处对看门狗进行初始化和定时喂狗处理
+-- 如果脚本程序死循环卡死，就会无法及时喂狗，最终会自动重启
 if wdt then
-    --添加硬狗防止程序卡死，在支持的设备上启用这个功能
-    wdt.init(9000)--初始化watchdog设置为9s
-    sys.timerLoopStart(wdt.feed, 3000)--3s喂一次狗
+    --配置喂狗超时时间为9秒钟
+    wdt.init(9000)
+    --启动一个循环定时器，每隔3秒钟喂一次狗
+    sys.timerLoopStart(wdt.feed, 3000)
 end
 
 
-local data,b64,b32,a,b
-
-if bit64 then
-	log.style(1)
-	log.info("bit64 演示")
-	data = 12345678
-	b64 = bit64.to64(data)
-	b32 = bit64.to32(b64)
-	log.info("i32", b32, mcu.x32(b32))
-	data = -12345678
-	b64 = bit64.to64(data)
-	b32 = bit64.to32(b64)
-	log.info("i32", b32, mcu.x32(b32))
-	data = 12.34234
-	b64 = bit64.to64(data)
-	b32 = bit64.to32(b64)
-	log.info("f32", data, b32)
-	data = -12.34234
-	b64 = bit64.to64(data)
-	b32 = bit64.to32(b64)
-	log.info("f32", data, b32)
-
+-- 如果内核固件支持errDump功能，此处进行配置，【强烈建议打开此处的注释】
+-- 因为此功能模块可以记录并且上传脚本在运行过程中出现的语法错误或者其他自定义的错误信息，可以初步分析一些设备运行异常的问题
+-- 以下代码是最基本的用法，更复杂的用法可以详细阅读API说明文档
+-- 启动errDump日志存储并且上传功能，600秒上传一次
+-- if errDump then
+--     errDump.config(true, 600)
+-- end
 
-	a = bit64.to64(87654321)
-	b = bit64.to64(12345678)
-	log.info("87654321+12345678=", bit64.show(bit64.plus(a,b)))
-	log.info("87654321-12345678=", bit64.show(bit64.minus(a,b)))
-	log.info("87654321*12345678=", bit64.show(bit64.multi(a,b)))
-	log.info("87654321/12345678=", bit64.show(bit64.pide(a,b)))
 
-	a = bit64.to64(87654321)
-	b = 1234567
-	log.info("87654321+1234567=", bit64.show(bit64.plus(a,b)))
-	log.info("87654321-1234567=", bit64.show(bit64.minus(a,b)))
-	log.info("87654321*1234567=", bit64.show(bit64.multi(a,b)))
-	log.info("87654321/1234567=", bit64.show(bit64.pide(a,b)))
+-- 使用LuatOS开发的任何一个项目，都强烈建议使用远程升级FOTA功能
+-- 可以使用合宙的iot.openluat.com平台进行远程升级
+-- 也可以使用客户自己搭建的平台进行远程升级
+-- 远程升级的详细用法，可以参考fota的demo进行使用
 
 
-	a = bit64.to64(87654.326)
-	b = bit64.to64(12345)
-	log.info("87654.326+12345=", 87654.326 + 12345)
-	log.info("87654.326+12345=", bit64.show(bit64.plus(a,b)))
-	log.info("87654.326-12345=", bit64.show(bit64.minus(a,b)))
-	log.info("87654.326*12345=", bit64.show(bit64.multi(a,b)))
-	log.info("87654.326/12345=", bit64.show(bit64.pide(a,b)))
+-- 启动一个循环定时器
+-- 每隔3秒钟打印一次总内存，实时的已使用内存，历史最高的已使用内存情况
+-- 方便分析内存使用是否有异常
+-- sys.timerLoopStart(function()
+--     log.info("mem.lua", rtos.meminfo())
+--     log.info("mem.sys", rtos.meminfo("sys"))
+-- end, 3000)
 
-	a = bit64.to64(87654.32)
-	b = bit64.to64(12345.67)
-	log.info("float", "87654.32+12345.67=", 87654.32 + 12345.67)
-	log.info("double","87654.32+12345.67=", bit64.show(bit64.plus(a,b)))
-	log.info("double to float","87654.32+12345.67=", bit64.to32(bit64.plus(a,b)))
-	log.info("87654.32-12345.67=", bit64.show(bit64.minus(a,b)))
-	log.info("87654.32*12345.67=", bit64.show(bit64.multi(a,b)))
-	log.info("87654.32/12345.67=", bit64.show(bit64.pide(a,b)))
-	log.info("double to int64", "87654.32/12345.67=", bit64.show(bit64.pide(a,b,nil,true)))
-
-	a = bit64.to64(0xc0000000)
-	b = 2
-	a = bit64.shift(a,8,true)
-	log.info("0xc0000000 << 8 =", bit64.show(a, 16))
-	log.info("0xc000000000+2=", bit64.show(bit64.plus(a,b), 16))
-	log.info("0xc000000000-2=", bit64.show(bit64.minus(a,b), 16))
-	log.info("0xc000000000*2=", bit64.show(bit64.multi(a,b), 16))
-	log.info("0xc000000000/2=", bit64.show(bit64.pide(a,b), 16))
-	log.style(0)
-
-	if bit64.strtoll then
-		local data = bit64.strtoll("864040064024194", 10)
-		log.info("data", data:toHex())
-		log.info("data", bit64.show(data))
-	end
-end
-
-local function sys_run_time()
-	local tick64, per = mcu.tick64(true)
-	local per_cnt = per * 1000000
-	while true do
-		tick64, per = mcu.tick64(true)
-		log.info("work time","当前时间", bit64.to32(bit64.pide(tick64,per_cnt)))
-		sys.wait(1000)
-	end
-end
-
-if mcu.tick64 then
-	sys.taskInit(sys_run_time)
-end
+-- 加载bit64_app应用功能模块
+require "bit64_app"
 
 -- 用户代码已结束---------------------------------------------
 -- 结尾总是这一句
 sys.run()
--- sys.run()之后后面不要加任何语句!!!!!
+-- sys.run()之后不要加任何语句!!!!!因为添加的任何语句都不会被执行

module/Air780EPM/demo/bit64/readme.md

@@ -0,0 +1,81 @@
+## 功能模块介绍
+
+1、main.lua：主程序入口；
+
+2、bit64_app.lua：32 位系统上对 64 位数据的基本算术运算和逻辑运算；
+
+## 演示功能概述
+
+1、创建一个task；
+
+2、演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算；
+
+
+## 演示硬件环境
+
+![](https://docs.openluat.com/air780epm/luatos/common/hwenv/image/Air780EPM2.png)
+
+1、Air780EPM核心板一块
+
+2、TYPE-C USB数据线一根
+
+3、Air780EPM核心板和数据线的硬件接线方式为
+
+- Air780EPM核心板通过TYPE-C USB口连接TYPE-C USB 数据线，数据线的另外一端连接电脑的USB口；
+- 核心板正面的 ON/OFF 拨动开关 拨到ON一端；
+
+
+## 演示软件环境
+
+1、[Luatools下载调试工具](https://docs.openluat.com/air780epm/luatos/common/download/)
+
+2、[Air780EPM 最新版本的内核固件](https://docs.openluat.com/air780epm/luatos/firmware/version/)
+
+
+## 演示核心步骤
+
+1、搭建好硬件环境
+
+2、Luatools烧录内核固件和demo脚本代码
+
+3、烧录成功后，自动开机运行
+
+4、出现类似于下面的日志，就表示运行成功：
+
+``` lua
+[2025-10-15 11:10:19.702][000000000.210] I/bit64_luatos.lua:24 bit64 演示
+[2025-10-15 11:10:19.706][000000000.211] I/bit64_luatos.lua:31 i32 123456 0x1e240
+[2025-10-15 11:10:19.713][000000000.211] I/bit64_luatos.lua:36 i32 12345678 0xbc614e
+[2025-10-15 11:10:19.721][000000000.211] I/bit64_luatos.lua:40 i32 -12345678 0xff439eb2
+[2025-10-15 11:10:19.727][000000000.212] I/bit64_luatos.lua:44 f32   12.3423   12.3423
+[2025-10-15 11:10:19.734][000000000.212] I/bit64_luatos.lua:48 f32  -12.3423  -12.3423
+[2025-10-15 11:10:19.742][000000000.212] I/bit64_luatos.lua:58 87654321+12345678= 99999999
+[2025-10-15 11:10:19.747][000000000.213] I/bit64_luatos.lua:59 87654321-12345678= 75308643
+[2025-10-15 11:10:19.752][000000000.213] I/bit64_luatos.lua:60 87654321*12345678= 1082152022374638
+[2025-10-15 11:10:19.757][000000000.213] I/bit64_luatos.lua:61 87654321/12345678= 7
+[2025-10-15 11:10:19.763][000000000.213] I/bit64_luatos.lua:66 87654321+1234567= 88888888
+[2025-10-15 11:10:19.768][000000000.214] I/bit64_luatos.lua:67 87654321-1234567= 86419754
+[2025-10-15 11:10:19.773][000000000.214] I/bit64_luatos.lua:68 87654321*1234567= 108215132114007
+[2025-10-15 11:10:19.777][000000000.214] I/bit64_luatos.lua:69 87654321/1234567= 71
+[2025-10-15 11:10:19.784][000000000.214] I/bit64_luatos.lua:75 87654.326+12345=   99999.3
+[2025-10-15 11:10:19.789][000000000.215] I/bit64_luatos.lua:76 87654.326+12345= 99999.328125
+[2025-10-15 11:10:19.794][000000000.215] I/bit64_luatos.lua:77 87654.326-12345= 75309.328125
+[2025-10-15 11:10:19.799][000000000.215] I/bit64_luatos.lua:78 87654.326*12345= 1.082093e+09
+[2025-10-15 11:10:19.804][000000000.216] I/bit64_luatos.lua:79 87654.326/12345= 7.100391
+[2025-10-15 11:10:19.811][000000000.216] I/bit64_luatos.lua:84 float 87654.32+12345.67=  100000.0
+[2025-10-15 11:10:19.816][000000000.216] I/bit64_luatos.lua:85 double 87654.32+12345.67= 99999.990234
+[2025-10-15 11:10:19.823][000000000.217] I/bit64_luatos.lua:86 double to float 87654.32+12345.67=  100000.0
+[2025-10-15 11:10:19.827][000000000.217] I/bit64_luatos.lua:87 87654.32-12345.67= 75308.650391
+[2025-10-15 11:10:19.832][000000000.217] I/bit64_luatos.lua:88 87654.32*12345.67= 1.082151e+09
+[2025-10-15 11:10:19.836][000000000.218] I/bit64_luatos.lua:89 87654.32/12345.67= 7.100005
+[2025-10-15 11:10:19.842][000000000.218] I/bit64_luatos.lua:90 double to int64 87654.32/12345.67= 7
+[2025-10-15 11:10:19.849][000000000.218] I/bit64_luatos.lua:96 0xc0000000 << 8 = 0xc000000000
+[2025-10-15 11:10:19.853][000000000.218] I/bit64_luatos.lua:97 0xc000000000+2= 0xc000000002
+[2025-10-15 11:10:19.860][000000000.219] I/bit64_luatos.lua:98 0xc000000000-2= 0xbffffffffe
+[2025-10-15 11:10:19.867][000000000.219] I/bit64_luatos.lua:99 0xc000000000*2= 0x18000000000
+[2025-10-15 11:10:19.871][000000000.219] I/bit64_luatos.lua:100 0xc000000000/2= 0x6000000000
+[2025-10-15 11:10:19.876][000000000.219] I/user.data 827E1601D711030000 18
+[2025-10-15 11:10:19.882][000000000.220] I/user.data 864040064024194
+[2025-10-15 11:10:19.887][000000000.220] I/user.work time 当前时间 0
+[2025-10-15 11:10:20.345][000000001.220] I/user.work time 当前时间 1
+```

module/Air8000/demo/bit64/bit64_app.lua

@@ -0,0 +1,124 @@
+--[[
+@module  bit64_app
+@summary bit64_app应用功能模块 
+@version 1.0
+@date    2025.10.14
+@author  沈园园
+@usage
+本文件为bit64应用功能模块，核心业务逻辑为：
+1、演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算；
+
+本文件没有对外接口，直接在main.lua中require "bit64_app"就可以加载运行；
+]]
+
+--定义几个变量
+local data,b64,b32,a,b
+
+--设置调试风格1: I/main.lua:12 ABC DEF 123（在开头添加文件位置信息）
+log.style(1)
+
+--本文的64bit数据为：小端格式的9字节数据的字符串，最后一个字节是类型（0是整数，1是浮点）, 前面8个字节是数据。
+--十进制转123456对应64bit十六进制字符串"40E2010000000000"
+
+if bit64 then
+	log.info("bit64 演示")
+    
+    --将数据进行 32 位和 64 位互转
+    --123456对应64bit的9字节数据HEX字符
+    data = "40E201000000000000"
+    --需将HEX字符串转成Lua字符串填入 
+    b32 = bit64.to32(data:fromHex())
+    log.info("i32", b32, mcu.x32(b32))    
+    
+    data = 12345678
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("i32", b32, mcu.x32(b32))
+	data = -12345678
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("i32", b32, mcu.x32(b32))
+	data = 12.34234
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("f32", data, b32)
+	data = -12.34234
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("f32", data, b32)
+
+    --64 位数据之间进行运算
+    --64bit数据格式化打印成字符串，用于显示值
+    --64bit数据加,a+b,a和b中有一个为浮点，则按照浮点运算
+    --64bit数据减,a-b,a和b中有一个为浮点，则按照浮点运算
+    --64bit数据乘,a*b,a和b中有一个为浮点，则按照浮点运算
+    --64bit数据除,a/b,a和b中有一个为浮点，则按照浮点运算
+	a = bit64.to64(87654321)
+	b = bit64.to64(12345678)
+	log.info("87654321+12345678=", bit64.show(bit64.plus(a,b)))
+	log.info("87654321-12345678=", bit64.show(bit64.minus(a,b)))
+	log.info("87654321*12345678=", bit64.show(bit64.multi(a,b)))
+	log.info("87654321/12345678=", bit64.show(bit64.pide(a,b)))
+
+	--64 位与 32 位数据之间进行运算
+    a = bit64.to64(87654321)
+	b = 1234567
+	log.info("87654321+1234567=", bit64.show(bit64.plus(a,b)))
+	log.info("87654321-1234567=", bit64.show(bit64.minus(a,b)))
+	log.info("87654321*1234567=", bit64.show(bit64.multi(a,b)))
+	log.info("87654321/1234567=", bit64.show(bit64.pide(a,b)))
+
+
+	--64 位数据之间，一个数是浮点数进行运算
+    a = bit64.to64(87654.326)
+	b = bit64.to64(12345)
+	log.info("87654.326+12345=", 87654.326 + 12345)
+	log.info("87654.326+12345=", bit64.show(bit64.plus(a,b)))
+	log.info("87654.326-12345=", bit64.show(bit64.minus(a,b)))
+	log.info("87654.326*12345=", bit64.show(bit64.multi(a,b)))
+	log.info("87654.326/12345=", bit64.show(bit64.pide(a,b)))
+
+	--64 位浮点数计算
+    a = bit64.to64(87654.32)
+	b = bit64.to64(12345.67)
+	log.info("float", "87654.32+12345.67=", 87654.32 + 12345.67)
+	log.info("double","87654.32+12345.67=", bit64.show(bit64.plus(a,b)))
+	log.info("double to float","87654.32+12345.67=", bit64.to32(bit64.plus(a,b)))
+	log.info("87654.32-12345.67=", bit64.show(bit64.minus(a,b)))
+	log.info("87654.32*12345.67=", bit64.show(bit64.multi(a,b)))
+	log.info("87654.32/12345.67=", bit64.show(bit64.pide(a,b)))
+	log.info("double to int64", "87654.32/12345.67=", bit64.show(bit64.pide(a,b,nil,true)))
+
+	--64 位数据移位操作
+    a = bit64.to64(0xc0000000)
+	b = 2
+	a = bit64.shift(a,8,true)
+	log.info("0xc0000000 << 8 =", bit64.show(a, 16))
+	log.info("0xc000000000+2=", bit64.show(bit64.plus(a,b), 16))
+	log.info("0xc000000000-2=", bit64.show(bit64.minus(a,b), 16))
+	log.info("0xc000000000*2=", bit64.show(bit64.multi(a,b), 16))
+	log.info("0xc000000000/2=", bit64.show(bit64.pide(a,b), 16))
+	log.style(0)
+
+	--将字符串转为 LongLong 数据
+    if bit64.strtoll then
+		local data = bit64.strtoll("864040064024194", 10)
+		log.info("data", data:toHex())
+		log.info("data", bit64.show(data))
+	end
+end
+
+--获取高精度 tick，输出转换好的 64 位结构
+local function sys_run_time()
+	local tick64, per = mcu.tick64(true)
+	local per_cnt = per * 1000000
+	while true do
+		tick64, per = mcu.tick64(true)
+		log.info("work time","当前时间", bit64.to32(bit64.pide(tick64,per_cnt)))
+		sys.wait(1000)
+	end
+end
+
+if mcu.tick64 then
+	sys.taskInit(sys_run_time)
+end

module/Air8000/demo/bit64/main.lua

@@ -1,110 +1,71 @@
-
--- LuaTools需要PROJECT和VERSION这两个信息
-PROJECT = "bit64_test"
-VERSION = "1.0.0"
-
+--[[
+@module  main
+@summary LuatOS用户应用脚本文件入口，总体调度应用逻辑 
+@version 1.0
+@date    2025.10.14
+@author  沈园园
+@usage
+本demo演示的核心功能为：
+演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算
+更多说明参考本目录下的readme.md文件
+]]
+
+
+--[[
+必须定义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 = "luatos_bit64_app"
+VERSION = "001.000.000"
+
+
+-- 在日志中打印项目名和项目版本号
 log.info("main", PROJECT, VERSION)
 
--- 引入必要的库文件(lua编写), 内部库不需要require
-sys = require("sys")
-
-
 
+-- 如果内核固件支持wdt看门狗功能，此处对看门狗进行初始化和定时喂狗处理
+-- 如果脚本程序死循环卡死，就会无法及时喂狗，最终会自动重启
 if wdt then
-    --添加硬狗防止程序卡死，在支持的设备上启用这个功能
-    wdt.init(9000)--初始化watchdog设置为9s
-    sys.timerLoopStart(wdt.feed, 3000)--3s喂一次狗
+    --配置喂狗超时时间为9秒钟
+    wdt.init(9000)
+    --启动一个循环定时器，每隔3秒钟喂一次狗
+    sys.timerLoopStart(wdt.feed, 3000)
 end
 
 
-local data,b64,b32,a,b
-
-if bit64 then
-	log.style(1)
-	log.info("bit64 演示")
-	data = 12345678
-	b64 = bit64.to64(data)
-	b32 = bit64.to32(b64)
-	log.info("i32", b32, mcu.x32(b32))
-	data = -12345678
-	b64 = bit64.to64(data)
-	b32 = bit64.to32(b64)
-	log.info("i32", b32, mcu.x32(b32))
-	data = 12.34234
-	b64 = bit64.to64(data)
-	b32 = bit64.to32(b64)
-	log.info("f32", data, b32)
-	data = -12.34234
-	b64 = bit64.to64(data)
-	b32 = bit64.to32(b64)
-	log.info("f32", data, b32)
-
-
-	a = bit64.to64(87654321)
-	b = bit64.to64(12345678)
-	log.info("87654321+12345678=", bit64.show(bit64.plus(a,b)))
-	log.info("87654321-12345678=", bit64.show(bit64.minus(a,b)))
-	log.info("87654321*12345678=", bit64.show(bit64.multi(a,b)))
-	log.info("87654321/12345678=", bit64.show(bit64.pide(a,b)))
+-- 如果内核固件支持errDump功能，此处进行配置，【强烈建议打开此处的注释】
+-- 因为此功能模块可以记录并且上传脚本在运行过程中出现的语法错误或者其他自定义的错误信息，可以初步分析一些设备运行异常的问题
+-- 以下代码是最基本的用法，更复杂的用法可以详细阅读API说明文档
+-- 启动errDump日志存储并且上传功能，600秒上传一次
+-- if errDump then
+--     errDump.config(true, 600)
+-- end
 
-	a = bit64.to64(87654321)
-	b = 1234567
-	log.info("87654321+1234567=", bit64.show(bit64.plus(a,b)))
-	log.info("87654321-1234567=", bit64.show(bit64.minus(a,b)))
-	log.info("87654321*1234567=", bit64.show(bit64.multi(a,b)))
-	log.info("87654321/1234567=", bit64.show(bit64.pide(a,b)))
 
+-- 使用LuatOS开发的任何一个项目，都强烈建议使用远程升级FOTA功能
+-- 可以使用合宙的iot.openluat.com平台进行远程升级
+-- 也可以使用客户自己搭建的平台进行远程升级
+-- 远程升级的详细用法，可以参考fota的demo进行使用
 
-	a = bit64.to64(87654.326)
-	b = bit64.to64(12345)
-	log.info("87654.326+12345=", 87654.326 + 12345)
-	log.info("87654.326+12345=", bit64.show(bit64.plus(a,b)))
-	log.info("87654.326-12345=", bit64.show(bit64.minus(a,b)))
-	log.info("87654.326*12345=", bit64.show(bit64.multi(a,b)))
-	log.info("87654.326/12345=", bit64.show(bit64.pide(a,b)))
 
-	a = bit64.to64(87654.32)
-	b = bit64.to64(12345.67)
-	log.info("float", "87654.32+12345.67=", 87654.32 + 12345.67)
-	log.info("double","87654.32+12345.67=", bit64.show(bit64.plus(a,b)))
-	log.info("double to float","87654.32+12345.67=", bit64.to32(bit64.plus(a,b)))
-	log.info("87654.32-12345.67=", bit64.show(bit64.minus(a,b)))
-	log.info("87654.32*12345.67=", bit64.show(bit64.multi(a,b)))
-	log.info("87654.32/12345.67=", bit64.show(bit64.pide(a,b)))
-	log.info("double to int64", "87654.32/12345.67=", bit64.show(bit64.pide(a,b,nil,true)))
+-- 启动一个循环定时器
+-- 每隔3秒钟打印一次总内存，实时的已使用内存，历史最高的已使用内存情况
+-- 方便分析内存使用是否有异常
+-- sys.timerLoopStart(function()
+--     log.info("mem.lua", rtos.meminfo())
+--     log.info("mem.sys", rtos.meminfo("sys"))
+-- end, 3000)
 
-	a = bit64.to64(0xc0000000)
-	b = 2
-	a = bit64.shift(a,8,true)
-	log.info("0xc0000000 << 8 =", bit64.show(a, 16))
-	log.info("0xc000000000+2=", bit64.show(bit64.plus(a,b), 16))
-	log.info("0xc000000000-2=", bit64.show(bit64.minus(a,b), 16))
-	log.info("0xc000000000*2=", bit64.show(bit64.multi(a,b), 16))
-	log.info("0xc000000000/2=", bit64.show(bit64.pide(a,b), 16))
-	log.style(0)
-
-	if bit64.strtoll then
-		local data = bit64.strtoll("864040064024194", 10)
-		log.info("data", data:toHex())
-		log.info("data", bit64.show(data))
-	end
-end
-
-local function sys_run_time()
-	local tick64, per = mcu.tick64(true)
-	local per_cnt = per * 1000000
-	while true do
-		tick64, per = mcu.tick64(true)
-		log.info("work time","当前时间", bit64.to32(bit64.pide(tick64,per_cnt)))
-		sys.wait(1000)
-	end
-end
-
-if mcu.tick64 then
-	sys.taskInit(sys_run_time)
-end
+-- 加载bit64_app应用功能模块
+require "bit64_app"
 
 -- 用户代码已结束---------------------------------------------
 -- 结尾总是这一句
 sys.run()
--- sys.run()之后后面不要加任何语句!!!!!
+-- sys.run()之后不要加任何语句!!!!!因为添加的任何语句都不会被执行

module/Air8000/demo/bit64/readme.md

@@ -0,0 +1,82 @@
+## 功能模块介绍
+
+1、main.lua：主程序入口；
+
+2、bit64_app.lua：32 位系统上对 64 位数据的基本算术运算和逻辑运算；
+
+## 演示功能概述
+
+1、创建一个task；
+
+2、演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算；
+
+
+## 演示硬件环境
+
+![](https://docs.openluat.com/luatos_lesson/image/Evh1bVjatoG1rCxhrdpc9ny7nVf.png)
+
+1、Air8000核心板一块
+
+2、TYPE-C USB数据线一根
+
+3、Air8000核心板和数据线的硬件接线方式为
+
+- Air8000核心板通过TYPE-C USB口连接TYPE-C USB 数据线，数据线的另外一端连接电脑的USB口；
+- 核心板正面的 供电/充电 拨动开关 拨到供电一端；
+- 核心板背面的 USB ON/USB OFF 拨动开关 拨到USB ON一端；
+
+
+## 演示软件环境
+
+1、[Luatools下载调试工具](https://docs.openluat.com/air8000/luatos/common/download/)
+
+2、[Air8000 最新版本的内核固件](https://docs.openluat.com/air8000/luatos/firmware/)
+
+
+## 演示核心步骤
+
+1、搭建好硬件环境
+
+2、Luatools烧录内核固件和demo脚本代码
+
+3、烧录成功后，自动开机运行
+
+4、出现类似于下面的日志，就表示运行成功：
+
+``` lua
+[2025-10-15 11:10:19.702][000000000.210] I/bit64_luatos.lua:24 bit64 演示
+[2025-10-15 11:10:19.706][000000000.211] I/bit64_luatos.lua:31 i32 123456 0x1e240
+[2025-10-15 11:10:19.713][000000000.211] I/bit64_luatos.lua:36 i32 12345678 0xbc614e
+[2025-10-15 11:10:19.721][000000000.211] I/bit64_luatos.lua:40 i32 -12345678 0xff439eb2
+[2025-10-15 11:10:19.727][000000000.212] I/bit64_luatos.lua:44 f32   12.3423   12.3423
+[2025-10-15 11:10:19.734][000000000.212] I/bit64_luatos.lua:48 f32  -12.3423  -12.3423
+[2025-10-15 11:10:19.742][000000000.212] I/bit64_luatos.lua:58 87654321+12345678= 99999999
+[2025-10-15 11:10:19.747][000000000.213] I/bit64_luatos.lua:59 87654321-12345678= 75308643
+[2025-10-15 11:10:19.752][000000000.213] I/bit64_luatos.lua:60 87654321*12345678= 1082152022374638
+[2025-10-15 11:10:19.757][000000000.213] I/bit64_luatos.lua:61 87654321/12345678= 7
+[2025-10-15 11:10:19.763][000000000.213] I/bit64_luatos.lua:66 87654321+1234567= 88888888
+[2025-10-15 11:10:19.768][000000000.214] I/bit64_luatos.lua:67 87654321-1234567= 86419754
+[2025-10-15 11:10:19.773][000000000.214] I/bit64_luatos.lua:68 87654321*1234567= 108215132114007
+[2025-10-15 11:10:19.777][000000000.214] I/bit64_luatos.lua:69 87654321/1234567= 71
+[2025-10-15 11:10:19.784][000000000.214] I/bit64_luatos.lua:75 87654.326+12345=   99999.3
+[2025-10-15 11:10:19.789][000000000.215] I/bit64_luatos.lua:76 87654.326+12345= 99999.328125
+[2025-10-15 11:10:19.794][000000000.215] I/bit64_luatos.lua:77 87654.326-12345= 75309.328125
+[2025-10-15 11:10:19.799][000000000.215] I/bit64_luatos.lua:78 87654.326*12345= 1.082093e+09
+[2025-10-15 11:10:19.804][000000000.216] I/bit64_luatos.lua:79 87654.326/12345= 7.100391
+[2025-10-15 11:10:19.811][000000000.216] I/bit64_luatos.lua:84 float 87654.32+12345.67=  100000.0
+[2025-10-15 11:10:19.816][000000000.216] I/bit64_luatos.lua:85 double 87654.32+12345.67= 99999.990234
+[2025-10-15 11:10:19.823][000000000.217] I/bit64_luatos.lua:86 double to float 87654.32+12345.67=  100000.0
+[2025-10-15 11:10:19.827][000000000.217] I/bit64_luatos.lua:87 87654.32-12345.67= 75308.650391
+[2025-10-15 11:10:19.832][000000000.217] I/bit64_luatos.lua:88 87654.32*12345.67= 1.082151e+09
+[2025-10-15 11:10:19.836][000000000.218] I/bit64_luatos.lua:89 87654.32/12345.67= 7.100005
+[2025-10-15 11:10:19.842][000000000.218] I/bit64_luatos.lua:90 double to int64 87654.32/12345.67= 7
+[2025-10-15 11:10:19.849][000000000.218] I/bit64_luatos.lua:96 0xc0000000 << 8 = 0xc000000000
+[2025-10-15 11:10:19.853][000000000.218] I/bit64_luatos.lua:97 0xc000000000+2= 0xc000000002
+[2025-10-15 11:10:19.860][000000000.219] I/bit64_luatos.lua:98 0xc000000000-2= 0xbffffffffe
+[2025-10-15 11:10:19.867][000000000.219] I/bit64_luatos.lua:99 0xc000000000*2= 0x18000000000
+[2025-10-15 11:10:19.871][000000000.219] I/bit64_luatos.lua:100 0xc000000000/2= 0x6000000000
+[2025-10-15 11:10:19.876][000000000.219] I/user.data 827E1601D711030000 18
+[2025-10-15 11:10:19.882][000000000.220] I/user.data 864040064024194
+[2025-10-15 11:10:19.887][000000000.220] I/user.work time 当前时间 0
+[2025-10-15 11:10:20.345][000000001.220] I/user.work time 当前时间 1
+```

module/Air8101/demo/bit64/bit64_app.lua

@@ -0,0 +1,124 @@
+--[[
+@module  bit64_app
+@summary bit64_app应用功能模块 
+@version 1.0
+@date    2025.10.14
+@author  沈园园
+@usage
+本文件为bit64应用功能模块，核心业务逻辑为：
+1、演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算；
+
+本文件没有对外接口，直接在main.lua中require "bit64_app"就可以加载运行；
+]]
+
+--定义几个变量
+local data,b64,b32,a,b
+
+--设置调试风格1: I/main.lua:12 ABC DEF 123（在开头添加文件位置信息）
+log.style(1)
+
+--本文的64bit数据为：小端格式的9字节数据的字符串，最后一个字节是类型（0是整数，1是浮点）, 前面8个字节是数据。
+--十进制转123456对应64bit十六进制字符串"40E2010000000000"
+
+if bit64 then
+	log.info("bit64 演示")
+    
+    --将数据进行 32 位和 64 位互转
+    --123456对应64bit的9字节数据HEX字符
+    data = "40E201000000000000"
+    --需将HEX字符串转成Lua字符串填入 
+    b32 = bit64.to32(data:fromHex())
+    log.info("i32", b32, mcu.x32(b32))    
+    
+    data = 12345678
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("i32", b32, mcu.x32(b32))
+	data = -12345678
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("i32", b32, mcu.x32(b32))
+	data = 12.34234
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("f32", data, b32)
+	data = -12.34234
+	b64 = bit64.to64(data)
+	b32 = bit64.to32(b64)
+	log.info("f32", data, b32)
+
+    --64 位数据之间进行运算
+    --64bit数据格式化打印成字符串，用于显示值
+    --64bit数据加,a+b,a和b中有一个为浮点，则按照浮点运算
+    --64bit数据减,a-b,a和b中有一个为浮点，则按照浮点运算
+    --64bit数据乘,a*b,a和b中有一个为浮点，则按照浮点运算
+    --64bit数据除,a/b,a和b中有一个为浮点，则按照浮点运算
+	a = bit64.to64(87654321)
+	b = bit64.to64(12345678)
+	log.info("87654321+12345678=", bit64.show(bit64.plus(a,b)))
+	log.info("87654321-12345678=", bit64.show(bit64.minus(a,b)))
+	log.info("87654321*12345678=", bit64.show(bit64.multi(a,b)))
+	log.info("87654321/12345678=", bit64.show(bit64.pide(a,b)))
+
+	--64 位与 32 位数据之间进行运算
+    a = bit64.to64(87654321)
+	b = 1234567
+	log.info("87654321+1234567=", bit64.show(bit64.plus(a,b)))
+	log.info("87654321-1234567=", bit64.show(bit64.minus(a,b)))
+	log.info("87654321*1234567=", bit64.show(bit64.multi(a,b)))
+	log.info("87654321/1234567=", bit64.show(bit64.pide(a,b)))
+
+
+	--64 位数据之间，一个数是浮点数进行运算
+    a = bit64.to64(87654.326)
+	b = bit64.to64(12345)
+	log.info("87654.326+12345=", 87654.326 + 12345)
+	log.info("87654.326+12345=", bit64.show(bit64.plus(a,b)))
+	log.info("87654.326-12345=", bit64.show(bit64.minus(a,b)))
+	log.info("87654.326*12345=", bit64.show(bit64.multi(a,b)))
+	log.info("87654.326/12345=", bit64.show(bit64.pide(a,b)))
+
+	--64 位浮点数计算
+    a = bit64.to64(87654.32)
+	b = bit64.to64(12345.67)
+	log.info("float", "87654.32+12345.67=", 87654.32 + 12345.67)
+	log.info("double","87654.32+12345.67=", bit64.show(bit64.plus(a,b)))
+	log.info("double to float","87654.32+12345.67=", bit64.to32(bit64.plus(a,b)))
+	log.info("87654.32-12345.67=", bit64.show(bit64.minus(a,b)))
+	log.info("87654.32*12345.67=", bit64.show(bit64.multi(a,b)))
+	log.info("87654.32/12345.67=", bit64.show(bit64.pide(a,b)))
+	log.info("double to int64", "87654.32/12345.67=", bit64.show(bit64.pide(a,b,nil,true)))
+
+	--64 位数据移位操作
+    a = bit64.to64(0xc0000000)
+	b = 2
+	a = bit64.shift(a,8,true)
+	log.info("0xc0000000 << 8 =", bit64.show(a, 16))
+	log.info("0xc000000000+2=", bit64.show(bit64.plus(a,b), 16))
+	log.info("0xc000000000-2=", bit64.show(bit64.minus(a,b), 16))
+	log.info("0xc000000000*2=", bit64.show(bit64.multi(a,b), 16))
+	log.info("0xc000000000/2=", bit64.show(bit64.pide(a,b), 16))
+	log.style(0)
+
+	--将字符串转为 LongLong 数据
+    if bit64.strtoll then
+		local data = bit64.strtoll("864040064024194", 10)
+		log.info("data", data:toHex())
+		log.info("data", bit64.show(data))
+	end
+end
+
+--获取高精度 tick，输出转换好的 64 位结构
+local function sys_run_time()
+	local tick64, per = mcu.tick64(true)
+	local per_cnt = per * 1000000
+	while true do
+		tick64, per = mcu.tick64(true)
+		log.info("work time","当前时间", bit64.to32(bit64.pide(tick64,per_cnt)))
+		sys.wait(1000)
+	end
+end
+
+if mcu.tick64 then
+	sys.taskInit(sys_run_time)
+end

module/Air8101/demo/bit64/main.lua

@@ -1,153 +1,71 @@
-
--- LuaTools需要PROJECT和VERSION这两个信息
-PROJECT = "bit64_test"
-VERSION = "1.0.0"
-
+--[[
+@module  main
+@summary LuatOS用户应用脚本文件入口，总体调度应用逻辑 
+@version 1.0
+@date    2025.10.14
+@author  沈园园
+@usage
+本demo演示的核心功能为：
+演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算
+更多说明参考本目录下的readme.md文件
+]]
+
+
+--[[
+必须定义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 = "luatos_bit64_app"
+VERSION = "001.000.000"
+
+
+-- 在日志中打印项目名和项目版本号
 log.info("main", PROJECT, VERSION)
 
-if rtos.bsp() == "EC618" and pm and pm.PWK_MODE then
-    pm.power(pm.PWK_MODE, false)
-end
-
 
+-- 如果内核固件支持wdt看门狗功能，此处对看门狗进行初始化和定时喂狗处理
+-- 如果脚本程序死循环卡死，就会无法及时喂狗，最终会自动重启
 if wdt then
-    --添加硬狗防止程序卡死，在支持的设备上启用这个功能
-    wdt.init(9000)--初始化watchdog设置为9s
-    sys.timerLoopStart(wdt.feed, 3000)--3s喂一次狗
+    --配置喂狗超时时间为9秒钟
+    wdt.init(9000)
+    --启动一个循环定时器，每隔3秒钟喂一次狗
+    sys.timerLoopStart(wdt.feed, 3000)
 end
 
 
-local data,b64,b32,a,b
-if bit64 then
-	log.style(1)
-
--- 2.1 将数据进行 32 位和 64 位互转
-    log.info("bit64 演示")
-    log.info("-- 2.1")
-    data = 12345678
-    -- 32bit数据转成64bit数据
-    b64 = bit64.to64(data)
-    -- 64bit数据转成32bit输出
-    b32 = bit64.to32(b64)
-    log.info("i32", b32, mcu.x32(b32))
-    data = -12345678
-    b64 = bit64.to64(data)
-    b32 = bit64.to32(b64)
-    log.info("i32", b32, mcu.x32(b32))
-    data = 12.34234
-    b64 = bit64.to64(data)
-    b32 = bit64.to32(b64)
-    log.info("f32", data, b32)
-    data = -12.34234
-    b64 = bit64.to64(data)
-    b32 = bit64.to32(b64)
-    log.info("f32", data, b32)
-
--- 2.2 64 位数据之间进行运算
-    log.info("-- 2.2")
-    a = bit64.to64(87654321)
-    b = bit64.to64(12345678)
-    -- 64bit数据格式化打印成字符串，用于显示值。64bit数据加,a+b,a和b中有一个为浮点，则按照浮点运算
-    -- 64bit数据加,a+b,a和b中有一个为浮点，则按照浮点运算
-    log.info("87654321+12345678=", bit64.show(bit64.plus(a,b)))
-    -- 64bit数据减,a-b,a和b中有一个为浮点，则按照浮点运算
-    log.info("87654321-12345678=", bit64.show(bit64.minus(a,b)))
-    -- 64bit数据乘,a*b,a和b中有一个为浮点，则按照浮点运算
-    log.info("87654321*12345678=", bit64.show(bit64.multi(a,b)))
-    -- 64bit数据除,a/b,a和b中有一个为浮点，则按照浮点运算
-    log.info("87654321/12345678=", bit64.show(bit64.pide(a,b)))
-
--- 2.3 64 位与 32 位数据之间进行运算
-    log.info("-- 2.3")
-    a = bit64.to64(87654321)
-    b = bit64.to64(12345678)
-    -- 64bit数据格式化打印成字符串，用于显示值。64bit数据加,a+b,a和b中有一个为浮点，则按照浮点运算
-    -- 64bit数据加,a+b,a和b中有一个为浮点，则按照浮点运算
-    log.info("87654321+12345678=", bit64.show(bit64.plus(a,b)))
-    -- 64bit数据减,a-b,a和b中有一个为浮点，则按照浮点运算
-    log.info("87654321-12345678=", bit64.show(bit64.minus(a,b)))
-    -- 64bit数据乘,a*b,a和b中有一个为浮点，则按照浮点运算
-    log.info("87654321*12345678=", bit64.show(bit64.multi(a,b)))
-    -- 64bit数据除,a/b,a和b中有一个为浮点，则按照浮点运算
-    log.info("87654321/12345678=", bit64.show(bit64.pide(a,b)))
+-- 如果内核固件支持errDump功能，此处进行配置，【强烈建议打开此处的注释】
+-- 因为此功能模块可以记录并且上传脚本在运行过程中出现的语法错误或者其他自定义的错误信息，可以初步分析一些设备运行异常的问题
+-- 以下代码是最基本的用法，更复杂的用法可以详细阅读API说明文档
+-- 启动errDump日志存储并且上传功能，600秒上传一次
+-- if errDump then
+--     errDump.config(true, 600)
+-- end
 
--- 2.4 64 位数据之间，一个数是浮点数进行运算
-    log.info("-- 2.4")
-    a = bit64.to64(87654.326)
-    b = bit64.to64(12345)
-    --进行四则运算
-    log.info("87654.326+12345=", 87654.326 + 12345)
-    log.info("87654.326+12345=", bit64.show(bit64.plus(a,b)))
-    log.info("87654.326-12345=", bit64.show(bit64.minus(a,b)))
-    log.info("87654.326*12345=", bit64.show(bit64.multi(a,b)))
-    log.info("87654.326/12345=", bit64.show(bit64.pide(a,b)))
 
--- 2.5 64 位浮点数计算
-    log.info("-- 2.5")
-    a = bit64.to64(87654.32)
-    b = bit64.to64(12345.67)
-    --
-    log.info("float", "87654.32+12345.67=", 87654.32 + 12345.67)
-    log.info("double","87654.32+12345.67=", bit64.show(bit64.plus(a,b)))
-    log.info("double to float","87654.32+12345.67=", bit64.to32(bit64.plus(a,b)))
-    log.info("87654.32-12345.67=", bit64.show(bit64.minus(a,b)))
-    log.info("87654.32*12345.67=", bit64.show(bit64.multi(a,b)))
-    log.info("87654.32/12345.67=", bit64.show(bit64.pide(a,b)))
-    log.info("double to int64", "87654.32/12345.67=", bit64.show(bit64.pide(a,b,nil,true)))
+-- 使用LuatOS开发的任何一个项目，都强烈建议使用远程升级FOTA功能
+-- 可以使用合宙的iot.openluat.com平台进行远程升级
+-- 也可以使用客户自己搭建的平台进行远程升级
+-- 远程升级的详细用法，可以参考fota的demo进行使用
 
--- 2.6 浮点数之间的运算
-    log.info("-- 2.6")
-	a = bit64.to64(87654.32)
-    b = bit64.to64(12345.67)
-    log.info("float", "87654.32+12345.67=", 87654.32 + 12345.67)
-    log.info("double","87654.32+12345.67=", bit64.show(bit64.plus(a,b)))
-    log.info("double to float","87654.32+12345.67=", bit64.to32(bit64.plus(a,b)))
-    log.info("87654.32-12345.67=", bit64.show(bit64.minus(a,b)))
-    log.info("87654.32*12345.67=", bit64.show(bit64.multi(a,b)))
-    log.info("87654.32/12345.67=", bit64.show(bit64.pide(a,b)))
-    log.info("double to int64", "87654.32/12345.67=", bit64.show(bit64.pide(a,b,nil,true)))
 
--- 2.7 64 位数据移位操作
-    log.info("-- 2.7")
-    a = bit64.to64(0xc0000000)
-    b = 2
--- 64bit数据位移 a>>b 或者 a<<b
-    a = bit64.shift(a,8,true)
-    log.info("0xc0000000 << 8 =", bit64.show(a, 16))
-    log.info("0xc000000000+2=", bit64.show(bit64.plus(a,b), 16))
-    log.info("0xc000000000-2=", bit64.show(bit64.minus(a,b), 16))
-    log.info("0xc000000000*2=", bit64.show(bit64.multi(a,b), 16))
-    log.info("0xc000000000/2=", bit64.show(bit64.pide(a,b), 16))
+-- 启动一个循环定时器
+-- 每隔3秒钟打印一次总内存，实时的已使用内存，历史最高的已使用内存情况
+-- 方便分析内存使用是否有异常
+-- sys.timerLoopStart(function()
+--     log.info("mem.lua", rtos.meminfo())
+--     log.info("mem.sys", rtos.meminfo("sys"))
+-- end, 3000)
 
--- 2.8  将字符串转为 LongLong 数据
-    log.info("-- 2.8")
-    if bit64.strtoll then
-        -- 将字符串转为LongLong数据
-        local data = bit64.strtoll("864040064024194", 10)
-        log.info("data", data:toHex())
-        log.info("data", bit64.show(data))
-    end
-end
--- 2.9  获取高精度 tick，输出转换好的 64 位结构
-log.info("-- 2.9")
-local function sys_run_time()
-    -- 获取启动后的高精度tick，如果支持bit64库，可以直接输出转换好的bit64结构
-    local tick64, per = mcu.tick64(true)
-    local per_cnt = per * 1000000
-    while true do
-        tick64, per = mcu.tick64(true)
-
-        log.info("work time","当前时间", bit64.to32(bit64.pide(tick64,per_cnt)))
-        sys.wait(1000)
-    end
-end
-
-
-if mcu.tick64 then
-	sys.taskInit(sys_run_time)
-end
+-- 加载bit64_app应用功能模块
+require "bit64_app"
 
 -- 用户代码已结束---------------------------------------------
 -- 结尾总是这一句
 sys.run()
--- sys.run()之后后面不要加任何语句!!!!!
+-- sys.run()之后不要加任何语句!!!!!因为添加的任何语句都不会被执行

module/Air8101/demo/bit64/readme.md

@@ -0,0 +1,80 @@
+## 功能模块介绍
+
+1、main.lua：主程序入口；
+
+2、bit64_app.lua：32 位系统上对 64 位数据的基本算术运算和逻辑运算；
+
+## 演示功能概述
+
+1、创建一个task；
+
+2、演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算；
+
+## 演示硬件环境
+
+![](https://docs.openluat.com/air8101/luatos/common/hwenv/image/Air8101.png)
+
+1、Air8101核心板一块
+
+2、TYPE-C USB数据线一根
+
+3、Air8101核心板和数据线的硬件接线方式为
+
+- Air8101核心板通过TYPE-C USB口连接TYPE-C USB 数据线，数据线的另外一端连接电脑的USB口；
+- Air8101核心板通过TYPE-C USB口供电（核心板背面的功耗测试开关拨到OFF一端）；
+
+
+## 演示软件环境
+
+1、[Luatools下载调试工具](https://docs.openluat.com/air8101/luatos/common/download/)
+
+2、[Air8101 最新版本的内核固件](https://docs.openluat.com/air8101/luatos/firmware/)
+
+
+## 演示核心步骤
+
+1、搭建好硬件环境
+
+2、Luatools烧录内核固件和demo脚本代码
+
+3、烧录成功后，自动开机运行
+
+4、出现类似于下面的日志，就表示运行成功：
+
+``` lua
+[2025-10-15 11:10:19.702][000000000.210] I/bit64_luatos.lua:24 bit64 演示
+[2025-10-15 11:10:19.706][000000000.211] I/bit64_luatos.lua:31 i32 123456 0x1e240
+[2025-10-15 11:10:19.713][000000000.211] I/bit64_luatos.lua:36 i32 12345678 0xbc614e
+[2025-10-15 11:10:19.721][000000000.211] I/bit64_luatos.lua:40 i32 -12345678 0xff439eb2
+[2025-10-15 11:10:19.727][000000000.212] I/bit64_luatos.lua:44 f32   12.3423   12.3423
+[2025-10-15 11:10:19.734][000000000.212] I/bit64_luatos.lua:48 f32  -12.3423  -12.3423
+[2025-10-15 11:10:19.742][000000000.212] I/bit64_luatos.lua:58 87654321+12345678= 99999999
+[2025-10-15 11:10:19.747][000000000.213] I/bit64_luatos.lua:59 87654321-12345678= 75308643
+[2025-10-15 11:10:19.752][000000000.213] I/bit64_luatos.lua:60 87654321*12345678= 1082152022374638
+[2025-10-15 11:10:19.757][000000000.213] I/bit64_luatos.lua:61 87654321/12345678= 7
+[2025-10-15 11:10:19.763][000000000.213] I/bit64_luatos.lua:66 87654321+1234567= 88888888
+[2025-10-15 11:10:19.768][000000000.214] I/bit64_luatos.lua:67 87654321-1234567= 86419754
+[2025-10-15 11:10:19.773][000000000.214] I/bit64_luatos.lua:68 87654321*1234567= 108215132114007
+[2025-10-15 11:10:19.777][000000000.214] I/bit64_luatos.lua:69 87654321/1234567= 71
+[2025-10-15 11:10:19.784][000000000.214] I/bit64_luatos.lua:75 87654.326+12345=   99999.3
+[2025-10-15 11:10:19.789][000000000.215] I/bit64_luatos.lua:76 87654.326+12345= 99999.328125
+[2025-10-15 11:10:19.794][000000000.215] I/bit64_luatos.lua:77 87654.326-12345= 75309.328125
+[2025-10-15 11:10:19.799][000000000.215] I/bit64_luatos.lua:78 87654.326*12345= 1.082093e+09
+[2025-10-15 11:10:19.804][000000000.216] I/bit64_luatos.lua:79 87654.326/12345= 7.100391
+[2025-10-15 11:10:19.811][000000000.216] I/bit64_luatos.lua:84 float 87654.32+12345.67=  100000.0
+[2025-10-15 11:10:19.816][000000000.216] I/bit64_luatos.lua:85 double 87654.32+12345.67= 99999.990234
+[2025-10-15 11:10:19.823][000000000.217] I/bit64_luatos.lua:86 double to float 87654.32+12345.67=  100000.0
+[2025-10-15 11:10:19.827][000000000.217] I/bit64_luatos.lua:87 87654.32-12345.67= 75308.650391
+[2025-10-15 11:10:19.832][000000000.217] I/bit64_luatos.lua:88 87654.32*12345.67= 1.082151e+09
+[2025-10-15 11:10:19.836][000000000.218] I/bit64_luatos.lua:89 87654.32/12345.67= 7.100005
+[2025-10-15 11:10:19.842][000000000.218] I/bit64_luatos.lua:90 double to int64 87654.32/12345.67= 7
+[2025-10-15 11:10:19.849][000000000.218] I/bit64_luatos.lua:96 0xc0000000 << 8 = 0xc000000000
+[2025-10-15 11:10:19.853][000000000.218] I/bit64_luatos.lua:97 0xc000000000+2= 0xc000000002
+[2025-10-15 11:10:19.860][000000000.219] I/bit64_luatos.lua:98 0xc000000000-2= 0xbffffffffe
+[2025-10-15 11:10:19.867][000000000.219] I/bit64_luatos.lua:99 0xc000000000*2= 0x18000000000
+[2025-10-15 11:10:19.871][000000000.219] I/bit64_luatos.lua:100 0xc000000000/2= 0x6000000000
+[2025-10-15 11:10:19.876][000000000.219] I/user.data 827E1601D711030000 18
+[2025-10-15 11:10:19.882][000000000.220] I/user.data 864040064024194
+[2025-10-15 11:10:19.887][000000000.220] I/user.work time 当前时间 0
+[2025-10-15 11:10:20.345][000000001.220] I/user.work time 当前时间 1
+```