LuatOS 课程-011 讲：GNSS应用开发

在物联网项目开发中，智能定位系统是一类常见且实用的应用场景，本文将基于 LuatOS，分享一款智能定位系统的开发思路与相关实现要点。
在实际开发过程中，类似学生卡定位器的需求十分普遍，这类需求通常对定位精度、设备续航能力、轨迹显示效果以及多平台适配性均有明确要求，而基于 LuatOS 的智能定位系统，可针对性解决这类开发需求中的核心痛点。

项目特点：

• 🛰️ 三合一定位：GNSS + 基站 + WiFi
• 🔋 续航：智能功耗管理，运动才定位
• 🛣️ 轨迹优化：减少80%GPS静态漂移以及运动漂移，路线更符合真实路径
• 🌐 多平台兼容：一次开发，同时上报多个服务器
• 🎯 工业标准：完整JT808协议实现
• 🚩特点：exgnss扩展库和exvib扩展库

适合场景：

• 👨🎓 学生安全卡、老人定位器
• 🐕 宠物追踪、牲畜管理
• 🚗 车辆监控、物流追踪
• 📦 资产定位、贵重物品跟踪

前言

当前项目为演示项目，使用到的web平台为合宙自建的内部服务器，暂时不对外开放，此项目仅仅是为了给大家演示一下exgnss扩展库和exvib库如何融入到定位器相关项目内，也会重点讲解gnss应用场景有关的代码和业务逻辑，至于后期如何开放该平台等事宜，等待内部讨论后给出。

项目功能：

1. 经纬度数据、电量、卫星信号质量、速度、电池状态(充电中/未充电)等数据上报到合宙定位测试服务器
2. 根据服务器下发的指令 进入/退出快速定位模式
3. 功耗优化，区分运动和静止状态

项目需求：

1. 由Air8000A内部加速度传感器判断是否开启/关闭GNSS
2. 按照JT808协议和服务器进行通讯
3. 可以上传多个服务器(为后期做拓展)
4. 尽可能的减少静态/动态漂移带来的轨迹失真
5. 与服务器直接保持长连接状态，并且尽可能的做到功耗最低

使用到的最为重要的两个扩展库介绍：

exgnss：

exgnss库实际上是把底层提供的libgnss接口封装了一层，让配置过程更快速一点，更方便用户快速上手，exgnss库最重要的三个接口为：

1exgnss.setup(gnssotps) --配置GNGSS输出相关
2exgnss.open(mode,para)--硬件层面打开GNSS
3exgnss.close(mode,para)--硬件层面关闭GNSS
4

至于这三个接口的具体使用方法，以及传参，这里有接口/参数说明以及demo示例，后面项目中也用到了，这里带大家简单过一次。就不做赘述了

常量定义：

exgnss.DEFAULT

1常量含义：exgnss应用模式1,常开模式；
2数据类型：number；
3示例代码：--- exgnss应用模式1.
4        -- 打开gnss后，gnss定位成功时，如果有回调函数，会调用回调函数
5        -- 使用此应用模式调用exgnss.open打开的“gnss应用”，必须主动调用exgnss.close
6        -- 或者exgnss.close_all才能关闭此“gnss应用”,主动关闭时，即使有回调函数，也不会调用回调函数
7        -- 通俗点说就是一直打开，除非自己手动关闭掉
8        local function mode_cb(tag)
9            log.info("TAGmode_cb+++++++++",tag)
10            log.info("nmea", "rmc", json.encode(exgnss.rmc(2)))
11        end
12        exgnss.open(exgnss.DEFAULT,{tag="MODE",cb=mode_cb})
13

本简易定位器demo中用到的就是这个常量

还有**exgnss.TIMERORSUC(**到规定时间或者GNSS定位成功后[开拓地带约为35S]关闭GNSS)和

exgnss.TIMER[到规定时间就关，不管GNSS定位成功与否]

1exgnss=require("exgnss")  --因为是扩展库不是核心库 所以需要require(类似C语言中的#incloud)
2
3local function mode_cb(tag)
4    log.info("定位应用的回调函数",tag)
5    log.info("让我看看当前经纬度", json.encode(exgnss.rmc(2)))
6end
7
8local function gnss_fnc()
9    local gnssotps={
10        gnssmode=1, --1为卫星全定位，2为单北斗
11        agps_enable=true,    --是否使用AGPS，开启AGPS后定位速度更快，会访问服务器下载星历，对Air8000来说，星历时效性：北斗1小时，GPS2小时，默认下载星历的时间为1小时，即一小时内只会下载一次
12        debug=true,    --是否输出调试信息(GNSS芯片输出的nmea数据)
13
14     --其他参数用户可以看接口说明，本demo中用不到其他参数
15    }
16     --设置gnss参数
17    exgnss.setup(gnssotps)
18    --开启gnss应用，到规定的60S就关闭，不管定位成功与否
19    exgnss.open(exgnss.TIMER,{tag="用户自定义应用名",val=60,cb=mode_cb})  --使用TIMER模式，开启60s后关闭
20
21    sys.wait(40000)
22    log.info("关闭一个gnss应用")
23    --关闭一个gnss应用
24    exgnss.close(exgnss.TIMER,{tag="用户自定义应用名"})--关闭tag为“用户自定义应用名”应用
25    --查询gnss应用状态
26    log.info("gnss应用状态",exgnss.is_active(exgnss.TIMER,{tag="用户自定义应用名"}))
27    sys.wait(10000)
28    --关闭所有gnss应用
29    exgnss.close_all()
30    --查询最后一次定位结果
31    local loc= exgnss.last_loc()
32    if loc then
33        log.info("lastloc", loc.lat,loc.lng)
34    end
35end
36
37sys.taskInit(gnss_fnc)
38
39
40--GNSS定位状态的消息处理函数：
41local function gnss_state(event, ticks)
42    -- event取值有
43    -- "FIXED"：string类型 定位成功
44    -- "LOSE"： string类型 定位丢失
45    -- "CLOSE": string类型 GNSS关闭，仅配合使用exgnss.lua有效
46    -- ticks number类型 是事件发生的时间,一般可以忽略
47    log.info("exgnss", "state", event)
48    if event=="FIXED" then
49        --获取rmc数据
50        --json.encode默认输出"7f"格式保留7位小数，可以根据自己需要的格式调整小数位，本示例保留5位小数
51        log.info("nmea", "rmc0", json.encode(exgnss.rmc(0),"5f"))
52    end
53end
54sys.subscribe("GNSS_STATE",gnss_state)
55

exvib：

exvib库实际上是操作了Air780EGP/Air780EGG/Air780EGH/Air8000A/Air8000AB/Air8000N/Air8000U/Air8000D/Air8000DB模组内的一颗G-Sensor加速度传感器，模组内部硬件具体怎么接的，咱们这个项目中无需关心，exvib库的三种模式主要用于以下场景：

1. 微小震动检测:用于检测轻微震动的场景,例如用手敲击桌面,加速度量程2g；
2. 运动检测:用于电动车或汽车行驶时的检测和人行走和跑步时的检测,加速度量程4g
3. 跌倒检测:用于人或物体瞬间跌倒时的检测,加速度量程8g

咱们这个项目 使用的就是运动检测，exvib库就三个接口，分别为：

1exvib.read_xyz()--读三轴（G-Sensor）传过来的XYZ轴数据
2exvib.open(mode)--打开三轴（G-Sensor）
3exvib.close()--关闭三轴（G-Sensor）
4

exvib库完整的说明可以看这里，后面项目具体代码中也有，这三个接口不难理解，唯一注意的一点是exvib.open这个接口

exvib.open(mode)

1参数含义：加速度传感器的应用模式；
2数据类型：number；
3取值范围：
41 - 微小震动检测，用于检测轻微震动的场景，例如用手敲击桌面，加速度量程2g；
52 - 运动检测，用于电动车或汽车行驶时的检测和人行走和跑步时的检测，加速度量程4g；
63 - 跌倒检测，用于人或物体瞬间跌倒时的检测，加速度量程8g；
7是否必选：是；
8

第一部分：项目整体架构

1.1 模块化架构设计

架构特点：

1. 分层设计：

• 定位核心层：commom（管理了exgnss和trackCompensate）
• 传感器层：vibration(三轴)
• 电源管理层：charge、manage
• 通讯协议层：api、jt808
• 服务器层：srvs、auxServer
• 具体后面讲代码的时候会一个个lua文件打开，仔细说明，这里就不做过多赘述了

2. 事件驱动：

1-- 发布订阅模式，完全解耦
2sys.publish("SYS_STATUS_RUN")      -- 运动事件
3sys.subscribe("GNSS_STATE", fn)    -- 定位状态变化
4sys.waitUntil("IP_READY", 10000)   -- 等待网络就绪
5

3. 配置驱动：

1-- cfg.lua 统一管理所有配置
2_G.GNSS_LOWPOWER_ENABLE = true -- 低功耗开关
3_G.GNSS_LOWPOWER_INTERVAL = 60 -- 定位间隔(单位：S)
4-- 轨迹补偿参数
5trackCompensate.setConfig({
6    scene = "person", -- 人员模式
7    autoAdaptive = true, -- 自动适应
8    distanceThreshold = 50 -- 漂移过滤阈值
9})
10

4. gnss应用场景****管理：

1-- 避免资源冲突，智能管理GNSS
2exgnss.open(exgnss.DEFAULT, {tag = "common_app"})
3exgnss.open(exgnss.TIMERORSUC, {tag = "lowpower"})
4-- 两个tag都关闭时，GNSS才真正关闭
5

1.2 核心模块介绍

第二部分：智能定位状态机

一、什么是状态机

​ 状态机的全称叫做有限状态机，是计算机的运行的基本的元素。

​ 状态机由三个要素组成：

​ 1，有限个状态，

​ 2，触发状态迁移的事件，

​ 3，不同状态之间迁移的逻辑。

​ 我们在设计软件之前，先把系统的状态机设计清楚， 再开发软件，可以使得软件更容易评审，也更容易编写测试用例，多人的协作也会更加容易。

​ 状态机设计清楚之后， 可以让产品经理，研发工程师，项目经理，测试，形成了统一的话语体系，基于状态机，以及状态机下的各个参数的沟通， 变得高效，简单。

二、设备的定位状态机

用我们现在正在讲解的项目为例， 状态机如下：

1、 4个状态描述

（1）捕获GPS

​ 没有GPS定位成功，并且设备是运动的，设备都会处于捕获状态。

​ 这是设备最耗电的一个状态。

（2）追踪GPS

​ 捕获成功后，进入追踪状态，追踪状态比捕获省电一些。

（3）静止GPS

​ 追踪状态下，检测到设备静止，就进行静止GPS，这个时候，关闭GPS，上报最近一次的GPS位置。

（4）LBS定位状态

​ 捕获失败，并且设备静止，进入 LBS 状态，上报 LBS 和 wifi 的信息，服务器端进行基站和WIFI的组合定位。

2、触发状态迁移的事件

（1）捕获成功；

（2）捕获失败；

（3）追踪过程中丢GPS；

（4）静止；

（5）运动；

（6）按键

（7）收到服务器的指令

3、 状态迁移的逻辑

三、状态机设计理念

核心问题：如何平衡定位精度与功耗？

合宙的方案：智能切换 → 精度够用且续航长（一周）

2.2 各状态详细逻辑

CAPTURE模式 - 定位捕获

1-- 代码位置：common.lua 第200-250行
2function captureMode()
3    logF("========== 进入CAPTURE模式 ==========")
4
5    -- 1. 打开GNSS，启用AGPS
6    exgnss.open(exgnss.DEFAULT, {
7        tag = "common_app"
8    })
9
10    -- 2. WiFi扫描辅助定位
11    wlan.scan()
12
13    -- 3. 最多尝试10次（首次）或4次（后续）
14    for i = 1, maxAttempts do
15        srvs.dataSend() -- 触发定位数据采集-- 等待定位结果
16        local result = sys.waitUntil("GNSS_STATE", 3000)
17        if result == "FIXED" or exgnss.is_fix() then
18            logF("定位成功！耗时", i * 3, "秒")
19            return "TRACKING" -- 进入追踪模式
20        end
21        logF("定位尝试", i, "/", maxAttempts, "失败")
22    end
23    -- 4. 定位失败处理
24    if not manage.isRun() then -- 静止状态
25        logF("静止状态，降级到基站定位")
26        return "STATIC_LBS"
27    else
28        logF("运动状态，继续尝试")
29        return "CAPTURE" -- 继续尝试
30    end
31end
32

TRACKING模式 - 运动追踪

1-- 关键特性：
2-- 1. 1Hz定位频率，实时性高
3-- 2. 自动轨迹补偿，减少漂移
4-- 3. 双模式上传：正常5分钟/快速3秒
5-- 4. 智能休眠检测：20秒无震动
6-- 上传频率控制
7if fastUpload then -- 快速模式：3秒/次（紧急情况）
8    srvs.dataSend() -- 立即上传
9else -- 正常模式：缓存+批量上传
10    if waitUploadTimes >= 30 then -- 约5分钟
11        uploadCache() -- 批量上传缓存数据
12    end
13end
14

STATIC模式 - 静止优化

1-- STATIC_GNSS：使用最后有效位置
2-- STATIC_LBS：使用基站定位（GNSS失败时）
3-- 共同特点：
4-- 1. 关闭GNSS，功耗降至1mA
5-- 2. 定期心跳保持连接
6-- 3. 运动立即唤醒，无感知切换
7

2.3 状态切换条件表

第三部分：轨迹补偿算法详解

3.1 GPS为什么需要补偿？

现场演示：请大家看这张图，红色框为原始GPS轨迹：

问题根源(上一节也讲过了)：

1. 多路径效应：信号反射，误差10-50米
2. 卫星几何：仰角低时误差大
3. 大气延迟：电离层影响
4. 时钟误差：接收机时钟不准

3.2 四层补偿算法

3.3 核心算法代码解析

算法1：距离阈值过滤

1-- trackCompensate.lua 第80-120行
2local function distanceFilter(lat, lng, params)
3    if #historyBuffer == 0 then
4        return lat, lng -- 无历史数据，直接使用
5    end
6
7    local last = historyBuffer[#historyBuffer]
8    local distance = calculateDistance(last.lat, last.lng, lat, lng)
9    -- 自适应阈值：人员50米，车辆200米
10    local threshold = params.distanceThreshold
11    if distance > threshold then
12        logF("漂移点过滤：距离", distance, "米 > 阈值", threshold, "米")
13        return last.lat, last.lng -- 返回历史位置
14    end
15    return lat, lng -- 正常点
16end
17

算法2：航向平滑（解决360°跳变）

1-- 关键问题：359° → 1° 实际只变了2°，但差值算成358°
2-- 解决方案：使用三角函数处理角度循环
3local function smoothCourse(currentCourse, historyCourses)
4    local sumSin = 0
5    local sumCos = 0
6    -- 加权平均，最近的数据权重高
7    for i, course in ipairs(historyCourses) do
8        local weight = 1.0 / (i + 1) -- 权重递减
9        sumSin = sumSin + math.sin(math.rad(course)) * weight
10        sumCos = sumCos + math.cos(math.rad(course)) * weight
11    end
12    -- 计算平均航向
13    local avgCourse = math.deg(math.atan2(sumSin, sumCos))
14    avgCourse = (avgCourse + 360) % 360 -- 确保0-360范围
15    -- 检查是否跳变
16    local diff = math.abs(currentCourse - avgCourse)
17    if diff > 180 then
18        diff = 360 - diff
19        -- 处理循环
20    end
21    if diff > params.courseChangeThreshold then
22        logF("航向跳变补偿：", currentCourse, "→", avgCourse)
23        return avgCourse
24    end
25    return currentCourse
26end
27

算法3：速度突变过滤

1-- 原理：GNSS速度有时会从0突然跳到30km/h
2-- 验证：用实际位移计算的速度更可靠
3local function smoothSpeed(gnssSpeed, distance, timeDiff)
4    -- 计算基于位移的实际速度
5    local displacementSpeed = 0
6    if timeDiff > 0 then
7        displacementSpeed = (distance / timeDiff) * 3.6 -- m/s → km/h
8    end
9    -- 差异过大时，使用位移速度
10    local speedDiff = math.abs(gnssSpeed - displacementSpeed)
11    if speedDiff > params.speedChangeThreshold then
12        logF("速度突变：GNSS=", gnssSpeed, "位移=", displacementSpeed, "差值=", speedDiff)
13        return displacementSpeed
14    end
15    return gnssSpeed
16end
17

算法4：拐点补偿

1-- 解决急转弯被拉直的问题
2local function cornerCompensation(lat, lng, bearing, speed)
3    -- 1. 检测转弯角度
4    local angleDiff = calculateAngleDifference()
5
6    -- 2. 急转弯判定（人员120°，车辆90°）
7    if angleDiff > params.cornerAngleThreshold then
8        -- 3. 沿当前航向预测位置
9        local distance = (speed / 3.6) * 3
10        -- 假设3秒间隔
11        local estimatedLat = lat + (distance / 6371000) * math.cos(math.rad(bearing))
12        local estimatedLng = lng + (distance / 6371000) * math.sin(math.rad(bearing)) / math.cos(math.rad(lat))
13
14        -- 4. 检查预测位置是否合理
15        local predictionError = calculateDistance(lat, lng, estimatedLat, estimatedLng)
16        if predictionError < params.distanceThreshold then
17            logF("拐点补偿：角度", angleDiff, "°")
18            return estimatedLat, estimatedLng
19        end
20    end
21    return lat, lng
22end
23

3.4 双场景自适应系统

1-- 人员模式 vs 车辆模式
2local config = {
3    scene = "person", -- 默认人员模式
4    autoAdaptive = true, -- 自动切换
5    personParams = {
6        distanceThreshold = 50, -- 50米漂移过滤
7        speedChangeThreshold = 10, -- 10km/h速度突变
8        courseChangeThreshold = 60, -- 60°航向跳变
9        cornerAngleThreshold = 120 -- 120°急转弯
10    },
11    vehicleParams = {
12        distanceThreshold = 200, -- 200米漂移过滤
13        speedChangeThreshold = 50, -- 50km/h速度突变
14        courseChangeThreshold = 30, -- 30°航向跳变
15        cornerAngleThreshold = 90 -- 90°急转弯
16    },
17
18    adaptiveSpeedThreshold = 15 -- 15km/h切换阈值
19}
20
21-- 自动场景判断
22local function getCurrentParams()
23    if config.autoAdaptive and #historyBuffer >= 3 then
24        -- 计算最近3个点的平均速度
25        local avgSpeed = 0
26        for i = #historyBuffer - 2, #historyBuffer do
27            avgSpeed = avgSpeed + historyBuffer[i].speed
28        end
29        avgSpeed = avgSpeed / 3
30        if avgSpeed >= config.adaptiveSpeedThreshold then
31            logF("自动切换：车辆模式（速度", avgSpeed, "km/h）")
32            return config.vehicleParams
33        else
34            logF("自动切换：人员模式（速度", avgSpeed, "km/h）")
35            return config.personParams
36        end
37    end
38    -- 固定模式
39    return config.scene == "vehicle" and config.vehicleParams or config.personParams
40end
41

3.5 优化效果对比

测试数据：

1原始轨迹数据：
2  点1: 31.123456, 121.654321, 速度5, 航向180
3  点2: 31.123500, 121.654300, 速度25, 航向185 ← 速度突变！
4  点3: 31.123800, 121.654000, 速度6, 航向359 ← 航向跳变！
5
6优化后数据：
7  点1: 31.123456, 121.654321, 速度5, 航向180
8  点2: 31.123480, 121.654310, 速度5, 航向182 ← 速度修正
9  点3: 31.123520, 121.654280, 速度5, 航向181 ← 航向修正
10

量化提升：

第四部分：功耗优化策略

4.1 三层功耗管理架构

1-- 第一层：硬件级控制
2-- 引用计数管理，避免资源冲突
3local function hardwarePowerControl() -- 不同模块使用独立tag
4    exgnss.open(exgnss.DEFAULT, {
5        tag = "common_app"
6    }) -- 主定位
7    exgnss.open(exgnss.TIMERORSUC, {
8        tag = "lowpower"
9    }) -- 低功耗模式
10    -- 只有所有tag都关闭，硬件才真正断电
11    -- 避免：A模块关闭影响B模块使用
12end
13-- 第二层：应用级控制
14-- 状态机自动切换
15local function applicationPowerControl()
16    -- TRACKING模式：GNSS常开
17    -- STATIC模式：GNSS关闭
18    -- 根据运动状态自动调整
19    if manage.isRun() then
20        logF("运动状态，保持GNSS开启")
21    else
22        logF("静止状态，关闭GNSS节省功耗")
23        exgnss.close(exgnss.DEFAULT, {
24            tag = "common_app"
25        })
26    end
27end
28-- 第三层：系统级控制
29-- 统一休眠管理
30local function systemPowerControl() -- manage模块引用计数
31    manage.wake("READ_GNSS_DATA") -- 读取数据时唤醒
32    manage.sleep("READ_GNSS_DATA") -- 读取完成后休眠
33
34    manage.wake("charge") -- 充电时唤醒
35    manage.sleep("charge") -- 充电结束休眠
36    -- 检查所有tag，全部休眠时进入低功耗模式
37    local allSleeping = true
38    for tag, state in pairs(manage.tags) do
39        if state > 0 then
40            allSleeping = false
41            break
42        end
43    end
44    if allSleeping then
45        pm.power(pm.WORK_MODE, 1) -- 进入长连接低功耗模式休眠
46        logF("所有模块休眠，进入LIGHT模式")
47    end
48end
49

4.2 震动检测优化算法

1-- vibration.lua 核心逻辑
2local function vibrationOptimization()
3-- 静止→运动：快速响应（5秒内2次震动）
4-- 避免误判：防止偶尔震动误触发
5-- 运动→静止：延迟确认（20秒内0次震动）
6-- 避免误判：防止行走时停顿误判为静止
7-- 有效震动检测：10秒内5次震动
8-- 防止误触：过滤无效震动（如放口袋里的晃动）
9-- 冷却机制：有效震动后30分钟内不再重复触发
10-- 避免频繁：如车辆持续震动场景
11end
12

优化空间：

1. 进一步降低GNSS功耗：按需定位
2. 优化网络连接：心跳间隔调整
3. 深度休眠：夜间完全关闭

第五部分：数据通信架构及代码完整实现

5.1 JT808协议完整实现

5.2 数据包结构详解

1
2-- JT808 0x0200 位置信息报文结构
3local function buildPositionPacket()
4    -- 1. 消息头（12字节）
5    local header = api.NumToBigBin(0x0200, 2) -- 消息ID
6    .. api.NumToBigBin(bodyLen, 2) -- 消息体属性
7    .. simID -- 终端手机号（6字节BCD）
8    .. api.NumToBigBin(msgSn, 2) -- 消息流水号
9
10    -- 2. 消息体基础部分（28字节）
11    local body = api.NumToBigBin(0, 4) -- 报警标志
12    .. api.NumToBigBin(status, 4) -- 状态位
13    .. api.NumToBigBin(lat, 4) -- 纬度（度*1000000）
14    .. api.NumToBigBin(lng, 4) -- 经度（度*1000000）
15    .. api.NumToBigBin(altitude, 2) -- 海拔（米）
16    .. api.NumToBigBin(speed, 2) -- 速度（0.1km/h）
17    .. api.NumToBigBin(course, 2) -- 方向（度）
18    .. timeBCD -- 时间（6字节BCD）
19
20    -- 3. 扩展信息（附加项）
21    -- 里程信息
22    body = body .. api.NumToBigBin(0x01, 1) -- 附加项ID
23    .. api.NumToBigBin(4, 1) -- 长度4字节
24    .. api.NumToBigBin(mileage, 4) -- 里程值
25
26    -- 电量信息
27    body = body .. api.NumToBigBin(0x04, 1) -- 附加项ID
28    .. api.NumToBigBin(2, 1) -- 长度2字节
29    .. api.NumToBigBin(chargeState, 1) -- 充电状态
30    .. api.NumToBigBin(batteryPercent, 1) -- 电量百分比
31
32    -- WiFi信息（如有）
33    if wifiList and #wifiList > 0 then
34        body = body .. api.NumToBigBin(0x54, 1) -- WiFi附加项
35        .. buildWifiInfo(wifiList)
36    end
37
38    -- 4. 组装完整报文
39    local packet = header .. body
40    packet = packet .. string.char(api.XorCheck(packet)) -- 校验码
41    packet = msgEncode(packet) -- 转义处理
42    packet = "\x7E" .. packet .. "\x7E" -- 添加起始结束符
43
44    return packet
45end
46

5.3 多服务器管理架构

1local srvs = {
2    servers = {}, -- 服务器实例列表-- 添加服务器
3    add = function(self, server)
4        table.insert(self.servers, server)
5        logF("添加服务器，当前数量:", #self.servers)
6    end,
7
8    -- 发送数据到所有服务器
9    dataSend = function(self, data)
10        logF("========== 开始发送数据 ==========")
11
12        -- 数据预处理和日志
13        if data then
14            self:_logDataInfo(data)
15        else
16            logF("数据为空，自动调用common.monitorRecord()")
17            data = common.monitorRecord()
18        end -- 分发到所有服务器
19        local successCount = 0
20        for i, srv in ipairs(self.servers) do
21            if srv.dataSend then
22                local ok, err = pcall(srv.dataSend, data)
23                if ok then
24                    successCount = successCount + 1
25                    logF("服务器", i, "发送成功")
26                else
27                    logF("服务器", i, "发送失败:", err)
28                end
29            end
30        end
31
32        logF("发送完成，成功:", successCount, "/", #self.servers)
33        return successCount
34    end,
35
36    -- 检查连接状态（任意一个连接成功即返回true）
37    isConnected = function(self)
38        for _, srv in ipairs(self.servers) do
39            if srv.isConnected and srv.isConnected() then
40                return true
41            end
42        end
43        return false
44    end
45}
46
47-- 使用示例
48local auxServer = require "auxServer"
49local productionServer = require "productionServer"
50
51srvs:add(auxServer) -- 测试服务器
52srvs:add(productionServer) -- 生产服务器
53-- 一次调用，多处发送
54srvs:dataSend(positionData)
55

5.4 数据上传频率控制

1-- 双模式上传策略
2local uploadConfig = {
3    normal = {
4        interval = 5 * 60, -- 5分钟
5        cacheSize = 30, -- 缓存30次后上传
6        description = "正常模式：平衡功耗与实时性"
7    },
8
9    fast = {
10        interval = 3, -- 3秒
11        immediate = true, -- 立即上传
12        description = "快速模式：紧急追踪场景"
13    }
14}
15
16-- 模式切换接口
17function common.setfastUpload(duration)
18    if duration > 0 then -- 进入快速上传模式
19        logF("进入快速上传模式，持续", duration, "分钟")
20        fastUpload = true -- 立即触发一次上传
21        srvs.dataSend()
22
23        -- 定时自动退出
24        sys.timerStart(function()
25            fastUpload = false
26            logF("快速上传模式结束")
27        end, duration * 60 * 1000)
28    else -- 退出快速上传模式
29        fastUpload = false
30        logF("退出快速上传模式")
31    end
32end
33-- 触发方式
34-- 1. 服务器指令：0x8202消息设置上传间隔
35-- 2. 本地逻辑：检测到特殊场景（如放学时间）
36-- 3. 手动调用：
37common.setfastUpload(10)
38