跳转至

13 64位数据处理

作者：沈园园

一、64 位数据处理概述

目前合宙主推产品的LuatOS固件都有32位和64位两类；

本核心库bit64描述的是：32位系统固件上对64位数据的基本算术运算和逻辑运算；

如果你的项目一定要使用32位内核固件，并且用到了64位数据操作，可以阅读参考本核心库描述的内容；

如果你的项目使用64位内核固件，则可以按照正常的思路，对64位数据运算即可，不用阅读参考本核心库描述的内容；

32位内核固件和64位内核固件的唯一区别是是否支持64位数据的直接运算，其余功能完全相同，根据自己的项目需求来决定选择何种内核固件；

32 位数据: 可以表示的数值范围较小（4 字节），对于整数数据类型，一般范围是 (-2^{31}) 到 (2^{31}-1)（有符号整数）或 (0) 到 (2^{32}-1)（无符号整数）。

64 位数据: 有更大的表示范围（8 字节），整数类型通常可以表示 (-2^{63}) 到 (2^{63}-1)（有符号整数）或 (0) 到 (2^{64}-1)（无符号整数）。

处理更大的数据位宽通常会增加功耗，因为需要更大的数据总线和更复杂的运算电路。对于一些低功耗的嵌入式系统，选择 32 位数据会有助于降低功耗。

二、演示功能概述

演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算。

三、准备硬件环境

1、Air780EHV核心板一块

2、TYPE-C USB数据线一根

3、Air780EHV核心板和数据线的硬件接线方式为

  • Air780EHV核心板通过TYPE-C USB口连接TYPE-C USB 数据线，数据线的另外一端连接电脑的USB口；
  • 核心板正面的 ON/OFF 拨动开关 拨到ON一端；

四、准备软件环境

4.1 软件环境

在开始实践本示例之前，先筹备一下软件环境：

1、烧录工具：Luatools 下载调试工具

2、内核固件：Air780EHV 最新版本的内核固件

3、脚本文件：https://gitee.com/openLuat/LuatOS/tree/master/module/Air780EHM_Air780EHV_Air780EGH/demo/bit64

4、lib脚本文件：使用Luatools烧录时，勾选 添加默认lib 选项，使用默认lib脚本文件

准备好软件环境之后，接下来查看如何烧录项目文件到Air780EHV核心板，将本篇文章中演示使用的项目文件烧录到780EHV核心板中。

4.2 API 介绍

bit64 库：https://docs.openluat.com/osapi/core/bit64/

五、程序结构

bit64/
│── main.lua
│── bit64_app.lua
│── readme.md

5.1 文件说明

  1. main.lua：主程序入口文件。
  2. bit64_app.lua：32 位系统上对 64 位数据的基本算术运算和逻辑运算。

六、代码详解

6.1 main.lua

主程序文件 main.lua 是整个项目的入口点。它负责初始化系统环境。

6.2 bit64_app.lua

演示在 32 位系统上对 64 位数据的基本算术运算和逻辑运算

6.2.1 将数据进行 32 位和 64 位互转

--将数据进行 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)

6.2.2 64 位数据之间进行运算

--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)))

6.2.3 64 位与 32 位数据之间进行运算

--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)))

6.2.4 64 位数据之间，一个数是浮点数进行运算

--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)))

6.2.5 64 位浮点数计算

--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)))

6.2.6 64 位数据移位操作

--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)

6.2.7 将字符串转为 LongLong 数据

--将字符串转为 LongLong 数据
if bit64.strtoll then
    local data = bit64.strtoll("864040064024194", 10)
    log.info("data", data:toHex())
    log.info("data", bit64.show(data))
end

6.2.8 获取高精度 tick，输出转换好的 64 位结构

--获取高精度 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

七、运行结果展示

出现类似于下面的日志，就表示运行成功：

[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

八、总结

演示了 32 位与 64 位数据的转换，64 位与 64 位数据之间的计算，64 位与 32 位数据之间的计算。